@arbitrum/nitro-contracts 3.1.1 → 3.2.0

package/src/osp/OneStepProverHostIo.sol

@@ -11,6 +11,7 @@ import "../state/MultiStack.sol";
 import "../state/Deserialize.sol";
 import "../state/ModuleMemory.sol";
 import "./IOneStepProver.sol";
+import "./ICustomDAProofValidator.sol";
 import "../bridge/Messages.sol";
 import "../bridge/IBridge.sol";
 
@@ -29,6 +30,18 @@ contract OneStepProverHostIo is IOneStepProver {
     uint64 private constant INBOX_HEADER_LEN = 40;
     uint64 private constant DELAYED_HEADER_LEN = 112 + 1;
 
+    // CustomDA proof format constants
+    uint256 private constant CERT_SIZE_LEN = 8;
+    uint256 private constant CLAIMED_VALID_LEN = 1;
+
+    ICustomDAProofValidator public immutable customDAValidator;
+
+    constructor(
+        address _customDAValidator
+    ) {
+        customDAValidator = ICustomDAProofValidator(_customDAValidator);
+    }
+
     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
@@ -136,7 +149,7 @@ contract OneStepProverHostIo is IOneStepProver {
         bytes memory extracted;
         uint8 proofType = uint8(proof[proofOffset]);
         proofOffset++;
-        // These values must be kept in sync with `arbitrator/arbutil/src/types.rs`
+        // These values must be kept in sync with `crates/arbutil/src/types.rs`
         // and `arbutil/preimage_type.go` (both in the nitro repo).
         if (inst.argumentData == 0) {
             // The machine is asking for a keccak256 preimage
@@ -220,6 +233,32 @@ contract OneStepProverHostIo is IOneStepProver {
 
                 extracted = kzgProof[64:96];
             }
+        } else if (inst.argumentData == 3) {
+            // The machine is asking for a CustomDA preimage
+            require(address(customDAValidator) != address(0), "CUSTOM_DA_VALIDATOR_NOT_SUPPORTED");
+            require(proofType == 0, "UNKNOWN_PREIMAGE_PROOF");
+
+            bytes calldata customProof = proof[proofOffset:];
+
+            // Extract certificate size and certificate
+            require(customProof.length >= CERT_SIZE_LEN, "CUSTOM_DA_PROOF_TOO_SHORT");
+
+            uint256 certSize = uint256(uint64(bytes8(customProof[0:CERT_SIZE_LEN])));
+
+            require(customProof.length >= CERT_SIZE_LEN + certSize, "PROOF_TOO_SHORT_FOR_CERT");
+
+            // Extract and validate certificate
+            bytes calldata certificate = customProof[CERT_SIZE_LEN:CERT_SIZE_LEN + certSize];
+
+            // Verify this is the certificate the machine requested
+            require(keccak256(certificate) == leafContents, "WRONG_CERTIFICATE_HASH");
+
+            // Delegate to custom validator with proven values and full proof
+            extracted =
+                customDAValidator.validateReadPreimage(leafContents, preimageOffset, customProof);
+
+            // Ensure we got a valid response
+            require(extracted.length > 0 && extracted.length <= 32, "INVALID_CUSTOM_DA_RESPONSE");
         } else {
             revert("UNKNOWN_PREIMAGE_TYPE");
         }
@@ -233,6 +272,91 @@ contract OneStepProverHostIo is IOneStepProver {
         mach.valueStack.push(ValueLib.newI32(uint32(extracted.length)));
     }
 
+    function executeValidatePreimage(
+        ExecutionContext calldata,
+        Machine memory mach,
+        Module memory mod,
+        Instruction calldata,
+        bytes calldata proof
+    ) internal view {
+        uint256 preimageType = mach.valueStack.pop().assumeI32();
+        uint256 ptr = mach.valueStack.pop().assumeI32();
+
+        // Validate preimageType fits in u8 (matches Rust u8::try_from which uses ? to propagate error)
+        if (preimageType > 255) {
+            revert("PREIMAGE_TYPE_OVERFLOW");
+        }
+
+        // Invalid enum values (4-255) return 0 with no memory access
+        // This matches Rust where PreimageType::try_from fails
+        if (preimageType >= 4) {
+            mach.valueStack.push(ValueLib.newI32(0));
+            return;
+        }
+
+        // Validate ptr (matches Rust load_32_byte_aligned check)
+        if (!mod.moduleMemory.isValidLeaf(ptr)) {
+            mach.status = MachineStatus.ERRORED;
+            return;
+        }
+
+        // Prove the hash in memory
+        uint256 leafIdx = ptr / LEAF_SIZE;
+        uint256 proofOffset = 0;
+        bytes32 leafContents;
+        MerkleProof memory merkleProof;
+        (leafContents, proofOffset, merkleProof) =
+            mod.moduleMemory.proveLeaf(leafIdx, proof, proofOffset);
+
+        if (preimageType == 3) {
+            require(address(customDAValidator) != address(0), "CUSTOM_DA_VALIDATOR_NOT_SUPPORTED");
+            if (validateAndCheckCertificate(proof, proofOffset, leafContents)) {
+                mach.valueStack.push(ValueLib.newI32(1));
+            } else {
+                mach.valueStack.push(ValueLib.newI32(0));
+            }
+        } else {
+            // preimageType 0, 1, 2 -> always valid
+            mach.valueStack.push(ValueLib.newI32(1));
+        }
+
+        // Update merkle root
+        mod.moduleMemory.merkleRoot = merkleProof.computeRootFromMemory(leafIdx, leafContents);
+    }
+
+    function validateAndCheckCertificate(
+        bytes calldata proof,
+        uint256 proofOffset,
+        bytes32 expectedHash
+    ) internal view returns (bool) {
+        // Proof format is: [certSize(8), certificate, claimedValid(1), validityProof...]
+        uint256 certSize = uint256(uint64(bytes8(proof[proofOffset:proofOffset + CERT_SIZE_LEN])));
+
+        require(
+            proof.length >= proofOffset + CERT_SIZE_LEN + certSize + CLAIMED_VALID_LEN,
+            "PROOF_TOO_SHORT"
+        );
+
+        bytes calldata certificate =
+            proof[proofOffset + CERT_SIZE_LEN:proofOffset + CERT_SIZE_LEN + certSize];
+
+        // Verify this is the certificate the machine requested
+        require(keccak256(certificate) == expectedHash, "WRONG_CERTIFICATE_HASH");
+
+        bool claimedValid = uint8(proof[proofOffset + CERT_SIZE_LEN + certSize]) != 0;
+
+        // Pass the full proof segment to validateCertificate
+        bytes calldata validationProof = proof[proofOffset:];
+
+        // Check actual validity and verify claims match
+        bool isValid = customDAValidator.validateCertificate(validationProof);
+        require(
+            isValid == claimedValid,
+            isValid ? "CLAIMED_INVALID_BUT_VALID" : "CLAIMED_VALID_BUT_INVALID"
+        );
+        return isValid;
+    }
+
     function validateSequencerInbox(
         ExecutionContext calldata execCtx,
         uint64 msgIndex,
@@ -319,10 +443,8 @@ contract OneStepProverHostIo is IOneStepProver {
             require(proof[proofOffset] == 0, "UNKNOWN_INBOX_PROOF");
             proofOffset++;
 
-            function(ExecutionContext calldata, uint64, bytes calldata)
-                internal
-                view
-                returns (bool) inboxValidate;
+            function(ExecutionContext calldata, uint64, bytes calldata) internal view returns (bool)
+                inboxValidate;
 
             bool success;
             if (inst.argumentData == Instructions.INBOX_INDEX_SEQUENCER) {
@@ -584,19 +706,17 @@ contract OneStepProverHostIo is IOneStepProver {
 
         uint16 opcode = inst.opcode;
 
-        function(
-            ExecutionContext calldata,
-            Machine memory,
-            Module memory,
-            Instruction calldata,
-            bytes calldata
-        ) internal view impl;
+        function(ExecutionContext calldata, Machine memory, Module memory, Instruction calldata, bytes calldata)
+            internal
+            view impl;
 
         if (
             opcode >= Instructions.GET_GLOBAL_STATE_BYTES32
                 && opcode <= Instructions.SET_GLOBAL_STATE_U64
         ) {
             impl = executeGlobalStateAccess;
+        } else if (opcode == Instructions.VALIDATE_CERTIFICATE) {
+            impl = executeValidatePreimage;
         } else if (opcode == Instructions.READ_PRE_IMAGE) {
             impl = executeReadPreImage;
         } else if (opcode == Instructions.READ_INBOX_MESSAGE) {

package/src/osp/OneStepProverMath.sol

@@ -466,9 +466,8 @@ contract OneStepProverMath is IOneStepProver {
 
         uint16 opcode = inst.opcode;
 
-        function(Machine memory, Module memory, Instruction calldata, bytes calldata)
-            internal
-            pure impl;
+        function(Machine memory, Module memory, Instruction calldata, bytes calldata) internal pure
+            impl;
         if (opcode == Instructions.I32_EQZ || opcode == Instructions.I64_EQZ) {
             impl = executeEqz;
         } else if (

package/src/osp/OneStepProverMemory.sol

@@ -250,9 +250,8 @@ contract OneStepProverMemory is IOneStepProver {
 
         uint16 opcode = inst.opcode;
 
-        function(Machine memory, Module memory, Instruction calldata, bytes calldata)
-            internal
-            pure impl;
+        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) {

package/src/precompiles/.github/workflows/contract-tests.yml

@@ -0,0 +1,39 @@
+name: CI
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  test-format:
+    name: Test format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+        with:
+          version: v1.3.6
+          cache: false
+
+      - name: Setup node/yarn
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: 'yarn'
+          cache-dependency-path: '**/yarn.lock'
+
+      - name: Install packages
+        run: yarn
+
+      - name: Check Contracts Format
+        run: yarn format --check
+
+      - name: Make sure contracts can be built
+        run: yarn build

package/src/precompiles/ArbDebug.sol

@@ -12,6 +12,12 @@ interface ArbDebug {
     /// @notice Caller becomes a chain owner
     function becomeChainOwner() external;
 
+    /// @notice Overwrite an existing contract's code
+    function overwriteContractCode(
+        address target,
+        bytes calldata newCode
+    ) external returns (bytes memory oldCode);
+
     /// @notice Emit events with values based on the args provided
     function events(bool flag, bytes32 value) external payable returns (address, uint256);
 
@@ -31,6 +37,7 @@ interface ArbDebug {
         uint64 number
     ) external pure;
 
+    /// @notice Available in ArbOS version 30 and above
     function panic() external;
 
     function legacyError() external pure;

package/src/precompiles/ArbGasInfo.sol

@@ -49,9 +49,15 @@ interface ArbGasInfo {
     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)
+    /// @notice Starting from ArbOS version 50, `speedLimitPerSecond` corresponds to the target of the single-constraint pricing model.
+    /// @notice For multi-constraint pricing model, use `getGasPricingConstraints` to retrieve the constraint set.
+    /// @return (speedLimitPerSecond, gasPoolMax, maxBlockGasLimit)
     function getGasAccountingParams() external view returns (uint256, uint256, uint256);
 
+    /// @notice Get the maxTxGasLimit
+    /// @notice Available in ArbOS version 50 and above
+    function getMaxTxGasLimit() external view returns (uint256);
+
     /// @notice Get the minimum gas price needed for a tx to succeed
     function getMinimumGasPrice() external view returns (uint256);
 
@@ -62,11 +68,11 @@ interface ArbGasInfo {
     function getL1BaseFeeEstimateInertia() external view returns (uint64);
 
     /// @notice Get the L1 pricer reward rate, in wei per unit
-    /// Available in ArbOS version 11
+    /// @notice Available in ArbOS version 11 and above
     function getL1RewardRate() external view returns (uint64);
 
     /// @notice Get the L1 pricer reward recipient
-    /// Available in ArbOS version 11
+    /// @notice Available in ArbOS version 11 and above
     function getL1RewardRecipient() external view returns (address);
 
     /// @notice Deprecated -- Same as getL1BaseFeeEstimate()
@@ -76,12 +82,18 @@ interface ArbGasInfo {
     function getCurrentTxL1GasFees() external view returns (uint256);
 
     /// @notice Get the backlogged amount of gas burnt in excess of the speed limit
+    /// @notice Starting from ArbOS version 50, returns the backlog value from the single-constraint pricing model.
+    /// @notice For multi-constraint pricing model, use `getGasPricingConstraints` to get backlog values for each configured constraint.
     function getGasBacklog() external view returns (uint64);
 
     /// @notice Get how slowly ArbOS updates the L2 basefee in response to backlogged gas
+    /// @notice Starting from ArbOS version 50, returns the inertia value used by the single-constraint pricing model.
+    /// @notice For new integrations, prefer `getGasPricingConstraints`.
     function getPricingInertia() external view returns (uint64);
 
     /// @notice Get the forgivable amount of backlogged gas ArbOS will ignore when raising the basefee
+    /// @notice Starting from ArbOS version 50, returns the backlog tolerance value used by the single-constraint pricing model.
+    /// @notice There is no tolerance for backlogged gas in the new multi-constraint pricing model.
     function getGasBacklogTolerance() external view returns (uint64);
 
     /// @notice Returns the surplus of funds for L1 batch posting payments (may be negative).
@@ -94,25 +106,39 @@ interface ArbGasInfo {
     function getAmortizedCostCapBips() external view returns (uint64);
 
     /// @notice Returns the available funds from L1 fees
+    /// @notice Available in ArbOS version 10 and above
     function getL1FeesAvailable() external view returns (uint256);
 
     /// @notice Returns the equilibration units parameter for L1 price adjustment algorithm
-    /// Available in ArbOS version 20
+    /// @notice Available in ArbOS version 20 and above
     function getL1PricingEquilibrationUnits() external view returns (uint256);
 
     /// @notice Returns the last time the L1 calldata pricer was updated.
-    /// Available in ArbOS version 20
+    /// @notice Available in ArbOS version 20 and above
     function getLastL1PricingUpdateTime() external view returns (uint64);
 
     /// @notice Returns the amount of L1 calldata payments due for rewards (per the L1 reward rate)
-    /// Available in ArbOS version 20
+    /// @notice Available in ArbOS version 20 and above
     function getL1PricingFundsDueForRewards() external view returns (uint256);
 
     /// @notice Returns the amount of L1 calldata posted since the last update.
-    /// Available in ArbOS version 20
+    /// @notice Available in ArbOS version 20 and above
     function getL1PricingUnitsSinceUpdate() external view returns (uint64);
 
     /// @notice Returns the L1 pricing surplus as of the last update (may be negative).
-    /// Available in ArbOS version 20
+    /// @notice Available in ArbOS version 20 and above
     function getLastL1PricingSurplus() external view returns (int256);
+
+    /// @notice Get the maximum block gas limit
+    /// @notice Available in ArbOS version 50 and above
+    function getMaxBlockGasLimit() external view returns (uint64);
+
+    /// @notice Get the current gas pricing constraints used by the multi-constraint pricing model.
+    /// @notice Each constraint contains the following values:
+    ///         - gas_target_per_second: target gas usage per second for the constraint (uint64, gas/sec)
+    ///         - adjustment_window_seconds: time over which the price will rise by a factor of e if demand is 2x the target (uint64, seconds)
+    ///         - uint64 backlog: current backlog in gas units for this constraint (uint64, gas units)
+    /// @return constraints Array of triples (gas_target_per_second, adjustment_window_seconds, backlog)
+    /// @notice Available in ArbOS version 50 and above.
+    function getGasPricingConstraints() external view returns (uint64[3][] memory constraints);
 }

package/src/precompiles/ArbNativeTokenManager.sol

@@ -8,7 +8,7 @@ pragma solidity >=0.4.21 <0.9.0;
  * @title Enables minting and burning native tokens.
  * @notice Authorized callers are added/removed through ArbOwner precompile.
  *         Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000073.
- *         Available in ArbOS version 41
+ *         Available in ArbOS version 41 and above
  */
 interface ArbNativeTokenManager {
     /**

package/src/precompiles/ArbOwner.sol

@@ -34,31 +34,31 @@ interface ArbOwner {
     function getAllChainOwners() external view returns (address[] memory);
 
     /// @notice Sets the NativeTokenManagementFrom time
-    /// Available in ArbOS version 41
+    /// @notice Available in ArbOS version 41 and above
     function setNativeTokenManagementFrom(
         uint64 timestamp
     ) external;
 
     /// @notice Add account as a native token owner
-    /// Available in ArbOS version 41
+    /// @notice Available in ArbOS version 41 and above
     function addNativeTokenOwner(
         address newOwner
     ) external;
 
     /// @notice Remove account from the list of native token owners
-    /// Available in ArbOS version 41
+    /// @notice Available in ArbOS version 41 and above
     function removeNativeTokenOwner(
         address ownerToRemove
     ) external;
 
     /// @notice See if the user is a native token owner
-    /// Available in ArbOS version 41
+    /// @notice Available in ArbOS version 41 and above
     function isNativeTokenOwner(
         address addr
     ) external view returns (bool);
 
     /// @notice Retrieves the list of native token owners
-    /// Available in ArbOS version 41
+    /// @notice Available in ArbOS version 41 and above
     function getAllNativeTokenOwners() external view returns (address[] memory);
 
     /// @notice Set how slowly ArbOS updates its estimate of the L1 basefee
@@ -77,21 +77,33 @@ interface ArbOwner {
     ) external;
 
     /// @notice Set the computational speed limit for the chain
+    /// @notice Starting from ArbOS version 50, continues to set the legacy single-constraint speed limit value.
+    /// @notice It does not modify the multi-constraint pricing model configuration. To configure multiple constraints, use `setGasPricingConstraints`.
     function setSpeedLimit(
         uint64 limit
     ) external;
 
-    /// @notice Set the maximum size a tx (and block) can be
+    /// @notice Set the maximum size a tx can be
     function setMaxTxGasLimit(
         uint64 limit
     ) external;
 
+    /// @notice Set the maximum size a block can be
+    /// @notice Available in ArbOS version 50 and above
+    function setMaxBlockGasLimit(
+        uint64 limit
+    ) external;
+
     /// @notice Set the L2 gas pricing inertia
+    /// @notice Starting from ArbOS version 50, continues to set the single-constraint pricing inertia value.
+    /// @notice It does not modify the multi-constraint pricing model configuration. To configure multiple constraints, use `setGasPricingConstraints`.
     function setL2GasPricingInertia(
         uint64 sec
     ) external;
 
     /// @notice Set the L2 gas backlog tolerance
+    /// @notice Starting from ArbOS version 50, continues to set the single-constraint backlog tolerance value.
+    /// @notice It does not modify the multi-constraint pricing model configuration. There is no tolerance for backlogged gas in the new multi-constraint pricing model.
     function setL2GasBacklogTolerance(
         uint64 sec
     ) external;
@@ -100,6 +112,7 @@ interface ArbOwner {
     function getNetworkFeeAccount() external view returns (address);
 
     /// @notice Get the infrastructure fee collector
+    /// @notice Available in ArbOS version 5 and above
     function getInfraFeeAccount() external view returns (address);
 
     /// @notice Set the network fee collector
@@ -108,6 +121,7 @@ interface ArbOwner {
     ) external;
 
     /// @notice Set the infrastructure fee collector
+    /// @notice Available in ArbOS version 5 and above
     function setInfraFeeAccount(
         address newInfraFeeAccount
     ) external;
@@ -140,15 +154,19 @@ interface ArbOwner {
         uint256 pricePerUnit
     ) external;
 
+    /// @notice Set how much L1 charges per non-zero byte of calldata
+    /// @notice Available in ArbOS version 50 and above
+    function setParentGasFloorPerToken(
+        uint64 floorPerToken
+    ) external;
+
     /// @notice Sets the base charge (in L1 gas) attributed to each data batch in the calldata pricer
     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
-     */
+    /// @notice Sets the Brotli compression level used for fast compression
+    /// @notice Available in ArbOS version 20 and above
     function setBrotliCompressionLevel(
         uint64 level
     ) external;
@@ -159,90 +177,131 @@ interface ArbOwner {
     ) external;
 
     /// @notice Releases surplus funds from L1PricerFundsPoolAddress for use
+    /// @notice Available in ArbOS version 10 and above
     function releaseL1PricerSurplusFunds(
         uint256 maxWeiToRelease
     ) external returns (uint256);
 
     /// @notice Sets the amount of ink 1 gas buys
+    /// @notice Available in ArbOS version 30 and above
     /// @param price the conversion rate (must fit in a uint24)
     function setInkPrice(
         uint32 price
     ) external;
 
     /// @notice Sets the maximum depth (in wasm words) a wasm stack may grow
+    /// @notice Available in ArbOS version 30 and above
     function setWasmMaxStackDepth(
         uint32 depth
     ) external;
 
     /// @notice Sets the number of free wasm pages a tx gets
+    /// @notice Available in ArbOS version 30 and above
     function setWasmFreePages(
         uint16 pages
     ) external;
 
     /// @notice Sets the base cost of each additional wasm page
+    /// @notice Available in ArbOS version 30 and above
     function setWasmPageGas(
         uint16 gas
     ) external;
 
     /// @notice Sets the maximum number of pages a wasm may allocate
+    /// @notice Available in ArbOS version 30 and above
     function setWasmPageLimit(
         uint16 limit
     ) external;
 
     /// @notice Sets the maximum size of the uncompressed wasm code in bytes
+    /// @notice Available in ArbOS version 30 and above
     function setWasmMaxSize(
         uint32 size
     ) external;
 
     /// @notice Sets the minimum costs to invoke a program
+    /// @notice Available in ArbOS version 30 and above
     /// @param gas amount of gas paid in increments of 256 when not the program is not cached
     /// @param cached amount of gas paid in increments of 64 when the program is cached
     function setWasmMinInitGas(uint8 gas, uint16 cached) external;
 
     /// @notice Sets the linear adjustment made to program init costs.
+    /// @notice Available in ArbOS version 30 and above
     /// @param percent the adjustment (100% = no adjustment).
     function setWasmInitCostScalar(
         uint64 percent
     ) external;
 
     /// @notice Sets the number of days after which programs deactivate
+    /// @notice Available in ArbOS version 30 and above
     function setWasmExpiryDays(
         uint16 _days
     ) external;
 
     /// @notice Sets the age a program must be to perform a keepalive
+    /// @notice Available in ArbOS version 30 and above
     function setWasmKeepaliveDays(
         uint16 _days
     ) external;
 
     /// @notice Sets the number of extra programs ArbOS caches during a given block
+    /// @notice Available in ArbOS version 30 and above
     function setWasmBlockCacheSize(
         uint16 count
     ) external;
 
     /// @notice Adds account as a wasm cache manager
+    /// @notice Available in ArbOS version 30 and above
     function addWasmCacheManager(
         address manager
     ) external;
 
     /// @notice Removes account from the list of wasm cache managers
+    /// @notice Available in ArbOS version 30 and above
     function removeWasmCacheManager(
         address manager
     ) external;
 
     /// @notice Sets serialized chain config in ArbOS state
+    /// @notice Available in ArbOS version 11 and above
     function setChainConfig(
         string calldata chainConfig
     ) external;
 
-    /**
-     * @notice Sets the increased calldata price feature on or off (EIP-7623)
-     * Available in ArbOS version 40 with default as false
-     */
+    /// @notice Sets the increased calldata price feature on or off (EIP-7623)
+    /// @notice Available in ArbOS version 40 and above with default as false
     function setCalldataPriceIncrease(
         bool enable
     ) external;
 
+    /// @notice Set the backlogged amount of gas burnt used by the single-constraint pricing model only.
+    /// @notice To configure backlogs for the multi-constraint pricing model, use `setGasPricingConstraints()`.
+    /// @param backlog The backlog value in gas units to assign to the single-constraint pricing model.
+    function setGasBacklog(
+        uint64 backlog
+    ) external;
+
+    /// @notice Sets the list of gas pricing constraints for the multi-constraint pricing model.
+    /// @notice Replaces the existing constraints configuration and sets each constraint's starting backlog value.
+    /// @notice All existing backlogs are replaced by the provided values.
+    /// @notice Any changes to gas targets, inertia, or starting backlogs may cause immediate price fluctuations.
+    /// @notice Operators are fully responsible for the resulting behavior and should adjust parameters carefully.
+    /// @notice Use `ArbGasInfo.getGasPricingConstraints()` to retrieve the current configuration.
+    /// @notice Model selection:
+    /// @notice - If one or more constraints are provided, the chain switches to the multi-constraint pricing model
+    /// @notice   and uses exactly the provided parameters.
+    /// @notice - If zero constraints are provided, the chain uses the single-constraint pricing model.
+    /// @notice   In that case, the single-constraint backlog can be set via `setBacklog`, which you may derive from multi-constraint
+    /// @notice   parameters if desired.
+    /// @notice Available in ArbOS version 50 and above.
+    /// @param constraints Array of triples (gas_target_per_second, adjustment_window_seconds, starting_backlog_value)
+    ///        - gas_target_per_second: target gas usage per second for the constraint (uint64, gas/sec)
+    ///        - adjustment_window_seconds: time over which the price will rise by a factor of e if demand is 2x the target (uint64, seconds)
+    ///        - starting_backlog_value: initial backlog for this constraint (uint64, gas units)
+    function setGasPricingConstraints(
+        uint64[3][] calldata constraints
+    ) external;
+
     /// Emitted when a successful call is made to this precompile
     event OwnerActs(bytes4 indexed method, address indexed owner, bytes data);
 }