@arbitrum/nitro-contracts 2.1.1-beta.0 → 3.0.0-alpha.1

package/src/precompiles/ArbOwner.sol

@@ -12,40 +12,61 @@ pragma solidity >=0.4.21 <0.9.0;
  * - ArbOS upgrades happen with the rest of the system rather than being independent
  * - Exemptions to address aliasing are no longer offered. Exemptions were intended to support backward compatibility for contracts deployed before aliasing was introduced, but no exemptions were ever requested.
  * Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000070.
- **/
+ *
+ */
 interface ArbOwner {
     /// @notice Add account as a chain owner
-    function addChainOwner(address newOwner) external;
+    function addChainOwner(
+        address newOwner
+    ) external;
 
     /// @notice Remove account from the list of chain owners
-    function removeChainOwner(address ownerToRemove) external;
+    function removeChainOwner(
+        address ownerToRemove
+    ) external;
 
     /// @notice See if the user is a chain owner
-    function isChainOwner(address addr) external view returns (bool);
+    function isChainOwner(
+        address addr
+    ) external view returns (bool);
 
     /// @notice Retrieves the list of chain owners
     function getAllChainOwners() external view returns (address[] memory);
 
     /// @notice Set how slowly ArbOS updates its estimate of the L1 basefee
-    function setL1BaseFeeEstimateInertia(uint64 inertia) external;
+    function setL1BaseFeeEstimateInertia(
+        uint64 inertia
+    ) external;
 
     /// @notice Set the L2 basefee directly, bypassing the pool calculus
-    function setL2BaseFee(uint256 priceInWei) external;
+    function setL2BaseFee(
+        uint256 priceInWei
+    ) external;
 
     /// @notice Set the minimum basefee needed for a transaction to succeed
-    function setMinimumL2BaseFee(uint256 priceInWei) external;
+    function setMinimumL2BaseFee(
+        uint256 priceInWei
+    ) external;
 
     /// @notice Set the computational speed limit for the chain
-    function setSpeedLimit(uint64 limit) external;
+    function setSpeedLimit(
+        uint64 limit
+    ) external;
 
     /// @notice Set the maximum size a tx (and block) can be
-    function setMaxTxGasLimit(uint64 limit) external;
+    function setMaxTxGasLimit(
+        uint64 limit
+    ) external;
 
     /// @notice Set the L2 gas pricing inertia
-    function setL2GasPricingInertia(uint64 sec) external;
+    function setL2GasPricingInertia(
+        uint64 sec
+    ) external;
 
     /// @notice Set the L2 gas backlog tolerance
-    function setL2GasBacklogTolerance(uint64 sec) external;
+    function setL2GasBacklogTolerance(
+        uint64 sec
+    ) external;
 
     /// @notice Get the network fee collector
     function getNetworkFeeAccount() external view returns (address);
@@ -54,59 +75,91 @@ interface ArbOwner {
     function getInfraFeeAccount() external view returns (address);
 
     /// @notice Set the network fee collector
-    function setNetworkFeeAccount(address newNetworkFeeAccount) external;
+    function setNetworkFeeAccount(
+        address newNetworkFeeAccount
+    ) external;
 
     /// @notice Set the infrastructure fee collector
-    function setInfraFeeAccount(address newInfraFeeAccount) external;
+    function setInfraFeeAccount(
+        address newInfraFeeAccount
+    ) external;
 
     /// @notice Upgrades ArbOS to the requested version at the requested timestamp
     function scheduleArbOSUpgrade(uint64 newVersion, uint64 timestamp) external;
 
     /// @notice Sets equilibration units parameter for L1 price adjustment algorithm
-    function setL1PricingEquilibrationUnits(uint256 equilibrationUnits) external;
+    function setL1PricingEquilibrationUnits(
+        uint256 equilibrationUnits
+    ) external;
 
     /// @notice Sets inertia parameter for L1 price adjustment algorithm
-    function setL1PricingInertia(uint64 inertia) external;
+    function setL1PricingInertia(
+        uint64 inertia
+    ) external;
 
     /// @notice Sets reward recipient address for L1 price adjustment algorithm
-    function setL1PricingRewardRecipient(address recipient) external;
+    function setL1PricingRewardRecipient(
+        address recipient
+    ) external;
 
     /// @notice Sets reward amount for L1 price adjustment algorithm, in wei per unit
-    function setL1PricingRewardRate(uint64 weiPerUnit) external;
+    function setL1PricingRewardRate(
+        uint64 weiPerUnit
+    ) external;
 
     /// @notice Set how much ArbOS charges per L1 gas spent on transaction data.
-    function setL1PricePerUnit(uint256 pricePerUnit) external;
+    function setL1PricePerUnit(
+        uint256 pricePerUnit
+    ) external;
 
     /// @notice Sets the base charge (in L1 gas) attributed to each data batch in the calldata pricer
-    function setPerBatchGasCharge(int64 cost) external;
+    function setPerBatchGasCharge(
+        int64 cost
+    ) external;
 
     /**
      * @notice Sets the Brotli compression level used for fast compression
      * Available in ArbOS version 12 with default level as 1
      */
-    function setBrotliCompressionLevel(uint64 level) external;
+    function setBrotliCompressionLevel(
+        uint64 level
+    ) external;
 
     /// @notice Sets the cost amortization cap in basis points
-    function setAmortizedCostCapBips(uint64 cap) external;
+    function setAmortizedCostCapBips(
+        uint64 cap
+    ) external;
 
     /// @notice Releases surplus funds from L1PricerFundsPoolAddress for use
-    function releaseL1PricerSurplusFunds(uint256 maxWeiToRelease) external returns (uint256);
+    function releaseL1PricerSurplusFunds(
+        uint256 maxWeiToRelease
+    ) external returns (uint256);
 
     /// @notice Sets the amount of ink 1 gas buys
     /// @param price the conversion rate (must fit in a uint24)
-    function setInkPrice(uint32 price) external;
+    function setInkPrice(
+        uint32 price
+    ) external;
 
     /// @notice Sets the maximum depth (in wasm words) a wasm stack may grow
-    function setWasmMaxStackDepth(uint32 depth) external;
+    function setWasmMaxStackDepth(
+        uint32 depth
+    ) external;
 
     /// @notice Sets the number of free wasm pages a tx gets
-    function setWasmFreePages(uint16 pages) external;
+    function setWasmFreePages(
+        uint16 pages
+    ) external;
 
     /// @notice Sets the base cost of each additional wasm page
-    function setWasmPageGas(uint16 gas) external;
+    function setWasmPageGas(
+        uint16 gas
+    ) external;
 
     /// @notice Sets the maximum number of pages a wasm may allocate
-    function setWasmPageLimit(uint16 limit) external;
+    function setWasmPageLimit(
+        uint16 limit
+    ) external;
 
     /// @notice Sets the minimum costs to invoke a program
     /// @param gas amount of gas paid in increments of 256 when not the program is not cached
@@ -115,25 +168,39 @@ interface ArbOwner {
 
     /// @notice Sets the linear adjustment made to program init costs.
     /// @param percent the adjustment (100% = no adjustment).
-    function setWasmInitCostScalar(uint64 percent) external;
+    function setWasmInitCostScalar(
+        uint64 percent
+    ) external;
 
     /// @notice Sets the number of days after which programs deactivate
-    function setWasmExpiryDays(uint16 _days) external;
+    function setWasmExpiryDays(
+        uint16 _days
+    ) external;
 
     /// @notice Sets the age a program must be to perform a keepalive
-    function setWasmKeepaliveDays(uint16 _days) external;
+    function setWasmKeepaliveDays(
+        uint16 _days
+    ) external;
 
     /// @notice Sets the number of extra programs ArbOS caches during a given block
-    function setWasmBlockCacheSize(uint16 count) external;
+    function setWasmBlockCacheSize(
+        uint16 count
+    ) external;
 
     /// @notice Adds account as a wasm cache manager
-    function addWasmCacheManager(address manager) external;
+    function addWasmCacheManager(
+        address manager
+    ) external;
 
     /// @notice Removes account from the list of wasm cache managers
-    function removeWasmCacheManager(address manager) external;
+    function removeWasmCacheManager(
+        address manager
+    ) external;
 
     /// @notice Sets serialized chain config in ArbOS state
-    function setChainConfig(string calldata chainConfig) external;
+    function setChainConfig(
+        string calldata chainConfig
+    ) external;
 
     /// Emitted when a successful call is made to this precompile
     event OwnerActs(bytes4 indexed method, address indexed owner, bytes data);

package/src/precompiles/ArbOwnerPublic.sol

@@ -8,14 +8,18 @@ pragma solidity >=0.4.21 <0.9.0;
 /// @notice Precompiled contract that exists in every Arbitrum chain at 0x000000000000000000000000000000000000006b.
 interface ArbOwnerPublic {
     /// @notice See if the user is a chain owner
-    function isChainOwner(address addr) external view returns (bool);
+    function isChainOwner(
+        address addr
+    ) external view returns (bool);
 
     /**
      * @notice Rectify the list of chain owners
      * If successful, emits ChainOwnerRectified event
      * Available in ArbOS version 11
      */
-    function rectifyChainOwner(address ownerToRectify) external;
+    function rectifyChainOwner(
+        address ownerToRectify
+    ) external;
 
     /// @notice Retrieves the list of chain owners
     function getAllChainOwners() external view returns (address[] memory);

package/src/precompiles/ArbRetryableTx.sol

@@ -15,7 +15,9 @@ interface ArbRetryableTx {
      * @param ticketId unique identifier of retryable message: keccak256(keccak256(ArbchainId, inbox-sequence-number), uint(0) )
      * @return txId that the redeem attempt will have
      */
-    function redeem(bytes32 ticketId) external returns (bytes32);
+    function redeem(
+        bytes32 ticketId
+    ) external returns (bytes32);
 
     /**
      * @notice Return the minimum lifetime of redeemable txn.
@@ -28,7 +30,9 @@ interface ArbRetryableTx {
      * @param ticketId unique ticket identifier
      * @return timestamp for ticket's deadline
      */
-    function getTimeout(bytes32 ticketId) external view returns (uint256);
+    function getTimeout(
+        bytes32 ticketId
+    ) external view returns (uint256);
 
     /**
      * @notice Adds one lifetime period to the life of ticketId.
@@ -38,7 +42,9 @@ interface ArbRetryableTx {
      * @param ticketId unique ticket identifier
      * @return new timeout of ticketId
      */
-    function keepalive(bytes32 ticketId) external returns (uint256);
+    function keepalive(
+        bytes32 ticketId
+    ) external returns (uint256);
 
     /**
      * @notice Return the beneficiary of ticketId.
@@ -46,14 +52,18 @@ interface ArbRetryableTx {
      * @param ticketId unique ticket identifier
      * @return address of beneficiary for ticket
      */
-    function getBeneficiary(bytes32 ticketId) external view returns (address);
+    function getBeneficiary(
+        bytes32 ticketId
+    ) external view returns (address);
 
     /**
      * @notice Cancel ticketId and refund its callvalue to its beneficiary.
      * Revert if ticketId doesn't exist, or if called by anyone other than ticketId's beneficiary.
      * @param ticketId unique ticket identifier
      */
-    function cancel(bytes32 ticketId) external;
+    function cancel(
+        bytes32 ticketId
+    ) external;
 
     /**
      * @notice Gets the redeemer of the current retryable redeem attempt.

package/src/precompiles/ArbStatistics.sol

@@ -18,12 +18,5 @@ interface ArbStatistics {
     function getStats()
         external
         view
-        returns (
-            uint256,
-            uint256,
-            uint256,
-            uint256,
-            uint256,
-            uint256
-        );
+        returns (uint256, uint256, uint256, uint256, uint256, uint256);
 }

package/src/precompiles/ArbSys.sol

@@ -20,7 +20,9 @@ interface ArbSys {
      * @notice Get Arbitrum block hash (reverts unless currentBlockNum-256 <= arbBlockNum < currentBlockNum)
      * @return block hash
      */
-    function arbBlockHash(uint256 arbBlockNum) external view returns (bytes32);
+    function arbBlockHash(
+        uint256 arbBlockNum
+    ) external view returns (bytes32);
 
     /**
      * @notice Gets the rollup's unique chain identifier
@@ -54,10 +56,10 @@ interface ArbSys {
      * @param unused argument no longer used
      * @return aliased sender address
      */
-    function mapL1SenderContractAddressToL2Alias(address sender, address unused)
-        external
-        pure
-        returns (address);
+    function mapL1SenderContractAddressToL2Alias(
+        address sender,
+        address unused
+    ) external pure returns (address);
 
     /**
      * @notice check if the caller (of this caller of this) is an aliased L1 contract address
@@ -77,7 +79,9 @@ interface ArbSys {
      * @param destination recipient address on L1
      * @return unique identifier for this L2-to-L1 transaction.
      */
-    function withdrawEth(address destination) external payable returns (uint256);
+    function withdrawEth(
+        address destination
+    ) external payable returns (uint256);
 
     /**
      * @notice Send a transaction to L1
@@ -87,10 +91,10 @@ interface ArbSys {
      * @param data (optional) calldata for L1 contract call
      * @return a unique identifier for this L2-to-L1 transaction.
      */
-    function sendTxToL1(address destination, bytes calldata data)
-        external
-        payable
-        returns (uint256);
+    function sendTxToL1(
+        address destination,
+        bytes calldata data
+    ) external payable returns (uint256);
 
     /**
      * @notice Get send Merkle tree state
@@ -101,11 +105,7 @@ interface ArbSys {
     function sendMerkleTreeState()
         external
         view
-        returns (
-            uint256 size,
-            bytes32 root,
-            bytes32[] memory partials
-        );
+        returns (uint256 size, bytes32 root, bytes32[] memory partials);
 
     /**
      * @notice creates a send txn from L2 to L1
@@ -144,9 +144,7 @@ interface ArbSys {
      * @param position = (level << 192) + leaf
      */
     event SendMerkleUpdate(
-        uint256 indexed reserved,
-        bytes32 indexed hash,
-        uint256 indexed position
+        uint256 indexed reserved, bytes32 indexed hash, uint256 indexed position
     );
 
     error InvalidBlockNumber(uint256 requested, uint256 current);

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);
 }