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

package/src/osp/OneStepProverHostIo.sol

@@ -29,11 +29,7 @@ contract OneStepProverHostIo is IOneStepProver {
     uint64 private constant INBOX_HEADER_LEN = 40;
     uint64 private constant DELAYED_HEADER_LEN = 112 + 1;
 
-    function setLeafByte(
-        bytes32 oldLeaf,
-        uint256 idx,
-        uint8 val
-    ) internal pure returns (bytes32) {
+    function setLeafByte(bytes32 oldLeaf, uint256 idx, uint8 val) internal pure returns (bytes32) {
         require(idx < LEAF_SIZE, "BAD_SET_LEAF_BYTE_IDX");
         // Take into account that we are casting the leaf to a big-endian integer
         uint256 leafShift = (LEAF_SIZE - 1 - idx) * 8;
@@ -66,17 +62,12 @@ contract OneStepProverHostIo is IOneStepProver {
         uint256 proofOffset = 0;
         bytes32 startLeafContents;
         MerkleProof memory merkleProof;
-        (startLeafContents, proofOffset, merkleProof) = mod.moduleMemory.proveLeaf(
-            leafIdx,
-            proof,
-            proofOffset
-        );
+        (startLeafContents, proofOffset, merkleProof) =
+            mod.moduleMemory.proveLeaf(leafIdx, proof, proofOffset);
 
         if (inst.opcode == Instructions.GET_GLOBAL_STATE_BYTES32) {
-            mod.moduleMemory.merkleRoot = merkleProof.computeRootFromMemory(
-                leafIdx,
-                state.bytes32Vals[idx]
-            );
+            mod.moduleMemory.merkleRoot =
+                merkleProof.computeRootFromMemory(leafIdx, state.bytes32Vals[idx]);
         } else if (inst.opcode == Instructions.SET_GLOBAL_STATE_BYTES32) {
             state.bytes32Vals[idx] = startLeafContents;
         } else {
@@ -113,11 +104,7 @@ contract OneStepProverHostIo is IOneStepProver {
 
     // Computes b**e % m
     // Really pure but the Solidity compiler sees the staticcall and requires view
-    function modExp256(
-        uint256 b,
-        uint256 e,
-        uint256 m
-    ) internal view returns (uint256) {
+    function modExp256(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
         bytes memory modExpInput = abi.encode(32, 32, 32, b, e, m);
         (bool modexpSuccess, bytes memory modExpOutput) = address(0x05).staticcall(modExpInput);
         require(modexpSuccess, "MODEXP_FAILED");
@@ -143,11 +130,8 @@ contract OneStepProverHostIo is IOneStepProver {
         uint256 proofOffset = 0;
         bytes32 leafContents;
         MerkleProof memory merkleProof;
-        (leafContents, proofOffset, merkleProof) = mod.moduleMemory.proveLeaf(
-            leafIdx,
-            proof,
-            proofOffset
-        );
+        (leafContents, proofOffset, merkleProof) =
+            mod.moduleMemory.proveLeaf(leafIdx, proof, proofOffset);
 
         bytes memory extracted;
         uint8 proofType = uint8(proof[proofOffset]);
@@ -257,7 +241,7 @@ contract OneStepProverHostIo is IOneStepProver {
         require(message.length >= INBOX_HEADER_LEN, "BAD_SEQINBOX_PROOF");
 
         uint64 afterDelayedMsg;
-        (afterDelayedMsg, ) = Deserialize.u64(message, 32);
+        (afterDelayedMsg,) = Deserialize.u64(message, 32);
         bytes32 messageHash = keccak256(message);
         bytes32 beforeAcc;
         bytes32 delayedAcc;
@@ -289,7 +273,7 @@ contract OneStepProverHostIo is IOneStepProver {
         bytes32 messageDataHash = keccak256(message[DELAYED_HEADER_LEN:]);
         bytes1 kind = message[0];
         uint256 sender;
-        (sender, ) = Deserialize.u256(message, 1);
+        (sender,) = Deserialize.u256(message, 1);
 
         bytes32 messageHash = keccak256(
             abi.encodePacked(kind, uint160(sender), message[33:DELAYED_HEADER_LEN], messageDataHash)
@@ -311,10 +295,10 @@ contract OneStepProverHostIo is IOneStepProver {
         uint256 ptr = mach.valueStack.pop().assumeI32();
         uint256 msgIndex = mach.valueStack.pop().assumeI64();
         if (
-            inst.argumentData == Instructions.INBOX_INDEX_SEQUENCER &&
-            msgIndex >= execCtx.maxInboxMessagesRead
+            inst.argumentData == Instructions.INBOX_INDEX_SEQUENCER
+                && msgIndex >= execCtx.maxInboxMessagesRead
         ) {
-            mach.status = MachineStatus.TOO_FAR;
+            mach.status = MachineStatus.ERRORED;
             return;
         }
 
@@ -327,11 +311,8 @@ contract OneStepProverHostIo is IOneStepProver {
         uint256 proofOffset = 0;
         bytes32 leafContents;
         MerkleProof memory merkleProof;
-        (leafContents, proofOffset, merkleProof) = mod.moduleMemory.proveLeaf(
-            leafIdx,
-            proof,
-            proofOffset
-        );
+        (leafContents, proofOffset, merkleProof) =
+            mod.moduleMemory.proveLeaf(leafIdx, proof, proofOffset);
 
         {
             // TODO: support proving via an authenticated contract
@@ -364,11 +345,8 @@ contract OneStepProverHostIo is IOneStepProver {
 
         uint32 i = 0;
         for (; i < 32 && messageOffset + i < messageLength; i++) {
-            leafContents = setLeafByte(
-                leafContents,
-                i,
-                uint8(proof[proofOffset + messageOffset + i])
-            );
+            leafContents =
+                setLeafByte(leafContents, i, uint8(proof[proofOffset + messageOffset + i]));
         }
 
         mod.moduleMemory.merkleRoot = merkleProof.computeRootFromMemory(leafIdx, leafContents);
@@ -385,7 +363,9 @@ contract OneStepProverHostIo is IOneStepProver {
         mach.status = MachineStatus.FINISHED;
     }
 
-    function isPowerOfTwo(uint256 value) internal pure returns (bool) {
+    function isPowerOfTwo(
+        uint256 value
+    ) internal pure returns (bool) {
         return value != 0 && (value & (value - 1) == 0);
     }
 
@@ -396,11 +376,7 @@ contract OneStepProverHostIo is IOneStepProver {
     )
         internal
         pure
-        returns (
-            uint256 leaf,
-            MerkleProof memory leafProof,
-            MerkleProof memory zeroProof
-        )
+        returns (uint256 leaf, MerkleProof memory leafProof, MerkleProof memory zeroProof)
     {
         string memory prefix = "Module merkle tree:";
         bytes32 root = mach.modulesRoot;
@@ -445,13 +421,10 @@ contract OneStepProverHostIo is IOneStepProver {
             mach.status = MachineStatus.ERRORED;
             return;
         }
-        (bytes32 userMod, uint256 offset, ) = mod.moduleMemory.proveLeaf(
-            pointer / LEAF_SIZE,
-            proof,
-            0
-        );
+        (bytes32 userMod, uint256 offset,) =
+            mod.moduleMemory.proveLeaf(pointer / LEAF_SIZE, proof, 0);
 
-        (uint256 leaf, , MerkleProof memory zeroProof) = proveLastLeaf(mach, offset, proof);
+        (uint256 leaf,, MerkleProof memory zeroProof) = proveLastLeaf(mach, offset, proof);
 
         bool balanced = isPowerOfTwo(leaf + 1);
         if (balanced) {
@@ -472,7 +445,7 @@ contract OneStepProverHostIo is IOneStepProver {
     ) internal pure {
         string memory prefix = "Module merkle tree:";
 
-        (uint256 leaf, MerkleProof memory leafProof, ) = proveLastLeaf(mach, 0, proof);
+        (uint256 leaf, MerkleProof memory leafProof,) = proveLastLeaf(mach, 0, proof);
 
         bool shrink = isPowerOfTwo(leaf);
         if (shrink) {
@@ -497,8 +470,8 @@ contract OneStepProverHostIo is IOneStepProver {
         require(state.hash() == mach.globalStateHash, "BAD_GLOBAL_STATE");
 
         if (
-            opcode == Instructions.GET_GLOBAL_STATE_BYTES32 ||
-            opcode == Instructions.SET_GLOBAL_STATE_BYTES32
+            opcode == Instructions.GET_GLOBAL_STATE_BYTES32
+                || opcode == Instructions.SET_GLOBAL_STATE_BYTES32
         ) {
             executeGetOrSetBytes32(mach, mod, state, inst, proof[proofOffset:]);
         } else if (opcode == Instructions.GET_GLOBAL_STATE_U64) {
@@ -539,8 +512,8 @@ contract OneStepProverHostIo is IOneStepProver {
             require(multi.remainingHash == bytes32(0), "WRONG_COTHREAD_EMPTY");
         } else {
             require(
-                keccak256(abi.encodePacked("cothread:", newInactiveCoThread, newRemaining)) ==
-                    multi.remainingHash,
+                keccak256(abi.encodePacked("cothread:", newInactiveCoThread, newRemaining))
+                    == multi.remainingHash,
                 "WRONG_COTHREAD_POP"
             );
         }
@@ -620,8 +593,8 @@ contract OneStepProverHostIo is IOneStepProver {
         ) internal view impl;
 
         if (
-            opcode >= Instructions.GET_GLOBAL_STATE_BYTES32 &&
-            opcode <= Instructions.SET_GLOBAL_STATE_U64
+            opcode >= Instructions.GET_GLOBAL_STATE_BYTES32
+                && opcode <= Instructions.SET_GLOBAL_STATE_U64
         ) {
             impl = executeGlobalStateAccess;
         } else if (opcode == Instructions.READ_PRE_IMAGE) {

package/src/osp/OneStepProverMath.sol

@@ -39,18 +39,16 @@ contract OneStepProverMath is IOneStepProver {
         mach.valueStack.push(ValueLib.newI32(output));
     }
 
-    function signExtend(uint32 a) internal pure returns (uint64) {
+    function signExtend(
+        uint32 a
+    ) internal pure returns (uint64) {
         if (a & (1 << 31) != 0) {
             return uint64(a) | uint64(0xffffffff00000000);
         }
         return uint64(a);
     }
 
-    function i64RelOp(
-        uint64 a,
-        uint64 b,
-        uint16 relop
-    ) internal pure returns (bool) {
+    function i64RelOp(uint64 a, uint64 b, uint16 relop) internal pure returns (bool) {
         if (relop == Instructions.IRELOP_EQ) {
             return (a == b);
         } else if (relop == Instructions.IRELOP_NE) {
@@ -90,10 +88,8 @@ contract OneStepProverMath is IOneStepProver {
         uint64 b64;
 
         if (
-            relop == Instructions.IRELOP_LT_S ||
-            relop == Instructions.IRELOP_GT_S ||
-            relop == Instructions.IRELOP_LE_S ||
-            relop == Instructions.IRELOP_GE_S
+            relop == Instructions.IRELOP_LT_S || relop == Instructions.IRELOP_GT_S
+                || relop == Instructions.IRELOP_LE_S || relop == Instructions.IRELOP_GE_S
         ) {
             a64 = signExtend(a);
             b64 = signExtend(b);
@@ -123,11 +119,7 @@ contract OneStepProverMath is IOneStepProver {
         mach.valueStack.push(ValueLib.newBoolean(res));
     }
 
-    function genericIUnOp(
-        uint64 a,
-        uint16 unop,
-        uint16 bits
-    ) internal pure returns (uint32) {
+    function genericIUnOp(uint64 a, uint16 unop, uint16 bits) internal pure returns (uint32) {
         require(bits == 32 || bits == 64, "WRONG USE OF genericUnOp");
         if (unop == Instructions.IUNOP_CLZ) {
             /* curbits is one-based to keep with unsigned mathematics */
@@ -480,25 +472,25 @@ contract OneStepProverMath is IOneStepProver {
         if (opcode == Instructions.I32_EQZ || opcode == Instructions.I64_EQZ) {
             impl = executeEqz;
         } else if (
-            opcode >= Instructions.I32_RELOP_BASE &&
-            opcode <= Instructions.I32_RELOP_BASE + Instructions.IRELOP_LAST
+            opcode >= Instructions.I32_RELOP_BASE
+                && opcode <= Instructions.I32_RELOP_BASE + Instructions.IRELOP_LAST
         ) {
             impl = executeI32RelOp;
         } else if (
-            opcode >= Instructions.I32_UNOP_BASE &&
-            opcode <= Instructions.I32_UNOP_BASE + Instructions.IUNOP_LAST
+            opcode >= Instructions.I32_UNOP_BASE
+                && opcode <= Instructions.I32_UNOP_BASE + Instructions.IUNOP_LAST
         ) {
             impl = executeI32UnOp;
         } else if (opcode >= Instructions.I32_ADD && opcode <= Instructions.I32_ROTR) {
             impl = executeI32BinOp;
         } else if (
-            opcode >= Instructions.I64_RELOP_BASE &&
-            opcode <= Instructions.I64_RELOP_BASE + Instructions.IRELOP_LAST
+            opcode >= Instructions.I64_RELOP_BASE
+                && opcode <= Instructions.I64_RELOP_BASE + Instructions.IRELOP_LAST
         ) {
             impl = executeI64RelOp;
         } else if (
-            opcode >= Instructions.I64_UNOP_BASE &&
-            opcode <= Instructions.I64_UNOP_BASE + Instructions.IUNOP_LAST
+            opcode >= Instructions.I64_UNOP_BASE
+                && opcode <= Instructions.I64_UNOP_BASE + Instructions.IUNOP_LAST
         ) {
             impl = executeI64UnOp;
         } else if (opcode >= Instructions.I64_ADD && opcode <= Instructions.I64_ROTR) {

package/src/osp/OneStepProverMemory.sol

@@ -19,11 +19,7 @@ contract OneStepProverMemory is IOneStepProver {
     uint256 private constant LEAF_SIZE = 32;
     uint64 private constant PAGE_SIZE = 65536;
 
-    function setLeafByte(
-        bytes32 oldLeaf,
-        uint256 idx,
-        uint8 val
-    ) internal pure returns (bytes32) {
+    function setLeafByte(bytes32 oldLeaf, uint256 idx, uint8 val) internal pure returns (bytes32) {
         require(idx < LEAF_SIZE, "BAD_SET_LEAF_BYTE_IDX");
         // Take into account that we are casting the leaf to a big-endian integer
         uint256 leafShift = (LEAF_SIZE - 1 - idx) * 8;
@@ -103,7 +99,7 @@ contract OneStepProverMemory is IOneStepProver {
         }
 
         uint256 index = inst.argumentData + mach.valueStack.pop().assumeI32();
-        (bool err, uint256 value, ) = mod.moduleMemory.load(index, readBytes, proof, 0);
+        (bool err, uint256 value,) = mod.moduleMemory.load(index, readBytes, proof, 0);
         if (err) {
             mach.status = MachineStatus.ERRORED;
             return;
@@ -197,31 +193,21 @@ contract OneStepProverMemory is IOneStepProver {
                 if (lastProvedLeafIdx != ~uint256(0)) {
                     // Apply the last leaf update
                     mod.moduleMemory.merkleRoot = lastProvedMerkle.computeRootFromMemory(
-                        lastProvedLeafIdx,
-                        lastProvedLeafContents
+                        lastProvedLeafIdx, lastProvedLeafContents
                     );
                 }
                 // This hits the stack size if we phrase it as mod.moduleMemory.proveLeaf(...)
-                (lastProvedLeafContents, proofOffset, lastProvedMerkle) = ModuleMemoryLib.proveLeaf(
-                    mod.moduleMemory,
-                    leafIdx,
-                    proof,
-                    proofOffset
-                );
+                (lastProvedLeafContents, proofOffset, lastProvedMerkle) =
+                    ModuleMemoryLib.proveLeaf(mod.moduleMemory, leafIdx, proof, proofOffset);
                 lastProvedLeafIdx = leafIdx;
             }
             uint256 indexWithinLeaf = idx % LEAF_SIZE;
-            lastProvedLeafContents = setLeafByte(
-                lastProvedLeafContents,
-                indexWithinLeaf,
-                uint8(toWrite)
-            );
+            lastProvedLeafContents =
+                setLeafByte(lastProvedLeafContents, indexWithinLeaf, uint8(toWrite));
             toWrite >>= 8;
         }
-        mod.moduleMemory.merkleRoot = lastProvedMerkle.computeRootFromMemory(
-            lastProvedLeafIdx,
-            lastProvedLeafContents
-        );
+        mod.moduleMemory.merkleRoot =
+            lastProvedMerkle.computeRootFromMemory(lastProvedLeafIdx, lastProvedLeafContents);
     }
 
     function executeMemorySize(

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