@arbitrum/nitro-contracts 2.0.0 → 2.1.1-beta.0

package/src/mocks/HostioTest.sol

@@ -0,0 +1,196 @@
+// Copyright 2024, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.24;
+
+/*
+ * HostioTest is a test contract used to compare EVM with Stylus.
+ */
+contract HostioTest {
+    function exitEarly() external pure {
+        assembly {
+            stop()
+        }
+    }
+
+    function transientLoadBytes32(bytes32 key) external view returns (bytes32) {
+        bytes32 data;
+        assembly {
+            data := tload(key)
+        }
+        return data;
+    }
+
+    function transientStoreBytes32(bytes32 key, bytes32 value) external {
+        assembly {
+            // solc-ignore-next-line transient-storage
+            tstore(key, value)
+        }
+    }
+
+    function returnDataSize() external pure returns (uint256) {
+        uint256 size;
+        assembly {
+            size := returndatasize()
+        }
+        return size;
+    }
+
+    function emitLog(
+        bytes calldata _data,
+        int8 n,
+        bytes32 t1,
+        bytes32 t2,
+        bytes32 t3,
+        bytes32 t4
+    ) external {
+        bytes memory data = _data;
+        if (n == 0) {
+            assembly {
+                log0(add(data, 32), mload(data))
+            }
+        } else if (n == 1) {
+            assembly {
+                log1(add(data, 32), mload(data), t1)
+            }
+        } else if (n == 2) {
+            assembly {
+                log2(add(data, 32), mload(data), t1, t2)
+            }
+        } else if (n == 3) {
+            assembly {
+                log3(add(data, 32), mload(data), t1, t2, t3)
+            }
+        } else if (n == 4) {
+            assembly {
+                log4(add(data, 32), mload(data), t1, t2, t3, t4)
+            }
+        } else {
+            revert("invalid n for emit log");
+        }
+    }
+
+    function accountBalance(address account) external view returns (uint256) {
+        return account.balance;
+    }
+
+    function accountCode(address account) external view returns (bytes memory) {
+        uint256 size = 10000;
+        bytes memory code = new bytes(size);
+        assembly {
+            extcodecopy(account, add(code, 32), 0, size)
+            size := extcodesize(account)
+            mstore(code, size)
+        }
+        return code;
+    }
+
+    function accountCodeSize(address account) external view returns (uint256) {
+        uint256 size;
+        assembly {
+            size := extcodesize(account)
+        }
+        return size;
+    }
+
+    function accountCodehash(address account) external view returns (bytes32) {
+        bytes32 hash;
+        assembly {
+            hash := extcodehash(account)
+        }
+        return hash;
+    }
+
+    function evmGasLeft() external view returns (uint256) {
+        return gasleft();
+    }
+
+    function evmInkLeft() external view returns (uint256) {
+        return gasleft();
+    }
+
+    function blockBasefee() external view returns (uint256) {
+        return block.basefee;
+    }
+
+    function chainid() external view returns (uint256) {
+        return block.chainid;
+    }
+
+    function blockCoinbase() external view returns (address) {
+        return block.coinbase;
+    }
+
+    function blockGasLimit() external view returns (uint256) {
+        return block.gaslimit;
+    }
+
+    function blockNumber() external view returns (uint256) {
+        return block.number;
+    }
+
+    function blockTimestamp() external view returns (uint256) {
+        return block.timestamp;
+    }
+
+    function contractAddress() external view returns (address) {
+        return address(this);
+    }
+
+    function mathDiv(uint256 a, uint256 b) external pure returns (uint256) {
+        return a / b;
+    }
+
+    function mathMod(uint256 a, uint256 b) external pure returns (uint256) {
+        return a % b;
+    }
+
+    function mathPow(uint256 a, uint256 b) external pure returns (uint256) {
+        uint256 result;
+        assembly {
+            result := exp(a, b)
+        }
+        return result;
+    }
+
+    function mathAddMod(
+        uint256 a,
+        uint256 b,
+        uint256 c
+    ) external pure returns (uint256) {
+        return addmod(a, b, c);
+    }
+
+    function mathMulMod(
+        uint256 a,
+        uint256 b,
+        uint256 c
+    ) external pure returns (uint256) {
+        return mulmod(a, b, c);
+    }
+
+    function msgSender() external view returns (address) {
+        return msg.sender;
+    }
+
+    function msgValue() external payable returns (uint256) {
+        return msg.value;
+    }
+
+    function keccak(bytes calldata preimage) external pure returns (bytes32) {
+        return keccak256(preimage);
+    }
+
+    function txGasPrice() external view returns (uint256) {
+        return tx.gasprice;
+    }
+
+    function txInkPrice() external view returns (uint256) {
+        return tx.gasprice;
+    }
+
+    function txOrigin() external view returns (address) {
+        return tx.origin;
+    }
+}

package/src/precompiles/ArbSys.sol

@@ -29,7 +29,8 @@ interface ArbSys {
     function arbChainID() external view returns (uint256);
 
     /**
-     * @notice Get internal version number identifying an ArbOS build
+     * @notice Get internal version number identifying an ArbOS build, this is `55 + nitroArbOS version number`
+     *         e.g. on ArbOS 31 this would return 86. This is the only function that have the 55 offset.
      * @return version number as int
      */
     function arbOSVersion() external view returns (uint256);

package/src/precompiles/ArbWasm.sol

@@ -82,7 +82,7 @@ interface ArbWasm {
     /// @notice Gets the minimum costs to invoke a program
     /// @return gas amount of gas in increments of 256 when not cached
     /// @return cached amount of gas in increments of 64 when cached
-    function minInitGas() external view returns (uint8 gas, uint8 cached);
+    function minInitGas() external view returns (uint64 gas, uint64 cached);
 
     /// @notice Gets the linear adjustment made to program init costs.
     /// @return percent the adjustment (100% = no adjustment).

package/src/rollup/IRollupLogic.sol

@@ -24,7 +24,11 @@ interface IRollupUserAbs is IRollupCore, IOwnable {
 
     function confirmNextNode(bytes32 blockHash, bytes32 sendRoot) external;
 
-    function fastConfirmNextNode(bytes32 blockHash, bytes32 sendRoot) external;
+    function fastConfirmNextNode(
+        bytes32 blockHash,
+        bytes32 sendRoot,
+        bytes32 nodeHash
+    ) external;
 
     function stakeOnExistingNode(uint64 nodeNum, bytes32 nodeHash) external;
 

package/src/rollup/RollupCreator.sol

@@ -40,7 +40,6 @@ contract RollupCreator is Ownable {
         address nativeToken;
         bool deployFactoriesToL2;
         uint256 maxFeePerGasForRetryables;
-        //// @dev The address of the batch poster, not used when set to zero address
         address[] batchPosters;
         address batchPosterManager;
     }
@@ -92,11 +91,11 @@ contract RollupCreator is Ownable {
      * @dev - UpgradeExecutor should be the owner of proxyAdmin which manages bridge contracts
      * @dev - config.rollupOwner should have executor role on upgradeExecutor
      * @dev - Bridge should have a single inbox and outbox
-     * @dev - Validators and batch poster should be set if provided
+     * @dev - Validators, batch posters and batch poster manager should be set if provided
      * @param deployParams The parameters for the rollup deployment. It consists of:
      *          - config        The configuration for the rollup
-     *          - batchPoster   The address of the batch poster, not used when set to zero address
      *          - validators    The list of validator addresses, not used when set to empty list
+     *          - maxDataSize   Max size of the calldata that can be posted
      *          - nativeToken   Address of the custom fee token used by rollup. If rollup is ETH-based address(0) should be provided
      *          - deployFactoriesToL2 Whether to deploy L2 factories using retryable tickets. If true, retryables need to be paid for in native currency.
      *                          Deploying factories via retryable tickets at rollup creation time is the most reliable method to do it since it
@@ -104,7 +103,8 @@ contract RollupCreator is Ownable {
      *                          anyone can try to deploy factories and potentially burn the nonce 0 (ie. due to gas price spike when doing direct
      *                          L2 TX). That would mean we permanently lost capability to deploy deterministic factory at expected address.
      *          - maxFeePerGasForRetryables price bid for L2 execution.
-     *          - dataHashReader The address of the data hash reader used to read blob hashes
+     *          - batchPosters  The list of batch poster addresses, not used when set to empty list
+     *          - batchPosterManager The address which has the ability to rotate batch poster keys
      * @return The address of the newly created rollup
      */
     function createRollup(RollupDeploymentParams memory deployParams)

package/src/rollup/RollupUserLogic.sol

@@ -120,7 +120,7 @@ abstract contract AbsRollupUserLogic is
         bytes32 blockHash,
         bytes32 sendRoot,
         bool isFastConfirm
-    ) internal {
+    ) internal whenNotPaused {
         requireUnresolvedExists();
 
         uint64 nodeNum = firstUnresolvedNode();
@@ -159,11 +159,7 @@ abstract contract AbsRollupUserLogic is
      * @param blockHash The block hash at the end of the assertion
      * @param sendRoot The send root at the end of the assertion
      */
-    function confirmNextNode(bytes32 blockHash, bytes32 sendRoot)
-        external
-        onlyValidator
-        whenNotPaused
-    {
+    function confirmNextNode(bytes32 blockHash, bytes32 sendRoot) external onlyValidator {
         _confirmNextNode(blockHash, sendRoot, false);
     }
 
@@ -171,9 +167,15 @@ abstract contract AbsRollupUserLogic is
      * @notice This allow anyTrustFastConfirmer to confirm next node regardless of deadline
      *         the anyTrustFastConfirmer is supposed to be set only on an AnyTrust chain to
      *         a contract that can call this function when received sufficient signatures
+     *         node hash must be match the node to be confirmed to protect against reorgs
      */
-    function fastConfirmNextNode(bytes32 blockHash, bytes32 sendRoot) external whenNotPaused {
-        require(msg.sender == anyTrustFastConfirmer, "NOT_FAST_CONFIRMER");
+    function fastConfirmNextNode(
+        bytes32 blockHash,
+        bytes32 sendRoot,
+        bytes32 nodeHash
+    ) external {
+        require(msg.sender == anyTrustFastConfirmer, "NFC");
+        require(nodeHash == getNodeStorage(firstUnresolvedNode()).nodeHash, "WH");
         _confirmNextNode(blockHash, sendRoot, true);
     }