Feat/tx gateway

contracts/deploy/18_deploy_RollupRevenueVaultWithReinitialization.ts

@@ -1,21 +1,10 @@
 import { DeployFunction } from "hardhat-deploy/types";
-import { HardhatRuntimeEnvironment } from "hardhat/types";
-import { tryVerifyContract, getDeployedContractAddress, getRequiredEnvVar } from "../common/helpers";
+import { tryVerifyContract, getRequiredEnvVar } from "../common/helpers";
 import { ethers, upgrades } from "hardhat";
 import { RollupRevenueVault__factory } from "contracts/typechain-types";
 
-const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
-  const { deployments } = hre;
-
+const func: DeployFunction = async function () {
   const contractName = "RollupRevenueVault";
-  const existingContractAddress = await getDeployedContractAddress(contractName, deployments);
-
-  // RollupRevenueVault DEPLOYED AS UPGRADEABLE PROXY
-  if (!existingContractAddress) {
-    console.log(`Deploying initial version, NB: the address will be saved if env SAVE_ADDRESS=true.`);
-  } else {
-    console.log(`Deploying new version, NB: ${existingContractAddress} will be overwritten if env SAVE_ADDRESS=true.`);
-  }
 
   const proxyAddress = getRequiredEnvVar("ROLLUP_REVENUE_VAULT_ADDRESS");
 

contracts/deploy/19_deploy_L1LineaTokenBurner.ts

@@ -1,28 +1,13 @@
 import { ethers } from "hardhat";
 import { DeployFunction } from "hardhat-deploy/types";
-import { HardhatRuntimeEnvironment } from "hardhat/types";
-import {
-  getRequiredEnvVar,
-  getDeployedContractAddress,
-  LogContractDeployment,
-  tryVerifyContractWithConstructorArgs,
-} from "../common/helpers";
-
-const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
-  const { deployments } = hre;
+import { getRequiredEnvVar, LogContractDeployment, tryVerifyContractWithConstructorArgs } from "../common/helpers";
 
+const func: DeployFunction = async function () {
   const contractName = "L1LineaTokenBurner";
-  const existingContractAddress = await getDeployedContractAddress(contractName, deployments);
 
   const messageService = getRequiredEnvVar("LINEA_TOKEN_BURNER_MESSAGE_SERVICE");
   const lineaToken = getRequiredEnvVar("LINEA_TOKEN_BURNER_LINEA_TOKEN");
 
-  if (!existingContractAddress) {
-    console.log(`Deploying initial version, NB: the address will be saved if env SAVE_ADDRESS=true.`);
-  } else {
-    console.log(`Deploying new version, NB: ${existingContractAddress} will be overwritten if env SAVE_ADDRESS=true.`);
-  }
-
   const factory = await ethers.getContractFactory(contractName);
   const contract = await factory.deploy(messageService, lineaToken);
 

contracts/deploy/20_deploy_V3DexSwapAdapter.ts

@@ -1,30 +1,15 @@
 import { ethers } from "hardhat";
 import { DeployFunction } from "hardhat-deploy/types";
-import { HardhatRuntimeEnvironment } from "hardhat/types";
-import {
-  getRequiredEnvVar,
-  getDeployedContractAddress,
-  LogContractDeployment,
-  tryVerifyContractWithConstructorArgs,
-} from "../common/helpers";
-
-const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
-  const { deployments } = hre;
+import { getRequiredEnvVar, LogContractDeployment, tryVerifyContractWithConstructorArgs } from "../common/helpers";
 
+const func: DeployFunction = async function () {
   const contractName = "V3DexSwapAdapter";
-  const existingContractAddress = await getDeployedContractAddress(contractName, deployments);
 
   const router = getRequiredEnvVar("V3_DEX_SWAP_ADAPTER_ROUTER");
   const wethToken = getRequiredEnvVar("V3_DEX_SWAP_ADAPTER_WETH_TOKEN");
   const lineaToken = getRequiredEnvVar("V3_DEX_SWAP_ADAPTER_LINEA_TOKEN");
   const poolTickSpacing = getRequiredEnvVar("V3_DEX_SWAP_ADAPTER_POOL_TICK_SPACING");
 
-  if (!existingContractAddress) {
-    console.log(`Deploying initial version, NB: the address will be saved if env SAVE_ADDRESS=true.`);
-  } else {
-    console.log(`Deploying new version, NB: ${existingContractAddress} will be overwritten if env SAVE_ADDRESS=true.`);
-  }
-
   const factory = await ethers.getContractFactory(contractName);
   const contract = await factory.deploy(router, wethToken, lineaToken, poolTickSpacing);
 

contracts/deploy/21_deploy_AddressFilter.ts

@@ -0,0 +1,26 @@
+import { ethers } from "hardhat";
+import { DeployFunction } from "hardhat-deploy/types";
+import { LogContractDeployment, getRequiredEnvVar, tryVerifyContractWithConstructorArgs } from "../common/helpers";
+
+const func: DeployFunction = async function () {
+  const contractName = "AddressFilter";
+
+  const lineaRollupSecurityCouncil = getRequiredEnvVar("LINEA_ROLLUP_SECURITY_COUNCIL");
+  const filteredAddresses = getRequiredEnvVar("ADDRESS_FILTER_FILTERED_ADDRESSES").split(",");
+
+  const factory = await ethers.getContractFactory(contractName);
+  const contract = await factory.deploy(lineaRollupSecurityCouncil, filteredAddresses);
+
+  await LogContractDeployment(contractName, contract);
+  const contractAddress = await contract.getAddress();
+
+  const args = [lineaRollupSecurityCouncil, filteredAddresses];
+  await tryVerifyContractWithConstructorArgs(
+    contractAddress,
+    "src/rollup/forcedTransactions/AddressFilter.sol:AddressFilter",
+    args,
+  );
+};
+
+export default func;
+func.tags = ["AddressFilter"];

contracts/deploy/22_deploy_ForcedTransactionGateway.ts

@@ -0,0 +1,47 @@
+import { ethers } from "hardhat";
+import { DeployFunction } from "hardhat-deploy/types";
+import { LogContractDeployment, getRequiredEnvVar, tryVerifyContractWithConstructorArgs } from "../common/helpers";
+
+const func: DeployFunction = async function () {
+  const contractName = "ForcedTransactionGateway";
+
+  const lineaRollupAddress = getRequiredEnvVar("LINEA_ROLLUP_ADDRESS");
+  const destinationChainId = getRequiredEnvVar("FORCED_TRANSACTION_GATEWAY_L2_CHAIN_ID");
+  const l2BlockBuffer = getRequiredEnvVar("FORCED_TRANSACTION_GATEWAY_L2_BLOCK_BUFFER");
+  const maxGasLimit = getRequiredEnvVar("FORCED_TRANSACTION_GATEWAY_MAX_GAS_LIMIT");
+  const maxInputLengthBuffer = getRequiredEnvVar("FORCED_TRANSACTION_GATEWAY_MAX_INPUT_LENGTH_BUFFER");
+  const defaultAdmin = getRequiredEnvVar("LINEA_ROLLUP_SECURITY_COUNCIL");
+  const addressFilter = getRequiredEnvVar("FORCED_TRANSACTION_ADDRESS_FILTER");
+
+  const factory = await ethers.getContractFactory(contractName);
+  const contract = await factory.deploy(
+    lineaRollupAddress,
+    destinationChainId,
+    l2BlockBuffer,
+    maxGasLimit,
+    maxInputLengthBuffer,
+    defaultAdmin,
+    addressFilter,
+  );
+
+  await LogContractDeployment(contractName, contract);
+  const contractAddress = await contract.getAddress();
+
+  const args = [
+    lineaRollupAddress,
+    destinationChainId,
+    l2BlockBuffer,
+    maxGasLimit,
+    maxInputLengthBuffer,
+    defaultAdmin,
+    addressFilter,
+  ];
+  await tryVerifyContractWithConstructorArgs(
+    contractAddress,
+    "src/rollup/forcedTransactions/ForcedTransactionGateway.sol:ForcedTransactionGateway",
+    args,
+  );
+};
+
+export default func;
+func.tags = ["ForcedTransactionGateway"];

contracts/src/_testing/unit/libraries/Eip1559RlpEncoder.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @title Library for RLP Encoding EIP-1559 transactions.
+ * @author ConsenSys Software Inc.
+ * @custom:security-contact [email protected]
+ */
+pragma solidity ^0.8.30;
+
+import { RlpEncoder } from "../../../libraries/RlpEncoder.sol";
+
+/**
+ * @title Library for RLP Encoding a type 2 EIP-1559 transactions.
+ * @author ConsenSys Software Inc.
+ * @custom:security-contact [email protected]
+ */
+library Eip1559RlpEncoder {
+  /**
+   * @notice Supporting data for encoding an EIP-1559 transaction.
+   * @dev NB: ChainId is not on the struct to allow flexibility by the consuming contract.
+   * @dev NB: Access lists is assumed empty and does not appear here.
+   * @dev nonce The sender's nonce.
+   * @dev maxPriorityFeePerGas The max priority fee the user will pay.
+   * @dev maxFeePerGas The max fee per gas the user will pay.
+   * @dev gasLimit The limit of gas that the user is prepared to spend.
+   * @dev input The calldata input for the transaction.
+   * @dev accessList The access list used.
+   * @dev yParity The yParity in the signature.
+   * @dev r The r in the signature.
+   * @dev s The s in the signature.
+   */
+  struct Eip1559Transaction {
+    uint256 nonce;
+    uint256 maxPriorityFeePerGas;
+    uint256 maxFeePerGas;
+    uint256 gasLimit;
+    address to;
+    uint256 value;
+    bytes input;
+    RlpEncoder.AccessList[] accessList;
+    uint8 yParity;
+    uint256 r;
+    uint256 s;
+  }
+
+  /**
+   * @notice Internal function that encodes bytes correctly with length data.
+   * @param _chainId The chainId to encode with.
+   * @param _transaction The EIP-1559 transaction excluding chainId.
+   * @return rlpEncodedTransaction The RLP encoded transaction for submitting.
+   * @return transactionHash The expected transaction hash.
+   */
+  function _encodeEip1559Transaction(
+    uint256 _chainId,
+    Eip1559Transaction memory _transaction
+  ) internal pure returns (bytes memory rlpEncodedTransaction, bytes32 transactionHash) {
+    bytes[] memory fields = new bytes[](12);
+
+    fields[0] = RlpEncoder._encodeUint(_chainId);
+    fields[1] = RlpEncoder._encodeUint(_transaction.nonce);
+    fields[2] = RlpEncoder._encodeUint(_transaction.maxPriorityFeePerGas);
+    fields[3] = RlpEncoder._encodeUint(_transaction.maxFeePerGas);
+    fields[4] = RlpEncoder._encodeUint(_transaction.gasLimit);
+    fields[5] = RlpEncoder._encodeAddress(_transaction.to);
+    fields[6] = RlpEncoder._encodeUint(_transaction.value);
+    fields[7] = RlpEncoder._encodeBytes(_transaction.input);
+    fields[8] = RlpEncoder._encodeAccessList(_transaction.accessList);
+    fields[9] = RlpEncoder._encodeUint(_transaction.yParity);
+    fields[10] = RlpEncoder._encodeUint(_transaction.r);
+    fields[11] = RlpEncoder._encodeUint(_transaction.s);
+
+    rlpEncodedTransaction = abi.encodePacked(hex"02", RlpEncoder._encodeList(fields));
+    transactionHash = keccak256(rlpEncodedTransaction);
+  }
+}

contracts/src/_testing/unit/libraries/TestEip1559RlpEncoder.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity 0.8.30;
+
+import { Eip1559RlpEncoder } from "./Eip1559RlpEncoder.sol";
+
+contract TestEip1559RlpEncoder {
+  uint256 chainId;
+
+  constructor(uint256 _chainId) {
+    chainId = _chainId;
+  }
+
+  function encodeEip1559Transaction(
+    Eip1559RlpEncoder.Eip1559Transaction calldata _transaction
+  ) external view returns (bytes memory rlpEncodedTransaction, bytes32 transactionHash) {
+    (rlpEncodedTransaction, transactionHash) = Eip1559RlpEncoder._encodeEip1559Transaction(chainId, _transaction);
+  }
+}

contracts/src/_testing/unit/libraries/TestRlpEncoder.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: AGPL-3.0
+pragma solidity 0.8.30;
+
+import { RlpEncoder } from "../../../libraries/RlpEncoder.sol";
+
+contract TestRlpEncoder {
+  function encodeBool(bool _boolIn) external pure returns (bytes memory encodedBytes) {
+    return RlpEncoder._encodeBool(_boolIn);
+  }
+
+  function encodeString(string memory _stringIn) external pure returns (bytes memory encodedBytes) {
+    return RlpEncoder._encodeString(_stringIn);
+  }
+
+  function encodeInt(int _intIn) external pure returns (bytes memory encodedBytes) {
+    return RlpEncoder._encodeInt(_intIn);
+  }
+}

contracts/src/_testing/unit/rollup/TestLineaRollup.sol

@@ -2,10 +2,11 @@
 pragma solidity 0.8.30;
 
 import { LineaRollup } from "../../../rollup/LineaRollup.sol";
+import { FinalizedStateHashing } from "../../../libraries/FinalizedStateHashing.sol";
 
 /// @custom:oz-upgrades-unsafe-allow missing-initializer
 contract TestLineaRollup is LineaRollup {
-  function setFallbackOperatorAddress(address _fallbackOperator) external {
+  function setFallbackOperatorManually(address _fallbackOperator) external {
     fallbackOperator = _fallbackOperator;
   }
 
@@ -41,7 +42,28 @@ contract TestLineaRollup is LineaRollup {
     blobShnarfExists[_shnarf] = _finalBlockNumber;
   }
 
-  function setLastFinalizedState(uint256 _messageNumber, bytes32 _rollingHash, uint256 _timestamp) external {
-    currentFinalizedState = _computeLastFinalizedState(_messageNumber, _rollingHash, _timestamp);
+  function setLastFinalizedStateV6(uint256 _messageNumber, bytes32 _rollingHash, uint256 _timestamp) external {
+    currentFinalizedState = FinalizedStateHashing._computeLastFinalizedState(_messageNumber, _rollingHash, _timestamp);
+  }
+
+  function setLastFinalizedState(
+    uint256 _messageNumber,
+    bytes32 _rollingHash,
+    uint256 _forcedTransactionNumber,
+    bytes32 _forcedTransactionRollingHash,
+    uint256 _timestamp
+  ) external {
+    currentFinalizedState = FinalizedStateHashing._computeLastFinalizedState(
+      _messageNumber,
+      _rollingHash,
+      _forcedTransactionNumber,
+      _forcedTransactionRollingHash,
+      _timestamp
+    );
+  }
+
+  function setForcedTransactionBlockNumber(uint256 _blockNumber) external {
+    uint256 currentForcedTxNumber = nextForcedTransactionNumber++;
+    forcedTransactionL2BlockNumbers[currentForcedTxNumber] = _blockNumber;
   }
 }

contracts/src/interfaces/IGenericErrors.sol

@@ -16,4 +16,9 @@ interface IGenericErrors {
    * @dev Thrown when a parameter is the zero hash.
    */
   error ZeroHashNotAllowed();
+
+  /**
+   * @dev Thrown when a parameter is zero.
+   */
+  error ZeroValueNotAllowed();
 }

contracts/src/libraries/FinalizedStateHashing.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @title Library for computing the last finalized state on L1.
+ * @author ConsenSys Software Inc.
+ * @custom:security-contact [email protected]
+ */
+pragma solidity ^0.8.30;
+
+library FinalizedStateHashing {
+  /**
+   * @notice Internal function to compute and save the finalization state.
+   * @dev Using assembly this way is cheaper gas wise.
+   * @param _messageNumber Is the last L2 computed L1 message number in the finalization.
+   * @param _messageRollingHash Is the last L2 computed L1 rolling hash in the finalization.
+   * @param _forcedTransactionNumber Is the last processed forced transaction on L2's number.
+   * @param _messageRollingHash Is the last processed forced transaction on L2's rolling hash.
+   * @param _timestamp The final timestamp in the finalization.
+   */
+  function _computeLastFinalizedState(
+    uint256 _messageNumber,
+    bytes32 _messageRollingHash,
+    uint256 _forcedTransactionNumber,
+    bytes32 _forcedTransactionRollingHash,
+    uint256 _timestamp
+  ) internal pure returns (bytes32 hashedFinalizationState) {
+    assembly {
+      let mPtr := mload(0x40)
+      mstore(mPtr, _messageNumber)
+      mstore(add(mPtr, 0x20), _messageRollingHash)
+      mstore(add(mPtr, 0x40), _forcedTransactionNumber)
+      mstore(add(mPtr, 0x60), _forcedTransactionRollingHash)
+      mstore(add(mPtr, 0x80), _timestamp)
+      hashedFinalizationState := keccak256(mPtr, 0xa0)
+    }
+  }
+
+  /**
+   * @notice Internal function to compute and save the finalization state.
+   * @dev Using assembly this way is cheaper gas wise.
+   * @param _messageNumber Is the last L2 computed L1 message number in the finalization.
+   * @param _rollingHash Is the last L2 computed L1 rolling hash in the finalization.
+   * @param _timestamp The final timestamp in the finalization.
+   */
+  function _computeLastFinalizedState(
+    uint256 _messageNumber,
+    bytes32 _rollingHash,
+    uint256 _timestamp
+  ) internal pure returns (bytes32 hashedFinalizationState) {
+    assembly {
+      let mPtr := mload(0x40)
+      mstore(mPtr, _messageNumber)
+      mstore(add(mPtr, 0x20), _rollingHash)
+      mstore(add(mPtr, 0x40), _timestamp)
+      hashedFinalizationState := keccak256(mPtr, 0x60)
+    }
+  }
+}