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

package/src/chain/CacheManager.sol

@@ -7,9 +7,11 @@ pragma solidity ^0.8.0;
 import "../precompiles/ArbOwnerPublic.sol";
 import "../precompiles/ArbWasm.sol";
 import "../precompiles/ArbWasmCache.sol";
+import "../libraries/DelegateCallAware.sol";
 import "solady/src/utils/MinHeapLib.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-contract CacheManager {
+contract CacheManager is Initializable, DelegateCallAware {
     using MinHeapLib for MinHeapLib.Heap;
 
     ArbOwnerPublic internal constant ARB_OWNER_PUBLIC = ArbOwnerPublic(address(0x6b));
@@ -34,7 +36,7 @@ contract CacheManager {
     error BidsArePaused();
     error MakeSpaceTooLarge(uint64 size, uint64 limit);
 
-    event InsertBid(bytes32 indexed codehash, uint192 bid, uint64 size);
+    event InsertBid(bytes32 indexed codehash, address program, uint192 bid, uint64 size);
     event DeleteBid(bytes32 indexed codehash, uint192 bid, uint64 size);
     event SetCacheSize(uint64 size);
     event SetDecayRate(uint64 decay);
@@ -47,7 +49,7 @@ contract CacheManager {
         uint192 bid;
     }
 
-    constructor(uint64 initCacheSize, uint64 initDecay) {
+    function initialize(uint64 initCacheSize, uint64 initDecay) external initializer onlyDelegated {
         cacheSize = initCacheSize;
         decay = initDecay;
     }
@@ -151,10 +153,16 @@ contract CacheManager {
 
     /// @notice Returns the minimum bid required to cache the program with given codehash.
     ///         Value returned here is the minimum bid that you can send with msg.value
-    function getMinBid(bytes32 codehash) external view returns (uint192 min) {
+    function getMinBid(bytes32 codehash) public view returns (uint192 min) {
         return getMinBid(_asmSize(codehash));
     }
 
+    /// @notice Returns the minimum bid required to cache the program at given address.
+    ///         Value returned here is the minimum bid that you can send with msg.value
+    function getMinBid(address program) external view returns (uint192 min) {
+        return getMinBid(program.codehash);
+    }
+
     /// @notice Sends all revenue to the network fee account.
     function sweepFunds() external {
         (bool success, bytes memory data) = ARB_OWNER_PUBLIC.getNetworkFeeAccount().call{
@@ -167,18 +175,19 @@ contract CacheManager {
         }
     }
 
-    /// @notice Places a bid, reverting if payment is insufficient.
-    function placeBid(bytes32 codehash) external payable {
+    /// Places a bid, reverting if payment is insufficient.
+    function placeBid(address program) external payable {
         if (isPaused) {
             revert BidsArePaused();
         }
+        bytes32 codehash = program.codehash;
         if (_isCached(codehash)) {
             revert AlreadyCached(codehash);
         }
 
         uint64 asm = _asmSize(codehash);
         (uint192 bid, uint64 index) = _makeSpace(asm);
-        return _addBid(bid, codehash, asm, index);
+        return _addBid(bid, program, codehash, asm, index);
     }
 
     /// @notice Evicts entries until enough space exists in the cache, reverting if payment is insufficient.
@@ -230,6 +239,7 @@ contract CacheManager {
     /// @dev Adds a bid
     function _addBid(
         uint192 bid,
+        address program,
         bytes32 code,
         uint64 size,
         uint64 index
@@ -239,7 +249,7 @@ contract CacheManager {
         }
 
         Entry memory entry = Entry({size: size, code: code, bid: bid});
-        ARB_WASM_CACHE.cacheCodehash(code);
+        ARB_WASM_CACHE.cacheProgram(program);
         bids.push(_packBid(bid, index));
         queueSize += size;
         if (index == entries.length) {
@@ -247,7 +257,7 @@ contract CacheManager {
         } else {
             entries[index] = entry;
         }
-        emit InsertBid(code, bid, size);
+        emit InsertBid(code, program, bid, size);
     }
 
     /// @dev Clears the entry at the given index

package/src/libraries/Constants.sol

@@ -8,3 +8,14 @@ uint64 constant NO_CHAL_INDEX = 0;
 
 // Expected seconds per block in Ethereum PoS
 uint256 constant ETH_POS_BLOCK_TIME = 12;
+
+/// @dev If nativeTokenDecimals is different than 18 decimals, bridge will inflate or deflate token amounts
+///      when depositing to child chain to match 18 decimal denomination. Opposite process happens when
+///      amount is withdrawn back to parent chain. In order to avoid uint256 overflows we restrict max number
+///      of decimals to 36 which should be enough for most practical use-cases.
+uint8 constant MAX_ALLOWED_NATIVE_TOKEN_DECIMALS = uint8(36);
+
+/// @dev Max amount of erc20 native token that can deposit when upscaling is required (i.e. < 18 decimals)
+///      Amounts higher than this would risk uint256 overflows when adjusting decimals. Considering
+///      18 decimals are 60 bits, we choose 2^192 as the limit which equals to ~6.3*10^57 weis of token
+uint256 constant MAX_UPSCALE_AMOUNT = type(uint192).max;

package/src/libraries/DecimalsConverterHelper.sol

@@ -0,0 +1,33 @@
+// 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 {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+library DecimalsConverterHelper {
+    /// @notice generic function for mapping amount from one decimal denomination to another
+    /// @dev Ie. let's say amount is 752. If token has 16 decimals and is being adjusted to
+    ///      18 decimals then amount will be 75200. If token has 20 decimals adjusted amount
+    ///      is 7. If token uses no decimals converted amount is 752*10^18.
+    ///      When amount is adjusted from 18 decimals back to native token decimals, opposite
+    ///      process is performed.
+    /// @param amount amount to convert
+    /// @param decimalsIn current decimals
+    /// @param decimalsOut target decimals
+    /// @return amount converted to 'decimalsOut' decimals
+    function adjustDecimals(
+        uint256 amount,
+        uint8 decimalsIn,
+        uint8 decimalsOut
+    ) internal pure returns (uint256) {
+        if (decimalsIn == decimalsOut) {
+            return amount;
+        } else if (decimalsIn < decimalsOut) {
+            return amount * 10**(decimalsOut - decimalsIn);
+        } else {
+            return amount / 10**(decimalsIn - decimalsOut);
+        }
+    }
+}

package/src/libraries/Error.sol

@@ -119,6 +119,12 @@ error NotForked();
 /// @dev The provided gasLimit is larger than uint64
 error GasLimitTooLarge();
 
+/// @dev The provided amount cannot be adjusted to 18 decimals due to overflow
+error AmountTooLarge(uint256 amount);
+
+/// @dev Number of native token's decimals is restricted to enable conversions to 18 decimals
+error NativeTokenDecimalsTooLarge(uint256 decimals);
+
 // Outbox Errors
 
 /// @dev The provided proof was too long

package/src/mocks/BridgeStub.sol

@@ -32,6 +32,9 @@ contract BridgeStub is IBridge, IEthBridge {
     address public sequencerInbox;
     uint256 public override sequencerReportedSubMessageCount;
 
+    address public nativeToken;
+    uint8 public nativeTokenDecimals;
+
     function setSequencerInbox(address _sequencerInbox) external override {
         sequencerInbox = _sequencerInbox;
         emit SequencerInboxUpdated(_sequencerInbox);

package/src/mocks/SimpleCacheManager.sol

@@ -7,7 +7,7 @@ import "../precompiles/ArbWasmCache.sol";
 
 contract SimpleCacheManager {
     function cacheProgram(address program) external {
-        ArbWasmCache(address(0x72)).cacheCodehash(codehash(program));
+        ArbWasmCache(address(0x72)).cacheProgram(program);
     }
 
     function evictProgram(address program) external {

package/src/node-interface/NodeInterface.sol

@@ -18,7 +18,7 @@ interface NodeInterface {
      * @param deposit amount to deposit to sender in L2
      * @param to destination L2 contract address
      * @param l2CallValue call value for retryable L2 message
-     * @param excessFeeRefundAddress gasLimit x maxFeePerGas - execution cost gets credited here on L2 balance
+     * @param excessFeeRefundAddress the address which receives the difference between execution fee paid and the actual execution cost
      * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
      * @param data ABI encoded data of L2 message
      */

package/src/precompiles/ArbWasmCache.sol

@@ -16,11 +16,14 @@ interface ArbWasmCache {
     /// @return managers the list of managers.
     function allCacheManagers() external view returns (address[] memory managers);
 
-    /// @notice Caches all programs with the given codehash.
+    /// @dev Deprecated, replaced with cacheProgram
+    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 cacheCodehash(bytes32 codehash) external;
+    function cacheProgram(address addr) external;
 
     /// @notice Evicts all programs with the given codehash.
     /// @notice Caller must be a cache manager or chain owner.

package/src/rollup/AbsRollupEventInbox.sol

@@ -53,10 +53,7 @@ abstract contract AbsRollupEventInbox is
     {
         require(bytes(chainConfig).length > 0, "EMPTY_CHAIN_CONFIG");
         uint8 initMsgVersion = 1;
-        uint256 currentDataCost = block.basefee;
-        if (ArbitrumChecker.runningOnArbitrum()) {
-            currentDataCost += ArbGasInfo(address(0x6c)).getL1BaseFeeEstimate();
-        }
+        uint256 currentDataCost = _currentDataCostToReport();
         bytes memory initMsg = abi.encodePacked(
             chainId,
             initMsgVersion,
@@ -68,4 +65,6 @@ abstract contract AbsRollupEventInbox is
     }
 
     function _enqueueInitializationMsg(bytes memory initMsg) internal virtual returns (uint256);
+
+    function _currentDataCostToReport() internal virtual returns (uint256);
 }

package/src/rollup/DeployHelper.sol

@@ -6,8 +6,8 @@ pragma solidity ^0.8.0;
 
 import {IInbox} from "../bridge/IInbox.sol";
 import {IInboxBase} from "../bridge/IInboxBase.sol";
-import {IERC20Bridge} from "../bridge/IERC20Bridge.sol";
 import {IERC20Inbox} from "../bridge/ERC20Inbox.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
 /// @notice Helper contract for deploying some keyless deployment to Arbitrum using delayed inbox
 contract DeployHelper {
@@ -48,7 +48,7 @@ contract DeployHelper {
         uint256 _value,
         address _l2Address,
         bytes memory payload,
-        bool _isUsingFeeToken,
+        address _nativeToken,
         uint256 maxFeePerGas
     ) internal {
         uint256 submissionCost = IInboxBase(inbox).calculateRetryableSubmissionFee(
@@ -58,7 +58,20 @@ contract DeployHelper {
         uint256 feeAmount = _value + submissionCost + GASLIMIT * maxFeePerGas;
 
         // fund the target L2 address
-        if (_isUsingFeeToken) {
+        if (_nativeToken != address(0)) {
+            // calculate the fee amount in the native token's decimals
+            uint256 feeAmountNativeDenominated = feeAmount;
+            uint8 decimals = ERC20(_nativeToken).decimals();
+            if (decimals < 18) {
+                feeAmountNativeDenominated = feeAmount / (10**(18 - decimals));
+                // round up if necessary
+                if (feeAmountNativeDenominated * (10**(18 - decimals)) < feeAmount) {
+                    feeAmountNativeDenominated++;
+                }
+            } else if (decimals > 18) {
+                feeAmountNativeDenominated = feeAmount * (10**(decimals - 18));
+            }
+
             IERC20Inbox(inbox).createRetryableTicket({
                 to: _l2Address,
                 l2CallValue: _value,
@@ -67,7 +80,7 @@ contract DeployHelper {
                 callValueRefundAddress: msg.sender,
                 gasLimit: GASLIMIT,
                 maxFeePerGas: maxFeePerGas,
-                tokenTotalFeeAmount: feeAmount,
+                tokenTotalFeeAmount: feeAmountNativeDenominated,
                 data: ""
             });
         } else {
@@ -91,14 +104,12 @@ contract DeployHelper {
         address _nativeToken,
         uint256 _maxFeePerGas
     ) external payable {
-        bool isUsingFeeToken = _nativeToken != address(0);
-
         _fundAndDeploy(
             _inbox,
             NICK_CREATE2_VALUE,
             NICK_CREATE2_DEPLOYER,
             NICK_CREATE2_PAYLOAD,
-            isUsingFeeToken,
+            _nativeToken,
             _maxFeePerGas
         );
         _fundAndDeploy(
@@ -106,7 +117,7 @@ contract DeployHelper {
             ERC2470_VALUE,
             ERC2470_DEPLOYER,
             ERC2470_PAYLOAD,
-            isUsingFeeToken,
+            _nativeToken,
             _maxFeePerGas
         );
         _fundAndDeploy(
@@ -114,7 +125,7 @@ contract DeployHelper {
             ZOLTU_VALUE,
             ZOLTU_CREATE2_DEPLOYER,
             ZOLTU_CREATE2_PAYLOAD,
-            isUsingFeeToken,
+            _nativeToken,
             _maxFeePerGas
         );
         _fundAndDeploy(
@@ -122,12 +133,12 @@ contract DeployHelper {
             ERC1820_VALUE,
             ERC1820_DEPLOYER,
             ERC1820_PAYLOAD,
-            isUsingFeeToken,
+            _nativeToken,
             _maxFeePerGas
         );
 
         // if paying with ETH refund the caller
-        if (!isUsingFeeToken) {
+        if (_nativeToken == address(0)) {
             payable(msg.sender).transfer(address(this).balance);
         }
     }

package/src/rollup/ERC20RollupEventInbox.sol

@@ -23,4 +23,9 @@ contract ERC20RollupEventInbox is AbsRollupEventInbox {
                 tokenAmount
             );
     }
+
+    function _currentDataCostToReport() internal pure override returns (uint256) {
+        // at the moment chains using fee token in Anytrust mode do not charge for the data posting fees
+        return 0;
+    }
 }

package/src/rollup/FactoryDeployerHelper.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+/**
+ * @title Helper contract for cross-chain deployment of deterministic factories when rollup uses custom fee token
+ * @notice It bundles sending the fee token to inbox and invoking the factory deployment function.
+ *         Prerequisite: fee token must be approved for this contract to send it to inbox.
+ */
+contract FactoryDeployerHelper {
+    address public constant DEPLOY_HELPER = address(0x90D68B056c411015eaE3EC0b98AD94E2C91419F1);
+    uint256 public constant MAX_FEE_PER_GAS = 100_000_000;
+
+    function deploy(address inbox) external {
+        deploy(inbox, MAX_FEE_PER_GAS);
+    }
+
+    function deploy(address inbox, uint256 maxFeePerGas) public {
+        address bridge = address(IInboxBase(inbox).bridge());
+        address feeToken = IERC20Bridge(bridge).nativeToken();
+
+        uint256 amount = IDeployHelper(DEPLOY_HELPER).getDeploymentTotalCost(inbox, maxFeePerGas);
+        IERC20(feeToken).transferFrom(msg.sender, inbox, amount);
+        IDeployHelper(DEPLOY_HELPER).perform(inbox, feeToken, maxFeePerGas);
+    }
+}
+
+interface IERC20 {
+    function transferFrom(
+        address from,
+        address to,
+        uint256 value
+    ) external returns (bool);
+}
+
+interface IDeployHelper {
+    function getDeploymentTotalCost(address inbox, uint256 maxFeePerGas)
+        external
+        view
+        returns (uint256);
+
+    function perform(
+        address _inbox,
+        address _nativeToken,
+        uint256 _maxFeePerGas
+    ) external payable;
+}
+
+interface IInboxBase {
+    function bridge() external view returns (address);
+}
+
+interface IERC20Bridge {
+    function nativeToken() external view returns (address);
+}

package/src/rollup/IRollupLogic.sol

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

package/src/rollup/RollupAdminLogic.sol

@@ -379,4 +379,15 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
         validatorWhitelistDisabled = _validatorWhitelistDisabled;
         emit OwnerFunctionCalled(30);
     }
+
+    /**
+     * @notice set the anyTrustFastConfirmer address
+     *         must also call `setValidator` to set the same address as a validator to work
+     *         old fast confirmer need to be removed from the validator list manually
+     * @param _anyTrustFastConfirmer new value of anyTrustFastConfirmer
+     */
+    function setAnyTrustFastConfirmer(address _anyTrustFastConfirmer) external {
+        anyTrustFastConfirmer = _anyTrustFastConfirmer;
+        emit OwnerFunctionCalled(31);
+    }
 }

package/src/rollup/RollupCore.sol

@@ -77,6 +77,7 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
     uint64 internal constant GENESIS_NODE = 0;
 
     bool public validatorWhitelistDisabled;
+    address public anyTrustFastConfirmer;
 
     // If the chain this RollupCore is deployed on is an Arbitrum chain.
     bool internal immutable _hostChainIsArbitrum = ArbitrumChecker.runningOnArbitrum();

package/src/rollup/RollupCreator.sol

@@ -277,10 +277,58 @@ contract RollupCreator is Ownable {
                 IInboxBase(_inbox),
                 _maxFeePerGas
             );
-            IERC20(_nativeToken).safeTransferFrom(msg.sender, _inbox, totalFee);
+
+            // calculate the fee amount in the native token's decimals
+            uint8 decimals = ERC20(_nativeToken).decimals();
+
+            uint256 totalFeeNativeDenominated = totalFee;
+            if (decimals < 18) {
+                uint256 gasCost = _maxFeePerGas * 21_000;
+                uint256 nickCreate2Cost = _scaleDownToNativeDecimals(
+                    l2FactoriesDeployer.NICK_CREATE2_VALUE() + gasCost,
+                    decimals
+                );
+                uint256 erc2470Cost = _scaleDownToNativeDecimals(
+                    l2FactoriesDeployer.ERC2470_VALUE() + gasCost,
+                    decimals
+                );
+                uint256 zoltuCreate2Cost = _scaleDownToNativeDecimals(
+                    l2FactoriesDeployer.ZOLTU_VALUE() + gasCost,
+                    decimals
+                );
+                uint256 erc1820Cost = _scaleDownToNativeDecimals(
+                    l2FactoriesDeployer.ERC1820_VALUE() + gasCost,
+                    decimals
+                );
+                totalFeeNativeDenominated =
+                    nickCreate2Cost +
+                    erc2470Cost +
+                    zoltuCreate2Cost +
+                    erc1820Cost;
+            } else if (decimals > 18) {
+                totalFeeNativeDenominated = totalFee * (10**(decimals - 18));
+            }
+
+            IERC20(_nativeToken).safeTransferFrom(msg.sender, _inbox, totalFeeNativeDenominated);
 
             // do it
             l2FactoriesDeployer.perform(_inbox, _nativeToken, _maxFeePerGas);
         }
     }
+
+    function _scaleDownToNativeDecimals(uint256 amount, uint8 decimals)
+        internal
+        pure
+        returns (uint256)
+    {
+        uint256 scaledAmount = amount;
+        if (decimals < 18) {
+            scaledAmount = amount / (10**(18 - decimals));
+            // round up if necessary
+            if (scaledAmount * (10**(18 - decimals)) < amount) {
+                scaledAmount++;
+            }
+        }
+        return scaledAmount;
+    }
 }

package/src/rollup/RollupEventInbox.sol

@@ -21,4 +21,12 @@ contract RollupEventInbox is AbsRollupEventInbox {
                 keccak256(initMsg)
             );
     }
+
+    function _currentDataCostToReport() internal view override returns (uint256) {
+        uint256 currentDataCost = block.basefee;
+        if (ArbitrumChecker.runningOnArbitrum()) {
+            currentDataCost += ArbGasInfo(address(0x6c)).getL1BaseFeeEstimate();
+        }
+        return currentDataCost;
+    }
 }

package/src/rollup/RollupUserLogic.sol

@@ -116,29 +116,28 @@ abstract contract AbsRollupUserLogic is
         emit NodeRejected(firstUnresolvedNodeNum);
     }
 
-    /**
-     * @notice Confirm the next unresolved node
-     * @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,
+        bool isFastConfirm
+    ) internal {
         requireUnresolvedExists();
 
         uint64 nodeNum = firstUnresolvedNode();
         Node storage node = getNodeStorage(nodeNum);
 
-        // Verify the block's deadline has passed
-        node.requirePastDeadline();
+        if (!isFastConfirm) {
+            // Verify the block's deadline has passed
+            node.requirePastDeadline();
+        }
 
         // Check that prev is latest confirmed
         assert(node.prevNum == latestConfirmed());
 
         Node storage prevNode = getNodeStorage(node.prevNum);
-        prevNode.requirePastChildConfirmDeadline();
+        if (!isFastConfirm) {
+            prevNode.requirePastChildConfirmDeadline();
+        }
 
         removeOldZombies(0);
 
@@ -155,6 +154,29 @@ abstract contract AbsRollupUserLogic is
         confirmNode(nodeNum, blockHash, sendRoot);
     }
 
+    /**
+     * @notice Confirm the next unresolved node
+     * @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
+    {
+        _confirmNextNode(blockHash, sendRoot, false);
+    }
+
+    /**
+     * @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
+     */
+    function fastConfirmNextNode(bytes32 blockHash, bytes32 sendRoot) external whenNotPaused {
+        require(msg.sender == anyTrustFastConfirmer, "NOT_FAST_CONFIRMER");
+        _confirmNextNode(blockHash, sendRoot, true);
+    }
+
     /**
      * @notice Create a new stake
      * @param depositAmount The amount of either eth or tokens staked

package/src/test-helpers/BridgeTester.sol

@@ -46,6 +46,9 @@ contract BridgeTester is Initializable, DelegateCallAware, IBridge, IEthBridge {
     IOwnable public rollup;
     address public sequencerInbox;
 
+    address public nativeToken;
+    uint8 public nativeTokenDecimals;
+
     modifier onlyRollupOrOwner() {
         if (msg.sender != address(rollup)) {
             address rollupOwner = rollup.owner();

package/build/contracts/@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol/IERC20Permit.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../../../../build-info/83d3fd0b633e3a3120fc5455f62bf6b6.json"
-}