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

package/src/precompiles/ArbAddressTable.sol

@@ -14,14 +14,18 @@ interface ArbAddressTable {
      * @param addr address to check for presence in table
      * @return true if address is in table
      */
-    function addressExists(address addr) external view returns (bool);
+    function addressExists(
+        address addr
+    ) external view returns (bool);
 
     /**
      * @notice compress an address and return the result
      * @param addr address to compress
      * @return compressed address bytes
      */
-    function compress(address addr) external returns (bytes memory);
+    function compress(
+        address addr
+    ) external returns (bytes memory);
 
     /**
      * @notice read a compressed address from a bytes buffer
@@ -29,29 +33,35 @@ interface ArbAddressTable {
      * @param offset offset of target address
      * @return resulting address and updated offset into the buffer (revert if buffer is too short)
      */
-    function decompress(bytes calldata buf, uint256 offset)
-        external
-        view
-        returns (address, uint256);
+    function decompress(
+        bytes calldata buf,
+        uint256 offset
+    ) external view returns (address, uint256);
 
     /**
      * @param addr address to lookup
      * @return index of an address in the address table (revert if address isn't in the table)
      */
-    function lookup(address addr) external view returns (uint256);
+    function lookup(
+        address addr
+    ) external view returns (uint256);
 
     /**
      * @param index index to lookup address
      * @return address at a given index in address table (revert if index is beyond end of table)
      */
-    function lookupIndex(uint256 index) external view returns (address);
+    function lookupIndex(
+        uint256 index
+    ) external view returns (address);
 
     /**
      * @notice Register an address in the address table
      * @param addr address to register
      * @return index of the address (existing index, or newly created index if not already registered)
      */
-    function register(address addr) external returns (uint256);
+    function register(
+        address addr
+    ) external returns (uint256);
 
     /**
      * @return size of address table (= first unused index)

package/src/precompiles/ArbAggregator.sol

@@ -11,7 +11,9 @@ interface ArbAggregator {
     /// @notice Get the address of an arbitrarily chosen batch poster.
     /// @param addr ignored
     /// @return (batchPosterAddress, true)
-    function getPreferredAggregator(address addr) external view returns (address, bool);
+    function getPreferredAggregator(
+        address addr
+    ) external view returns (address, bool);
 
     /// @notice Deprecated, there is no longer a single preferred aggregator, use getBatchPosters instead
     /// @notice Get default aggregator.
@@ -24,12 +26,16 @@ interface ArbAggregator {
     /// @notice Adds newBatchPoster as a batch poster
     /// This reverts unless called by a chain owner
     /// @param newBatchPoster New batch poster
-    function addBatchPoster(address newBatchPoster) external;
+    function addBatchPoster(
+        address newBatchPoster
+    ) external;
 
     /// @notice Get the address where fees to batchPoster are sent.
     /// @param batchPoster The batch poster to get the fee collector for
     /// @return The fee collectors address. This will sometimes but not always be the same as the batch poster's address.
-    function getFeeCollector(address batchPoster) external view returns (address);
+    function getFeeCollector(
+        address batchPoster
+    ) external view returns (address);
 
     /// @notice Set the address where fees to batchPoster are sent.
     /// This reverts unless called by the batch poster, its fee collector, or a chain owner
@@ -40,7 +46,9 @@ interface ArbAggregator {
     /// @notice Deprecated, always returns zero
     /// @notice Get the tx base fee (in approximate L1 gas) for aggregator
     /// @param aggregator The aggregator to get the base fee for
-    function getTxBaseFee(address aggregator) external view returns (uint256);
+    function getTxBaseFee(
+        address aggregator
+    ) external view returns (uint256);
 
     /// @notice Deprecated, is now a no-op
     /// @notice Set the tx base fee (in approximate L1 gas) for aggregator

package/src/precompiles/ArbBLS.sol

@@ -6,6 +6,4 @@ pragma solidity >=0.4.21 <0.9.0;
 
 /// @title Disabled precompile, formerly used to register BLS public keys.
 /// @notice Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000067.
-interface ArbBLS {
-
-}
+interface ArbBLS {}

package/src/precompiles/ArbDebug.sol

@@ -21,21 +21,15 @@ interface ArbDebug {
     // Events that exist for testing log creation and pricing
     event Basic(bool flag, bytes32 indexed value);
     event Mixed(
-        bool indexed flag,
-        bool not,
-        bytes32 indexed value,
-        address conn,
-        address indexed caller
+        bool indexed flag, bool not, bytes32 indexed value, address conn, address indexed caller
     );
     event Store(
-        bool indexed flag,
-        address indexed field,
-        uint24 number,
-        bytes32 value,
-        bytes store
+        bool indexed flag, address indexed field, uint24 number, bytes32 value, bytes store
     );
 
-    function customRevert(uint64 number) external pure;
+    function customRevert(
+        uint64 number
+    ) external pure;
 
     function panic() external;
 

package/src/precompiles/ArbFunctionTable.sol

@@ -12,18 +12,15 @@ pragma solidity >=0.4.21 <0.9.0;
 /// Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000068.
 interface ArbFunctionTable {
     /// @notice Reverts since the table is empty
-    function upload(bytes calldata buf) external;
+    function upload(
+        bytes calldata buf
+    ) external;
 
     /// @notice Returns the empty table's size, which is 0
-    function size(address addr) external view returns (uint256);
+    function size(
+        address addr
+    ) external view returns (uint256);
 
     /// @notice No-op
-    function get(address addr, uint256 index)
-        external
-        view
-        returns (
-            uint256,
-            bool,
-            uint256
-        );
+    function get(address addr, uint256 index) external view returns (uint256, bool, uint256);
 }

package/src/precompiles/ArbGasInfo.sol

@@ -19,17 +19,9 @@ interface ArbGasInfo {
     ///            per ArbGas congestion,
     ///            per ArbGas total
     ///        )
-    function getPricesInWeiWithAggregator(address aggregator)
-        external
-        view
-        returns (
-            uint256,
-            uint256,
-            uint256,
-            uint256,
-            uint256,
-            uint256
-        );
+    function getPricesInWeiWithAggregator(
+        address aggregator
+    ) external view returns (uint256, uint256, uint256, uint256, uint256, uint256);
 
     /// @notice Get gas prices. Uses the caller's preferred aggregator, or the default if the caller doesn't have a preferred one.
     /// @return return gas prices in wei
@@ -44,47 +36,21 @@ interface ArbGasInfo {
     function getPricesInWei()
         external
         view
-        returns (
-            uint256,
-            uint256,
-            uint256,
-            uint256,
-            uint256,
-            uint256
-        );
+        returns (uint256, uint256, uint256, uint256, uint256, uint256);
 
     /// @notice Get prices in ArbGas for the supplied aggregator
     /// @return (per L2 tx, per L1 calldata byte, per storage allocation)
-    function getPricesInArbGasWithAggregator(address aggregator)
-        external
-        view
-        returns (
-            uint256,
-            uint256,
-            uint256
-        );
+    function getPricesInArbGasWithAggregator(
+        address aggregator
+    ) external view returns (uint256, uint256, uint256);
 
     /// @notice Get prices in ArbGas. Assumes the callers preferred validator, or the default if caller doesn't have a preferred one.
     /// @return (per L2 tx, per L1 calldata byte, per storage allocation)
-    function getPricesInArbGas()
-        external
-        view
-        returns (
-            uint256,
-            uint256,
-            uint256
-        );
+    function getPricesInArbGas() external view returns (uint256, uint256, uint256);
 
     /// @notice Get the gas accounting parameters. `gasPoolMax` is always zero, as the exponential pricing model has no such notion.
     /// @return (speedLimitPerSecond, gasPoolMax, maxTxGasLimit)
-    function getGasAccountingParams()
-        external
-        view
-        returns (
-            uint256,
-            uint256,
-            uint256
-        );
+    function getGasAccountingParams() external view returns (uint256, uint256, uint256);
 
     /// @notice Get the minimum gas price needed for a tx to succeed
     function getMinimumGasPrice() external view returns (uint256);

package/src/precompiles/ArbInfo.sol

@@ -8,8 +8,12 @@ pragma solidity >=0.4.21 <0.9.0;
 /// @notice Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000065.
 interface ArbInfo {
     /// @notice Retrieves an account's balance
-    function getBalance(address account) external view returns (uint256);
+    function getBalance(
+        address account
+    ) external view returns (uint256);
 
     /// @notice Retrieves a contract's deployed code
-    function getCode(address account) external view returns (bytes memory);
+    function getCode(
+        address account
+    ) external view returns (bytes memory);
 }

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
@@ -53,10 +55,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
@@ -76,7 +78,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
@@ -86,10 +90,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
@@ -100,11 +104,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
@@ -143,9 +143,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);