@arbitrum/nitro-contracts 2.0.0 → 3.0.0-alpha.0

package/src/precompiles/ArbWasm.sol

@@ -13,10 +13,9 @@ interface ArbWasm {
     /// @param program the program to activate
     /// @return version the stylus version the program was activated against
     /// @return dataFee the data fee paid to store the activated program
-    function activateProgram(address program)
-        external
-        payable
-        returns (uint16 version, uint256 dataFee);
+    function activateProgram(
+        address program
+    ) external payable returns (uint16 version, uint256 dataFee);
 
     /// @notice Gets the latest stylus version
     /// @return version the stylus version
@@ -24,36 +23,47 @@ interface ArbWasm {
 
     /// @notice Gets the stylus version the program with codehash was most recently activated against
     /// @return version the program version (reverts for EVM contracts)
-    function codehashVersion(bytes32 codehash) external view returns (uint16 version);
+    function codehashVersion(
+        bytes32 codehash
+    ) external view returns (uint16 version);
 
     /// @notice Extends a program's expiration date.
     /// Reverts if too soon or if the program is not up to date.
-    function codehashKeepalive(bytes32 codehash) external payable;
+    function codehashKeepalive(
+        bytes32 codehash
+    ) external payable;
 
     /// @notice Gets a program's asm size.
     /// Reverts if program is not active.
     /// @return size the size in bytes
-    function codehashAsmSize(bytes32 codehash) external view returns (uint32 size);
+    function codehashAsmSize(
+        bytes32 codehash
+    ) external view returns (uint32 size);
 
     /// @notice Gets the stylus version the program was most recently activated against
     /// @return version the program version (reverts for EVM contracts)
-    function programVersion(address program) external view returns (uint16 version);
+    function programVersion(
+        address program
+    ) external view returns (uint16 version);
 
     /// @notice Gets the cost to invoke the program
     /// @return gas the amount of gas
     /// @return gasWhenCached the amount of gas if the program was recently used
-    function programInitGas(address program)
-        external
-        view
-        returns (uint64 gas, uint64 gasWhenCached);
+    function programInitGas(
+        address program
+    ) external view returns (uint64 gas, uint64 gasWhenCached);
 
     /// @notice Gets the memory footprint of the program at the given address in pages
     /// @return footprint the memory footprint of program in pages (reverts for EVM contracts)
-    function programMemoryFootprint(address program) external view returns (uint16 footprint);
+    function programMemoryFootprint(
+        address program
+    ) external view returns (uint16 footprint);
 
     /// @notice Gets the amount of time remaining until the program expires
     /// @return _secs the time left in seconds (reverts for EVM contracts)
-    function programTimeLeft(address program) external view returns (uint64 _secs);
+    function programTimeLeft(
+        address program
+    ) external view returns (uint64 _secs);
 
     /// @notice Gets the conversion rate between gas and ink
     /// @return price the amount of ink 1 gas buys

package/src/precompiles/ArbWasmCache.sol

@@ -10,27 +10,37 @@ pragma solidity >=0.4.21 <0.9.0;
  */
 interface ArbWasmCache {
     /// @notice See if the user is a cache manager.
-    function isCacheManager(address manager) external view returns (bool);
+    function isCacheManager(
+        address manager
+    ) external view returns (bool);
 
     /// @notice Retrieve all address managers.
     /// @return managers the list of managers.
     function allCacheManagers() external view returns (address[] memory managers);
 
     /// @dev Deprecated, replaced with cacheProgram
-    function cacheCodehash(bytes32 codehash) external;
+    function cacheCodehash(
+        bytes32 codehash
+    ) external;
 
     /// @notice Caches all programs with a codehash equal to the given address.
     /// @notice Reverts if the programs have expired.
     /// @notice Caller must be a cache manager or chain owner.
     /// @notice If you're looking for how to bid for position, interact with the chain's cache manager contract.
-    function cacheProgram(address addr) external;
+    function cacheProgram(
+        address addr
+    ) external;
 
     /// @notice Evicts all programs with the given codehash.
     /// @notice Caller must be a cache manager or chain owner.
-    function evictCodehash(bytes32 codehash) external;
+    function evictCodehash(
+        bytes32 codehash
+    ) external;
 
     /// @notice Gets whether a program is cached. Note that the program may be expired.
-    function codehashIsCached(bytes32 codehash) external view returns (bool);
+    function codehashIsCached(
+        bytes32 codehash
+    ) external view returns (bool);
 
     event UpdateProgramCache(address indexed manager, bytes32 indexed codehash, bool cached);
 }

package/src/precompiles/ArbosTest.sol

@@ -10,5 +10,7 @@ pragma solidity >=0.4.21 <0.9.0;
 /// Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000069.
 interface ArbosTest {
     /// @notice Unproductively burns the amount of L2 ArbGas
-    function burnArbGas(uint256 gasAmount) external pure;
+    function burnArbGas(
+        uint256 gasAmount
+    ) external pure;
 }

package/src/rollup/AbsRollupEventInbox.sol

@@ -1,5 +1,5 @@
 // Copyright 2021-2022, Offchain Labs, Inc.
-// For license information, see https://github.com/nitro/blob/master/LICENSE
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
 // SPDX-License-Identifier: BUSL-1.1
 
 pragma solidity ^0.8.0;
@@ -11,7 +11,6 @@ import "../precompiles/ArbGasInfo.sol";
 import "../libraries/ArbitrumChecker.sol";
 import "../bridge/IDelayedMessageProvider.sol";
 import "../libraries/DelegateCallAware.sol";
-import {INITIALIZATION_MSG_TYPE} from "../libraries/MessageTypes.sol";
 import {AlreadyInit, HadZeroInit, RollupNotChanged} from "../libraries/Error.sol";
 
 /**
@@ -30,7 +29,9 @@ abstract contract AbsRollupEventInbox is
         _;
     }
 
-    function initialize(IBridge _bridge) external override onlyDelegated {
+    function initialize(
+        IBridge _bridge
+    ) external override onlyDelegated {
         if (address(bridge) != address(0)) revert AlreadyInit();
         if (address(_bridge) == address(0)) revert HadZeroInit();
         bridge = _bridge;
@@ -39,32 +40,30 @@ abstract contract AbsRollupEventInbox is
 
     /// @notice Allows the rollup owner to sync the rollup address
     function updateRollupAddress() external {
-        if (msg.sender != IOwnable(rollup).owner())
+        if (msg.sender != IOwnable(rollup).owner()) {
             revert NotOwner(msg.sender, IOwnable(rollup).owner());
+        }
         address newRollup = address(bridge.rollup());
         if (rollup == newRollup) revert RollupNotChanged();
         rollup = newRollup;
     }
 
-    function rollupInitialized(uint256 chainId, string calldata chainConfig)
-        external
-        override
-        onlyRollup
-    {
+    function rollupInitialized(
+        uint256 chainId,
+        string calldata chainConfig
+    ) external override onlyRollup {
         require(bytes(chainConfig).length > 0, "EMPTY_CHAIN_CONFIG");
         uint8 initMsgVersion = 1;
         uint256 currentDataCost = _currentDataCostToReport();
-        bytes memory initMsg = abi.encodePacked(
-            chainId,
-            initMsgVersion,
-            currentDataCost,
-            chainConfig
-        );
+        bytes memory initMsg =
+            abi.encodePacked(chainId, initMsgVersion, currentDataCost, chainConfig);
         uint256 num = _enqueueInitializationMsg(initMsg);
         emit InboxMessageDelivered(num, initMsg);
     }
 
-    function _enqueueInitializationMsg(bytes memory initMsg) internal virtual returns (uint256);
+    function _enqueueInitializationMsg(
+        bytes memory initMsg
+    ) internal virtual returns (uint256);
 
     function _currentDataCostToReport() internal virtual returns (uint256);
 }

package/src/rollup/Assertion.sol

@@ -0,0 +1,100 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "./AssertionState.sol";
+
+enum AssertionStatus {
+    // No assertion at this index
+    NoAssertion,
+    // Assertion is being computed
+    Pending,
+    // Assertion is confirmed
+    Confirmed
+}
+
+struct AssertionNode {
+    // This value starts at zero and is set to a value when the first child is created. After that it is constant until the assertion is destroyed or the owner destroys pending assertions
+    uint64 firstChildBlock;
+    // This value starts at zero and is set to a value when the second child is created. After that it is constant until the assertion is destroyed or the owner destroys pending assertions
+    uint64 secondChildBlock;
+    // The block number when this assertion was created
+    uint64 createdAtBlock;
+    // True if this assertion is the first child of its prev
+    bool isFirstChild;
+    // Status of the Assertion
+    AssertionStatus status;
+    // A hash of the context available at the time of this assertions creation. It should contain information that is not specific
+    // to this assertion, but instead to the environment at the time of creation. This is necessary to store on the assertion
+    // as this environment can change and we need to know what it was like at the time this assertion was created. An example
+    // of this is the wasm module root which determines the state transition function on the L2. If the wasm module root
+    // changes we need to know that previous assertions were made under a different root, so that we can understand that they
+    // were valid at the time. So when resolving a challenge by one step, the edge challenge manager finds the wasm module root
+    // that was recorded on the prev of the assertions being disputed and uses it to resolve the one step proof.
+    bytes32 configHash;
+}
+
+struct BeforeStateData {
+    // The assertion hash of the prev of the beforeState(prev)
+    bytes32 prevPrevAssertionHash;
+    // The sequencer inbox accumulator asserted by the beforeState(prev)
+    bytes32 sequencerBatchAcc;
+    // below are the components of config hash
+    ConfigData configData;
+}
+
+struct AssertionInputs {
+    // Additional data used to validate the before state
+    BeforeStateData beforeStateData;
+    AssertionState beforeState;
+    AssertionState afterState;
+}
+
+struct ConfigData {
+    bytes32 wasmModuleRoot;
+    uint256 requiredStake;
+    address challengeManager;
+    uint64 confirmPeriodBlocks;
+    uint64 nextInboxPosition;
+}
+
+/**
+ * @notice Utility functions for Assertion
+ */
+library AssertionNodeLib {
+    /**
+     * @notice Initialize a Assertion
+     */
+    function createAssertion(
+        bool _isFirstChild,
+        bytes32 _configHash
+    ) internal view returns (AssertionNode memory) {
+        AssertionNode memory assertion;
+        assertion.createdAtBlock = uint64(block.number);
+        assertion.isFirstChild = _isFirstChild;
+        assertion.configHash = _configHash;
+        assertion.status = AssertionStatus.Pending;
+        return assertion;
+    }
+
+    /**
+     * @notice Update child properties
+     */
+    function childCreated(
+        AssertionNode storage self
+    ) internal {
+        if (self.firstChildBlock == 0) {
+            self.firstChildBlock = uint64(block.number);
+        } else if (self.secondChildBlock == 0) {
+            self.secondChildBlock = uint64(block.number);
+        }
+    }
+
+    function requireExists(
+        AssertionNode memory self
+    ) internal pure {
+        require(self.status != AssertionStatus.NoAssertion, "ASSERTION_NOT_EXIST");
+    }
+}

package/src/rollup/AssertionState.sol

@@ -0,0 +1,29 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "../state/GlobalState.sol";
+import "../state/Machine.sol";
+import "../osp/IOneStepProofEntry.sol";
+
+struct AssertionState {
+    GlobalState globalState;
+    MachineStatus machineStatus;
+    bytes32 endHistoryRoot;
+}
+
+library AssertionStateLib {
+    function toExecutionState(
+        AssertionState memory state
+    ) internal pure returns (ExecutionState memory) {
+        return ExecutionState(state.globalState, state.machineStatus);
+    }
+
+    function hash(
+        AssertionState memory state
+    ) internal pure returns (bytes32) {
+        return keccak256(abi.encode(state));
+    }
+}