@arbitrum/nitro-contracts 1.0.0-beta.1

package/src/osp/OneStepProverMemory.sol

@@ -0,0 +1,313 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "../state/Value.sol";
+import "../state/Machine.sol";
+import "../state/Deserialize.sol";
+import "./IOneStepProver.sol";
+
+contract OneStepProverMemory is IOneStepProver {
+    using MerkleProofLib for MerkleProof;
+    using ModuleMemoryLib for ModuleMemory;
+    using ValueLib for Value;
+    using ValueStackLib for ValueStack;
+
+    uint256 private constant LEAF_SIZE = 32;
+    uint64 private constant PAGE_SIZE = 65536;
+
+    function pullLeafByte(bytes32 leaf, uint256 idx) internal pure returns (uint8) {
+        require(idx < LEAF_SIZE, "BAD_PULL_LEAF_BYTE_IDX");
+        // Take into account that we are casting the leaf to a big-endian integer
+        uint256 leafShift = (LEAF_SIZE - 1 - idx) * 8;
+        return uint8(uint256(leaf) >> leafShift);
+    }
+
+    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;
+        uint256 newLeaf = uint256(oldLeaf);
+        newLeaf &= ~(0xFF << leafShift);
+        newLeaf |= uint256(val) << leafShift;
+        return bytes32(newLeaf);
+    }
+
+    function executeMemoryLoad(
+        Machine memory mach,
+        Module memory mod,
+        Instruction calldata inst,
+        bytes calldata proof
+    ) internal pure {
+        ValueType ty;
+        uint256 readBytes;
+        bool signed;
+        if (inst.opcode == Instructions.I32_LOAD) {
+            ty = ValueType.I32;
+            readBytes = 4;
+            signed = false;
+        } else if (inst.opcode == Instructions.I64_LOAD) {
+            ty = ValueType.I64;
+            readBytes = 8;
+            signed = false;
+        } else if (inst.opcode == Instructions.F32_LOAD) {
+            ty = ValueType.F32;
+            readBytes = 4;
+            signed = false;
+        } else if (inst.opcode == Instructions.F64_LOAD) {
+            ty = ValueType.F64;
+            readBytes = 8;
+            signed = false;
+        } else if (inst.opcode == Instructions.I32_LOAD8_S) {
+            ty = ValueType.I32;
+            readBytes = 1;
+            signed = true;
+        } else if (inst.opcode == Instructions.I32_LOAD8_U) {
+            ty = ValueType.I32;
+            readBytes = 1;
+            signed = false;
+        } else if (inst.opcode == Instructions.I32_LOAD16_S) {
+            ty = ValueType.I32;
+            readBytes = 2;
+            signed = true;
+        } else if (inst.opcode == Instructions.I32_LOAD16_U) {
+            ty = ValueType.I32;
+            readBytes = 2;
+            signed = false;
+        } else if (inst.opcode == Instructions.I64_LOAD8_S) {
+            ty = ValueType.I64;
+            readBytes = 1;
+            signed = true;
+        } else if (inst.opcode == Instructions.I64_LOAD8_U) {
+            ty = ValueType.I64;
+            readBytes = 1;
+            signed = false;
+        } else if (inst.opcode == Instructions.I64_LOAD16_S) {
+            ty = ValueType.I64;
+            readBytes = 2;
+            signed = true;
+        } else if (inst.opcode == Instructions.I64_LOAD16_U) {
+            ty = ValueType.I64;
+            readBytes = 2;
+            signed = false;
+        } else if (inst.opcode == Instructions.I64_LOAD32_S) {
+            ty = ValueType.I64;
+            readBytes = 4;
+            signed = true;
+        } else if (inst.opcode == Instructions.I64_LOAD32_U) {
+            ty = ValueType.I64;
+            readBytes = 4;
+            signed = false;
+        } else {
+            revert("INVALID_MEMORY_LOAD_OPCODE");
+        }
+
+        // Neither of these can overflow as they're computed with much less than 256 bit integers.
+        uint256 startIdx = inst.argumentData + mach.valueStack.pop().assumeI32();
+        if (startIdx + readBytes > mod.moduleMemory.size) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+
+        uint256 proofOffset = 0;
+        uint256 lastProvedLeafIdx = ~uint256(0);
+        bytes32 lastProvedLeafContents;
+        uint64 readValue;
+        for (uint256 i = 0; i < readBytes; i++) {
+            uint256 idx = startIdx + i;
+            uint256 leafIdx = idx / LEAF_SIZE;
+            if (leafIdx != lastProvedLeafIdx) {
+                // This hits the stack size if we phrase it as mod.moduleMemory.proveLeaf(...)
+                (lastProvedLeafContents, proofOffset, ) = ModuleMemoryLib.proveLeaf(
+                    mod.moduleMemory,
+                    leafIdx,
+                    proof,
+                    proofOffset
+                );
+                lastProvedLeafIdx = leafIdx;
+            }
+            uint256 indexWithinLeaf = idx % LEAF_SIZE;
+            readValue |=
+                uint64(pullLeafByte(lastProvedLeafContents, indexWithinLeaf)) <<
+                uint64(i * 8);
+        }
+
+        if (signed) {
+            // Go down to the original uint size, change to signed, go up to correct size, convert back to unsigned
+            if (readBytes == 1 && ty == ValueType.I32) {
+                readValue = uint32(int32(int8(uint8(readValue))));
+            } else if (readBytes == 1 && ty == ValueType.I64) {
+                readValue = uint64(int64(int8(uint8(readValue))));
+            } else if (readBytes == 2 && ty == ValueType.I32) {
+                readValue = uint32(int32(int16(uint16(readValue))));
+            } else if (readBytes == 2 && ty == ValueType.I64) {
+                readValue = uint64(int64(int16(uint16(readValue))));
+            } else if (readBytes == 4 && ty == ValueType.I64) {
+                readValue = uint64(int64(int32(uint32(readValue))));
+            } else {
+                revert("BAD_READ_BYTES_SIGNED");
+            }
+        }
+
+        mach.valueStack.push(Value({valueType: ty, contents: readValue}));
+    }
+
+    function executeMemoryStore(
+        Machine memory mach,
+        Module memory mod,
+        Instruction calldata inst,
+        bytes calldata proof
+    ) internal pure {
+        uint64 writeBytes;
+        uint64 toWrite;
+        {
+            ValueType ty;
+            if (inst.opcode == Instructions.I32_STORE) {
+                ty = ValueType.I32;
+                writeBytes = 4;
+            } else if (inst.opcode == Instructions.I64_STORE) {
+                ty = ValueType.I64;
+                writeBytes = 8;
+            } else if (inst.opcode == Instructions.F32_STORE) {
+                ty = ValueType.F32;
+                writeBytes = 4;
+            } else if (inst.opcode == Instructions.F64_STORE) {
+                ty = ValueType.F64;
+                writeBytes = 8;
+            } else if (inst.opcode == Instructions.I32_STORE8) {
+                ty = ValueType.I32;
+                writeBytes = 1;
+            } else if (inst.opcode == Instructions.I32_STORE16) {
+                ty = ValueType.I32;
+                writeBytes = 2;
+            } else if (inst.opcode == Instructions.I64_STORE8) {
+                ty = ValueType.I64;
+                writeBytes = 1;
+            } else if (inst.opcode == Instructions.I64_STORE16) {
+                ty = ValueType.I64;
+                writeBytes = 2;
+            } else if (inst.opcode == Instructions.I64_STORE32) {
+                ty = ValueType.I64;
+                writeBytes = 4;
+            } else {
+                revert("INVALID_MEMORY_STORE_OPCODE");
+            }
+
+            Value memory writingVal = mach.valueStack.pop();
+            require(writingVal.valueType == ty, "BAD_STORE_TYPE");
+            toWrite = uint64(writingVal.contents);
+            if (writeBytes < 8) {
+                toWrite &= (uint64(1) << (writeBytes * 8)) - 1;
+            }
+        }
+
+        // Neither of these can overflow as they're computed with much less than 256 bit integers.
+        uint256 startIdx = inst.argumentData + mach.valueStack.pop().assumeI32();
+        if (startIdx + writeBytes > mod.moduleMemory.size) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+
+        uint256 proofOffset = 0;
+        uint256 lastProvedLeafIdx = ~uint256(0);
+        MerkleProof memory lastProvedMerkle;
+        bytes32 lastProvedLeafContents;
+        for (uint256 i = 0; i < writeBytes; i++) {
+            uint256 idx = startIdx + i;
+            uint256 leafIdx = idx / LEAF_SIZE;
+            if (leafIdx != lastProvedLeafIdx) {
+                if (lastProvedLeafIdx != ~uint256(0)) {
+                    // Apply the last leaf update
+                    mod.moduleMemory.merkleRoot = lastProvedMerkle.computeRootFromMemory(
+                        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
+                );
+                lastProvedLeafIdx = leafIdx;
+            }
+            uint256 indexWithinLeaf = idx % LEAF_SIZE;
+            lastProvedLeafContents = setLeafByte(
+                lastProvedLeafContents,
+                indexWithinLeaf,
+                uint8(toWrite)
+            );
+            toWrite >>= 8;
+        }
+        mod.moduleMemory.merkleRoot = lastProvedMerkle.computeRootFromMemory(
+            lastProvedLeafIdx,
+            lastProvedLeafContents
+        );
+    }
+
+    function executeMemorySize(
+        Machine memory mach,
+        Module memory mod,
+        Instruction calldata,
+        bytes calldata
+    ) internal pure {
+        uint32 pages = uint32(mod.moduleMemory.size / PAGE_SIZE);
+        mach.valueStack.push(ValueLib.newI32(pages));
+    }
+
+    function executeMemoryGrow(
+        Machine memory mach,
+        Module memory mod,
+        Instruction calldata,
+        bytes calldata
+    ) internal pure {
+        uint32 oldPages = uint32(mod.moduleMemory.size / PAGE_SIZE);
+        uint32 growingPages = mach.valueStack.pop().assumeI32();
+        // Safe as the input integers are too small to overflow a uint256
+        uint256 newSize = (uint256(oldPages) + uint256(growingPages)) * PAGE_SIZE;
+        // Note: we require the size remain *below* 2^32, meaning the actual limit is 2^32-PAGE_SIZE
+        if (newSize < (1 << 32)) {
+            mod.moduleMemory.size = uint64(newSize);
+            mach.valueStack.push(ValueLib.newI32(oldPages));
+        } else {
+            mach.valueStack.push(ValueLib.newI32(~uint32(0)));
+        }
+    }
+
+    function executeOneStep(
+        ExecutionContext calldata,
+        Machine calldata startMach,
+        Module calldata startMod,
+        Instruction calldata inst,
+        bytes calldata proof
+    ) external pure override returns (Machine memory mach, Module memory mod) {
+        mach = startMach;
+        mod = startMod;
+
+        uint16 opcode = inst.opcode;
+
+        function(Machine memory, Module memory, Instruction calldata, bytes calldata)
+            internal
+            pure impl;
+        if (opcode >= Instructions.I32_LOAD && opcode <= Instructions.I64_LOAD32_U) {
+            impl = executeMemoryLoad;
+        } else if (opcode >= Instructions.I32_STORE && opcode <= Instructions.I64_STORE32) {
+            impl = executeMemoryStore;
+        } else if (opcode == Instructions.MEMORY_SIZE) {
+            impl = executeMemorySize;
+        } else if (opcode == Instructions.MEMORY_GROW) {
+            impl = executeMemoryGrow;
+        } else {
+            revert("INVALID_MEMORY_OPCODE");
+        }
+
+        impl(mach, mod, inst, proof);
+    }
+}

package/src/precompiles/ArbAddressTable.sol

@@ -0,0 +1,60 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/**
+ * @title Allows registering / retrieving addresses at uint indices, saving calldata.
+ * @notice Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000066.
+ */
+interface ArbAddressTable {
+    /**
+     * @notice Check whether an address exists in the address table
+     * @param addr address to check for presence in table
+     * @return true if address is in table
+     */
+    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);
+
+    /**
+     * @notice read a compressed address from a bytes buffer
+     * @param buf bytes buffer containing an address
+     * @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);
+
+    /**
+     * @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);
+
+    /**
+     * @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);
+
+    /**
+     * @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);
+
+    /**
+     * @return size of address table (= first unused index)
+     */
+    function size() external view returns (uint256);
+}

package/src/precompiles/ArbAggregator.sol

@@ -0,0 +1,62 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/// @title Provides aggregators and their users methods for configuring how they participate in L1 aggregation.
+/// @notice Precompiled contract that exists in every Arbitrum chain at 0x000000000000000000000000000000000000006d
+interface ArbAggregator {
+    /// @notice Get the preferred aggregator for an address.
+    /// @param addr The address to fetch aggregator for
+    /// @return (preferredAggregatorAddress, isDefault)
+    ///     isDefault is true if addr is set to prefer the default aggregator
+    function getPreferredAggregator(address addr) external view returns (address, bool);
+
+    /// @notice Set the caller's preferred aggregator.
+    /// @param prefAgg If prefAgg is zero, this sets the caller to prefer the default aggregator
+    function setPreferredAggregator(address prefAgg) external;
+
+    /// @notice Get default aggregator.
+    function getDefaultAggregator() external view returns (address);
+
+    /// @notice Set the preferred aggregator.
+    /// This reverts unless called by the aggregator, its fee collector, or a chain owner
+    /// @param newDefault New default aggregator
+    function setDefaultAggregator(address newDefault) external;
+
+    /// @notice Get the aggregator's compression ratio
+    /// @param aggregator The aggregator to fetch the compression ratio for
+    /// @return The compression ratio, measured in basis points
+    function getCompressionRatio(address aggregator) external view returns (uint64);
+
+    /// @notice Set the aggregator's compression ratio
+    /// This reverts unless called by the aggregator, its fee collector, or a chain owner
+    /// @param aggregator The aggregator to set the compression ratio for
+    /// @param ratio The compression ratio, measured in basis points
+    function setCompressionRatio(address aggregator, uint64 ratio) external;
+
+    /// @notice Get the address where fees to aggregator are sent.
+    /// @param aggregator The aggregator to get the fee collector for
+    /// @return The fee collectors address. This will often but not always be the same as the aggregator's address.
+    function getFeeCollector(address aggregator) external view returns (address);
+
+    /// @notice Set the address where fees to aggregator are sent.
+    /// This reverts unless called by the aggregator, its fee collector, or a chain owner
+    /// @param aggregator The aggregator to set the fee collector for
+    /// @param newFeeCollector The new fee collector to set
+    function setFeeCollector(address aggregator, address newFeeCollector) external;
+
+    /// @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);
+
+    /// @notice Deprecated, is now a no-op
+    /// @notice Set the tx base fee (in approximate L1 gas) for aggregator
+    /// Revert unless called by aggregator or the chain owner
+    /// Revert if feeInL1Gas is outside the chain's allowed bounds
+    /// @param aggregator The aggregator to set the fee for
+    /// @param feeInL1Gas The base fee in L1 gas
+    function setTxBaseFee(address aggregator, uint256 feeInL1Gas) external;
+}

package/src/precompiles/ArbBLS.sol

@@ -0,0 +1,53 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/// @title Provides a registry of BLS public keys for accounts.
+/// @notice Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000067.
+interface ArbBLS {
+    /// @notice Deprecated -- equivalent to registerAltBN128
+    function register(
+        uint256 x0,
+        uint256 x1,
+        uint256 y0,
+        uint256 y1
+    ) external; // DEPRECATED
+
+    /// @notice Deprecated -- equivalent to getAltBN128
+    function getPublicKey(address addr)
+        external
+        view
+        returns (
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        ); // DEPRECATED
+
+    /// @notice Associate an AltBN128 public key with the caller's address
+    function registerAltBN128(
+        uint256 x0,
+        uint256 x1,
+        uint256 y0,
+        uint256 y1
+    ) external;
+
+    /// @notice Get the AltBN128 public key associated with an address (revert if there isn't one)
+    function getAltBN128(address addr)
+        external
+        view
+        returns (
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        );
+
+    /// @notice Associate a BLS 12-381 public key with the caller's address
+    function registerBLS12381(bytes calldata key) external;
+
+    /// @notice Get the BLS 12-381 public key associated with an address (revert if there isn't one)
+    function getBLS12381(address addr) external view returns (bytes memory);
+}

package/src/precompiles/ArbDebug.sol

@@ -0,0 +1,39 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/**
+ * @title A test contract whose methods are only accessible in debug mode
+ * @notice Precompiled contract that exists in every Arbitrum chain at 0x00000000000000000000000000000000000000ff.
+ */
+interface ArbDebug {
+    /// @notice Caller becomes a chain owner
+    function becomeChainOwner() external;
+
+    /// @notice Emit events with values based on the args provided
+    function events(bool flag, bytes32 value) external payable returns (address, uint256);
+
+    // 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
+    );
+    event Store(
+        bool indexed flag,
+        address indexed field,
+        uint24 number,
+        bytes32 value,
+        bytes store
+    );
+
+    function customRevert(uint64 number) external pure;
+
+    error Custom(uint64, string, bool);
+    error Unused();
+}

package/src/precompiles/ArbFunctionTable.sol

@@ -0,0 +1,29 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/// @title Deprecated - Provided aggregator's the ability to manage function tables,
+//  this enables one form of transaction compression.
+/// @notice The Nitro aggregator implementation does not use these,
+//  so these methods have been stubbed and their effects disabled.
+/// They are kept for backwards compatibility.
+/// 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;
+
+    /// @notice Returns the empty table's size, which is 0
+    function size(address addr) external view returns (uint256);
+
+    /// @notice No-op
+    function get(address addr, uint256 index)
+        external
+        view
+        returns (
+            uint256,
+            bool,
+            uint256
+        );
+}

package/src/precompiles/ArbGasInfo.sol

@@ -0,0 +1,121 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/// @title Provides insight into the cost of using the chain.
+/// @notice These methods have been adjusted to account for Nitro's heavy use of calldata compression.
+/// Of note to end-users, we no longer make a distinction between non-zero and zero-valued calldata bytes.
+/// Precompiled contract that exists in every Arbitrum chain at 0x000000000000000000000000000000000000006c.
+interface ArbGasInfo {
+    /// @notice Get gas prices for a provided aggregator
+    /// @return return gas prices in wei
+    ///        (
+    ///            per L2 tx,
+    ///            per L1 calldata unit, (a byte, non-zero or otherwise, is 16 units)
+    ///            per storage allocation,
+    ///            per ArbGas base,
+    ///            per ArbGas congestion,
+    ///            per ArbGas total
+    ///        )
+    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
+    ///        (
+    ///            per L2 tx,
+    ///            per L1 calldata unit, (a byte, non-zero or otherwise, is 16 units)
+    ///            per storage allocation,
+    ///            per ArbGas base,
+    ///            per ArbGas congestion,
+    ///            per ArbGas total
+    ///        )
+    function getPricesInWei()
+        external
+        view
+        returns (
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        );
+
+    /// @notice Get prices in ArbGas for the supplied aggregator
+    /// @return (per L2 tx, per L1 calldata unit, per storage allocation)
+    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 unit, per storage allocation)
+    function getPricesInArbGas()
+        external
+        view
+        returns (
+            uint256,
+            uint256,
+            uint256
+        );
+
+    /// @notice Get the gas accounting parameters
+    /// @return (speedLimitPerSecond, gasPoolMax, maxTxGasLimit)
+    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);
+
+    /// @notice Get the number of seconds worth of the speed limit the gas pool contains
+    function getGasPoolSeconds() external view returns (uint64);
+
+    /// @notice Get the target fullness in bips the pricing model will try to keep the pool at
+    function getGasPoolTarget() external view returns (uint64);
+
+    /// @notice Get the extent in bips to which the pricing model favors filling the pool over increasing speeds
+    function getGasPoolWeight() external view returns (uint64);
+
+    /// @notice Get ArbOS's estimate of the amount of gas being burnt per second
+    function getRateEstimate() external view returns (uint64);
+
+    /// @notice Get how slowly ArbOS updates its estimate the amount of gas being burnt per second
+    function getRateEstimateInertia() external view returns (uint64);
+
+    /// @notice Get ArbOS's estimate of the L1 basefee in wei
+    function getL1BaseFeeEstimate() external view returns (uint256);
+
+    /// @notice Get how slowly ArbOS updates its estimate of the L1 basefee
+    function getL1BaseFeeEstimateInertia() external view returns (uint64);
+
+    /// @notice Deprecated -- Same as getL1BaseFeeEstimate()
+    function getL1GasPriceEstimate() external view returns (uint256);
+
+    /// @notice Get L1 gas fees paid by the current transaction
+    function getCurrentTxL1GasFees() external view returns (uint256);
+
+    /// @notice Get the amount of gas remaining in the gas pool
+    function getGasPool() external view returns (int64);
+}