@arbitrum/nitro-contracts 1.0.0-beta.5 → 1.0.0-beta.6

package/src/mocks/SequencerInboxStub.sol

@@ -8,24 +8,26 @@ import "../bridge/SequencerInbox.sol";
 
 contract SequencerInboxStub is SequencerInbox {
     constructor(
-        IBridge delayedBridge_,
+        IBridge bridge_,
         address sequencer_,
         ISequencerInbox.MaxTimeVariation memory maxTimeVariation_
     ) {
-        delayedBridge = delayedBridge_;
-        rollup = msg.sender;
+        bridge = bridge_;
+        rollup = IOwnable(msg.sender);
         maxTimeVariation = maxTimeVariation_;
         isBatchPoster[sequencer_] = true;
     }
 
     function addInitMessage() external {
         (bytes32 dataHash, TimeBounds memory timeBounds) = formEmptyDataHash(0);
-        (bytes32 beforeAcc, bytes32 delayedAcc, bytes32 afterAcc) = addSequencerL2BatchImpl(
-            dataHash,
-            0
-        );
+        (
+            uint256 sequencerMessageCount,
+            bytes32 beforeAcc,
+            bytes32 delayedAcc,
+            bytes32 afterAcc
+        ) = addSequencerL2BatchImpl(dataHash, 0, 0);
         emit SequencerBatchDelivered(
-            inboxAccs.length - 1,
+            sequencerMessageCount,
             beforeAcc,
             afterAcc,
             delayedAcc,

package/src/mocks/Simple.sol

@@ -4,10 +4,13 @@
 
 pragma solidity ^0.8.0;
 
+import "../precompiles/ArbRetryableTx.sol";
+
 contract Simple {
     uint64 public counter;
 
     event CounterEvent(uint64 count);
+    event RedeemedEvent(address caller, address redeemer);
     event NullEvent();
 
     function increment() external {
@@ -19,6 +22,11 @@ contract Simple {
         emit CounterEvent(counter);
     }
 
+    function incrementRedeem() external {
+        counter++;
+        emit RedeemedEvent(msg.sender, ArbRetryableTx(address(110)).getCurrentRedeemer());
+    }
+
     function emitNullEvent() external {
         emit NullEvent();
     }

package/src/node-interface/NodeInterface.sol

@@ -11,7 +11,8 @@ pragma solidity >=0.4.21 <0.9.0;
  */
 interface NodeInterface {
     /**
-     * @notice Estimate the cost of putting a message in the L2 inbox that is reexecuted
+     * @notice Estimate the cost of putting a message in the L2 inbox that is reexecuted.
+     * Use eth_estimateGas to call.
      * @param sender sender of the L1 and L2 transaction
      * @param deposit amount to deposit to sender in L2
      * @param to destination L2 contract address
@@ -31,7 +32,8 @@ interface NodeInterface {
     ) external;
 
     /**
-     * @notice Constructs an outbox proof of an l2->l1 send's existence in the outbox accumulator
+     * @notice Constructs an outbox proof of an l2->l1 send's existence in the outbox accumulator.
+     * Use eth_call to call.
      * @param size the number of elements in the accumulator
      * @param leaf the position of the send in the accumulator
      * @return send the l2->l1 send's hash
@@ -48,8 +50,9 @@ interface NodeInterface {
         );
 
     /**
-     * @notice Finds the L1 batch containing a requested L2 block, reverting if none does
-     * Throws if block doesn't exist, or if block number is 0
+     * @notice Finds the L1 batch containing a requested L2 block, reverting if none does.
+     * Use eth_call to call.
+     * Throws if block doesn't exist, or if block number is 0. Use eth_call
      * @param blockNum The L2 block being queried
      * @return batch The L1 block containing the requested L2 block
      */
@@ -59,9 +62,33 @@ interface NodeInterface {
      * @notice Gets the number of L1 confirmations of the sequencer batch producing the requested L2 block
      * This gets the number of L1 confirmations for the input message producing the L2 block,
      * which happens well before the L1 rollup contract confirms the L2 block.
-     * Throws if block doesnt exist in the L2 chain.
+     * Throws if block doesnt exist in the L2 chain. Use eth_call to call.
      * @param blockHash The hash of the L2 block being queried
      * @return confirmations The number of L1 confirmations the sequencer batch has. Returns 0 if block not yet included in an L1 batch.
      */
     function getL1Confirmations(bytes32 blockHash) external view returns (uint64 confirmations);
+
+    /**
+     * @notice Same as native gas estimation, but with additional info on the l1 costs. Use eth_call to call.
+     * @param data the tx's calldata. Everything else like "From" and "Gas" are copied over
+     * @param to the tx's "To" (ignored when contractCreation is true)
+     * @param contractCreation whether "To" is omitted
+     * @return gasEstimate an estimate of the total amount of gas needed for this tx
+     * @return gasEstimateForL1 an estimate of the amount of gas needed for the l1 component of this tx
+     * @return baseFee the l2 base fee
+     * @return l1BaseFeeEstimate ArbOS's l1 estimate of the l1 base fee
+     */
+    function gasEstimateComponents(
+        address to,
+        bool contractCreation,
+        bytes calldata data
+    )
+        external
+        payable
+        returns (
+            uint64 gasEstimate,
+            uint64 gasEstimateForL1,
+            uint256 baseFee,
+            uint256 l1BaseFeeEstimate
+        );
 }

package/src/osp/IOneStepProver.sol

@@ -12,8 +12,7 @@ import "../bridge/IBridge.sol";
 
 struct ExecutionContext {
     uint256 maxInboxMessagesRead;
-    ISequencerInbox sequencerInbox;
-    IBridge delayedBridge;
+    IBridge bridge;
 }
 
 abstract contract IOneStepProver {

package/src/osp/OneStepProver0.sol

@@ -12,7 +12,6 @@ import "./IOneStepProver.sol";
 
 contract OneStepProver0 is IOneStepProver {
     using MerkleProofLib for MerkleProof;
-    using PcStackLib for PcStack;
     using StackFrameLib for StackFrameWindow;
     using ValueLib for Value;
     using ValueStackLib for ValueStack;
@@ -51,8 +50,6 @@ contract OneStepProver0 is IOneStepProver {
             ty = ValueType.F32;
         } else if (opcode == Instructions.F64_CONST) {
             ty = ValueType.F64;
-        } else if (opcode == Instructions.PUSH_STACK_BOUNDARY) {
-            ty = ValueType.STACK_BOUNDARY;
         } else {
             revert("CONST_PUSH_INVALID_OPCODE");
         }
@@ -86,39 +83,6 @@ contract OneStepProver0 is IOneStepProver {
         }
     }
 
-    function executeBlock(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata inst,
-        bytes calldata
-    ) internal pure {
-        uint32 targetPc = uint32(inst.argumentData);
-        require(targetPc == inst.argumentData, "BAD_BLOCK_PC");
-        mach.blockStack.push(targetPc);
-    }
-
-    function executeBranch(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        mach.functionPc = mach.blockStack.pop();
-    }
-
-    function executeBranchIf(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        uint32 cond = mach.valueStack.pop().assumeI32();
-        if (cond != 0) {
-            // Jump to target
-            mach.functionPc = mach.blockStack.pop();
-        }
-    }
-
     function executeReturn(
         Machine memory mach,
         Module memory,
@@ -419,27 +383,6 @@ contract OneStepProver0 is IOneStepProver {
         );
     }
 
-    function executeEndBlock(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        mach.blockStack.pop();
-    }
-
-    function executeEndBlockIf(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        uint32 cond = mach.valueStack.peek().assumeI32();
-        if (cond != 0) {
-            mach.blockStack.pop();
-        }
-    }
-
     function executeInitFrame(
         Machine memory mach,
         Module memory,
@@ -476,20 +419,6 @@ contract OneStepProver0 is IOneStepProver {
         }
     }
 
-    function executeIsStackBoundary(
-        Machine memory mach,
-        Module memory,
-        Instruction calldata,
-        bytes calldata
-    ) internal pure {
-        Value memory val = mach.valueStack.pop();
-        uint32 newContents = 0;
-        if (val.valueType == ValueType.STACK_BOUNDARY) {
-            newContents = 1;
-        }
-        mach.valueStack.push(ValueLib.newI32(newContents));
-    }
-
     function executeDup(
         Machine memory mach,
         Module memory,
@@ -519,12 +448,6 @@ contract OneStepProver0 is IOneStepProver {
             impl = executeUnreachable;
         } else if (opcode == Instructions.NOP) {
             impl = executeNop;
-        } else if (opcode == Instructions.BLOCK) {
-            impl = executeBlock;
-        } else if (opcode == Instructions.BRANCH) {
-            impl = executeBranch;
-        } else if (opcode == Instructions.BRANCH_IF) {
-            impl = executeBranchIf;
         } else if (opcode == Instructions.RETURN) {
             impl = executeReturn;
         } else if (opcode == Instructions.CALL) {
@@ -535,10 +458,6 @@ contract OneStepProver0 is IOneStepProver {
             impl = executeCallerModuleInternalCall;
         } else if (opcode == Instructions.CALL_INDIRECT) {
             impl = executeCallIndirect;
-        } else if (opcode == Instructions.END_BLOCK) {
-            impl = executeEndBlock;
-        } else if (opcode == Instructions.END_BLOCK_IF) {
-            impl = executeEndBlockIf;
         } else if (opcode == Instructions.ARBITRARY_JUMP) {
             impl = executeArbitraryJump;
         } else if (opcode == Instructions.ARBITRARY_JUMP_IF) {
@@ -557,18 +476,13 @@ contract OneStepProver0 is IOneStepProver {
             impl = executeDrop;
         } else if (opcode == Instructions.SELECT) {
             impl = executeSelect;
-        } else if (
-            (opcode >= Instructions.I32_CONST && opcode <= Instructions.F64_CONST) ||
-            opcode == Instructions.PUSH_STACK_BOUNDARY
-        ) {
+        } else if (opcode >= Instructions.I32_CONST && opcode <= Instructions.F64_CONST) {
             impl = executeConstPush;
         } else if (
             opcode == Instructions.MOVE_FROM_STACK_TO_INTERNAL ||
             opcode == Instructions.MOVE_FROM_INTERNAL_TO_STACK
         ) {
             impl = executeMoveInternal;
-        } else if (opcode == Instructions.IS_STACK_BOUNDARY) {
-            impl = executeIsStackBoundary;
         } else if (opcode == Instructions.DUP) {
             impl = executeDup;
         } else {

package/src/osp/OneStepProverHostIo.sol

@@ -10,7 +10,6 @@ import "../state/Deserialize.sol";
 import "./IOneStepProver.sol";
 import "../bridge/Messages.sol";
 import "../bridge/IBridge.sol";
-import "../bridge/ISequencerInbox.sol";
 
 contract OneStepProverHostIo is IOneStepProver {
     using GlobalStateLib for GlobalState;
@@ -165,13 +164,13 @@ contract OneStepProverHostIo is IOneStepProver {
         bytes32 delayedAcc;
 
         if (msgIndex > 0) {
-            beforeAcc = execCtx.sequencerInbox.inboxAccs(msgIndex - 1);
+            beforeAcc = execCtx.bridge.sequencerInboxAccs(msgIndex - 1);
         }
         if (afterDelayedMsg > 0) {
-            delayedAcc = execCtx.delayedBridge.inboxAccs(afterDelayedMsg - 1);
+            delayedAcc = execCtx.bridge.delayedInboxAccs(afterDelayedMsg - 1);
         }
         bytes32 acc = keccak256(abi.encodePacked(beforeAcc, messageHash, delayedAcc));
-        require(acc == execCtx.sequencerInbox.inboxAccs(msgIndex), "BAD_SEQINBOX_MESSAGE");
+        require(acc == execCtx.bridge.sequencerInboxAccs(msgIndex), "BAD_SEQINBOX_MESSAGE");
         return true;
     }
 
@@ -185,7 +184,7 @@ contract OneStepProverHostIo is IOneStepProver {
         bytes32 beforeAcc;
 
         if (msgIndex > 0) {
-            beforeAcc = execCtx.delayedBridge.inboxAccs(msgIndex - 1);
+            beforeAcc = execCtx.bridge.delayedInboxAccs(msgIndex - 1);
         }
 
         bytes32 messageDataHash = keccak256(message[DELAYED_HEADER_LEN:]);
@@ -198,7 +197,7 @@ contract OneStepProverHostIo is IOneStepProver {
         );
         bytes32 acc = Messages.accumulateInboxMessage(beforeAcc, messageHash);
 
-        require(acc == execCtx.delayedBridge.inboxAccs(msgIndex), "BAD_DELAYED_MESSAGE");
+        require(acc == execCtx.bridge.delayedInboxAccs(msgIndex), "BAD_DELAYED_MESSAGE");
         return true;
     }
 

package/src/osp/OneStepProverMath.sol

@@ -210,38 +210,38 @@ contract OneStepProverMath is IOneStepProver {
         uint64 a,
         uint64 b,
         uint16 opcodeOffset
-    ) internal pure returns (uint64) {
+    ) internal pure returns (uint64, bool) {
         unchecked {
             if (opcodeOffset == 0) {
                 // add
-                return a + b;
+                return (a + b, false);
             } else if (opcodeOffset == 1) {
                 // sub
-                return a - b;
+                return (a - b, false);
             } else if (opcodeOffset == 2) {
                 // mul
-                return a * b;
+                return (a * b, false);
             } else if (opcodeOffset == 4) {
                 // div_u
                 if (b == 0) {
-                    return 0;
+                    return (0, true);
                 }
-                return a / b;
+                return (a / b, false);
             } else if (opcodeOffset == 6) {
                 // rem_u
                 if (b == 0) {
-                    return 0;
+                    return (0, true);
                 }
-                return a % b;
+                return (a % b, false);
             } else if (opcodeOffset == 7) {
                 // and
-                return a & b;
+                return (a & b, false);
             } else if (opcodeOffset == 8) {
                 // or
-                return a | b;
+                return (a | b, false);
             } else if (opcodeOffset == 9) {
                 // xor
-                return a ^ b;
+                return (a ^ b, false);
             } else {
                 revert("INVALID_GENERIC_BIN_OP");
             }
@@ -263,18 +263,18 @@ contract OneStepProverMath is IOneStepProver {
         unchecked {
             if (opcodeOffset == 3) {
                 // div_s
-                if (b == 0) {
-                    res = 0;
-                } else {
-                    res = uint32(int32(a) / int32(b));
+                if (b == 0 || (int32(a) == -2147483648 && int32(b) == -1)) {
+                    mach.status = MachineStatus.ERRORED;
+                    return;
                 }
+                res = uint32(int32(a) / int32(b));
             } else if (opcodeOffset == 5) {
                 // rem_s
                 if (b == 0) {
-                    res = 0;
-                } else {
-                    res = uint32(int32(a) % int32(b));
+                    mach.status = MachineStatus.ERRORED;
+                    return;
                 }
+                res = uint32(int32(a) % int32(b));
             } else if (opcodeOffset == 10) {
                 // shl
                 res = a << (b % 32);
@@ -291,7 +291,12 @@ contract OneStepProverMath is IOneStepProver {
                 // rotr
                 res = rotr32(a, b);
             } else {
-                res = uint32(genericBinOp(a, b, opcodeOffset));
+                (uint64 computed, bool err) = genericBinOp(a, b, opcodeOffset);
+                if (err) {
+                    mach.status = MachineStatus.ERRORED;
+                    return;
+                }
+                res = uint32(computed);
             }
         }
 
@@ -313,18 +318,18 @@ contract OneStepProverMath is IOneStepProver {
         unchecked {
             if (opcodeOffset == 3) {
                 // div_s
-                if (b == 0) {
-                    res = 0;
-                } else {
-                    res = uint64(int64(a) / int64(b));
+                if (b == 0 || (int64(a) == -9223372036854775808 && int64(b) == -1)) {
+                    mach.status = MachineStatus.ERRORED;
+                    return;
                 }
+                res = uint64(int64(a) / int64(b));
             } else if (opcodeOffset == 5) {
                 // rem_s
                 if (b == 0) {
-                    res = 0;
-                } else {
-                    res = uint64(int64(a) % int64(b));
+                    mach.status = MachineStatus.ERRORED;
+                    return;
                 }
+                res = uint64(int64(a) % int64(b));
             } else if (opcodeOffset == 10) {
                 // shl
                 res = a << (b % 64);
@@ -341,7 +346,12 @@ contract OneStepProverMath is IOneStepProver {
                 // rotr
                 res = rotr64(a, b);
             } else {
-                res = genericBinOp(a, b, opcodeOffset);
+                bool err;
+                (res, err) = genericBinOp(a, b, opcodeOffset);
+                if (err) {
+                    mach.status = MachineStatus.ERRORED;
+                    return;
+                }
             }
         }
 

package/src/osp/OneStepProverMemory.sol

@@ -271,10 +271,9 @@ contract OneStepProverMemory is IOneStepProver {
         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);
+        uint256 newSize = uint256(oldPages) + uint256(growingPages);
+        if (newSize <= mod.moduleMemory.maxSize) {
+            mod.moduleMemory.size = uint64(newSize * PAGE_SIZE);
             mach.valueStack.push(ValueLib.newI32(oldPages));
         } else {
             mach.valueStack.push(ValueLib.newI32(~uint32(0)));

package/src/precompiles/ArbAggregator.sol

@@ -7,45 +7,35 @@ 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
+    /// @notice Deprecated, customization of preferred aggregator is no longer supported
+    /// @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);
 
-    /// @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 Deprecated, there is no longer a single preferred aggregator, use getBatchPosters instead
     /// @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
+    /// @notice Get a list of all current batch posters
+    /// @return Batch poster addresses
+    function getBatchPosters() external view returns (address[] memory);
+
+    /// @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;
+
+    /// @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);
+
+    /// @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
+    /// @param batchPoster The batch poster to set the fee collector for
     /// @param newFeeCollector The new fee collector to set
-    function setFeeCollector(address aggregator, address newFeeCollector) external;
+    function setFeeCollector(address batchPoster, address newFeeCollector) external;
 
     /// @notice Deprecated, always returns zero
     /// @notice Get the tx base fee (in approximate L1 gas) for aggregator

package/src/precompiles/ArbBLS.sol

@@ -4,50 +4,8 @@
 
 pragma solidity >=0.4.21 <0.9.0;
 
-/// @title Provides a registry of BLS public keys for accounts.
+/// @title Disabled precompile, formerly used to register BLS public keys.
 /// @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/ArbGasInfo.sol

@@ -75,7 +75,7 @@ interface ArbGasInfo {
             uint256
         );
 
-    /// @notice Get the gas accounting parameters
+    /// @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
@@ -89,21 +89,6 @@ interface ArbGasInfo {
     /// @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);
 
@@ -116,9 +101,6 @@ interface ArbGasInfo {
     /// @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);
-
     /// @notice Get the backlogged amount of gas burnt in excess of the speed limit
     function getGasBacklog() external view returns (uint64);