@arbitrum/nitro-contracts 1.1.1 → 1.2.0

package/src/challenge/ChallengeManager.sol

@@ -110,6 +110,12 @@ contract ChallengeManager is DelegateCallAware, IChallengeManager {
         osp = osp_;
     }
 
+    function postUpgradeInit(IOneStepProofEntry osp_) external onlyDelegated onlyProxyOwner {
+        // when updating to 4844 we need to create new osp contracts and set them here
+        // on the challenge manager
+        osp = osp_;
+    }
+
     function createChallenge(
         bytes32 wasmModuleRoot_,
         MachineStatus[2] calldata startAndEndMachineStatuses_,

package/src/libraries/Error.sol

@@ -176,5 +176,32 @@ error AlreadyValidDASKeyset(bytes32);
 /// @dev Tried to use or invalidate an already invalid Data Availability Service keyset
 error NoSuchKeyset(bytes32);
 
+/// @dev Thrown when the provided address is not the designated batch poster manager
+error NotBatchPosterManager(address);
+
+/// @dev Thrown when a data blob feature is attempted to be used on a chain that doesnt support it
+error DataBlobsNotSupported();
+
+/// @dev Thrown when an init param was supplied as empty
+error InitParamZero(string name);
+
+/// @dev Thrown when data hashes where expected but not where present on the tx
+error MissingDataHashes();
+
+/// @dev Thrown when the data blob meta data is invalid
+error InvalidBlobMetadata();
+
 /// @dev Thrown when rollup is not updated with updateRollupAddress
 error RollupNotChanged();
+
+/// @dev Batch data was empty when non empty was expected
+error EmptyBatchData();
+
+/// @dev Unsupported header flag was provided
+error InvalidHeaderFlag(bytes1);
+
+/// @dev SequencerInbox and Bridge are not in the same feeToken/ETH mode
+error NativeTokenMismatch();
+
+/// @dev Thrown when a deprecated function is called
+error Deprecated();

package/src/libraries/GasRefundEnabled.sol

@@ -0,0 +1,52 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+// solhint-disable-next-line compiler-version
+pragma solidity ^0.8.0;
+
+import "./IReader4844.sol";
+import "./IGasRefunder.sol";
+
+abstract contract GasRefundEnabled {
+    uint256 internal immutable gasPerBlob = 2**17;
+
+    /// @dev this refunds the sender for execution costs of the tx
+    /// calldata costs are only refunded if `msg.sender == tx.origin` to guarantee the value refunded relates to charging
+    /// for the `tx.input`. this avoids a possible attack where you generate large calldata from a contract and get over-refunded
+    modifier refundsGas(IGasRefunder gasRefunder, IReader4844 reader4844) {
+        uint256 startGasLeft = gasleft();
+        _;
+        if (address(gasRefunder) != address(0)) {
+            uint256 calldataSize = msg.data.length;
+            uint256 calldataWords = (calldataSize + 31) / 32;
+            // account for the CALLDATACOPY cost of the proxy contract, including the memory expansion cost
+            startGasLeft += calldataWords * 6 + (calldataWords**2) / 512;
+            // if triggered in a contract call, the spender may be overrefunded by appending dummy data to the call
+            // so we check if it is a top level call, which would mean the sender paid calldata as part of tx.input
+            // solhint-disable-next-line avoid-tx-origin
+            if (msg.sender != tx.origin) {
+                // We can't be sure if this calldata came from the top level tx,
+                // so to be safe we tell the gas refunder there was no calldata.
+                calldataSize = 0;
+            } else {
+                // for similar reasons to above we only refund blob gas when the tx.origin is the msg.sender
+                // this avoids the caller being able to send blobs to other contracts and still get refunded here
+                if (address(reader4844) != address(0)) {
+                    // add any cost for 4844 data, the data hash reader throws an error prior to 4844 being activated
+                    // we do this addition here rather in the GasRefunder so that we can check the msg.sender is the tx.origin
+                    try reader4844.getDataHashes() returns (bytes32[] memory dataHashes) {
+                        if (dataHashes.length != 0) {
+                            uint256 blobBasefee = reader4844.getBlobBaseFee();
+                            startGasLeft +=
+                                (dataHashes.length * gasPerBlob * blobBasefee) /
+                                block.basefee;
+                        }
+                    } catch {}
+                }
+            }
+
+            gasRefunder.onGasSpent(payable(msg.sender), startGasLeft - gasleft(), calldataSize);
+        }
+    }
+}

package/src/libraries/IGasRefunder.sol

@@ -12,28 +12,3 @@ interface IGasRefunder {
         uint256 calldataSize
     ) external returns (bool success);
 }
-
-abstract contract GasRefundEnabled {
-    /// @dev this refunds the sender for execution costs of the tx
-    /// calldata costs are only refunded if `msg.sender == tx.origin` to guarantee the value refunded relates to charging
-    /// for the `tx.input`. this avoids a possible attack where you generate large calldata from a contract and get over-refunded
-    modifier refundsGas(IGasRefunder gasRefunder) {
-        uint256 startGasLeft = gasleft();
-        _;
-        if (address(gasRefunder) != address(0)) {
-            uint256 calldataSize = msg.data.length;
-            uint256 calldataWords = (calldataSize + 31) / 32;
-            // account for the CALLDATACOPY cost of the proxy contract, including the memory expansion cost
-            startGasLeft += calldataWords * 6 + (calldataWords**2) / 512;
-            // if triggered in a contract call, the spender may be overrefunded by appending dummy data to the call
-            // so we check if it is a top level call, which would mean the sender paid calldata as part of tx.input
-            // solhint-disable-next-line avoid-tx-origin
-            if (msg.sender != tx.origin) {
-                // We can't be sure if this calldata came from the top level tx,
-                // so to be safe we tell the gas refunder there was no calldata.
-                calldataSize = 0;
-            }
-            gasRefunder.onGasSpent(payable(msg.sender), startGasLeft - gasleft(), calldataSize);
-        }
-    }
-}

package/src/libraries/IReader4844.sol

@@ -0,0 +1,13 @@
+// Copyright 2023-2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro-contracts/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.6.9 <0.9.0;
+
+interface IReader4844 {
+    /// @notice Returns the current BLOBBASEFEE
+    function getBlobBaseFee() external view returns (uint256);
+
+    /// @notice Returns all the data hashes of all the blobs on the current transaction
+    function getDataHashes() external view returns (bytes32[] memory);
+}

package/src/mocks/InboxStub.sol

@@ -163,7 +163,7 @@ contract InboxStub is IInboxBase, IInbox {
         address,
         uint256,
         bytes calldata
-    ) external returns (uint256) {
+    ) external pure returns (uint256) {
         revert("NOT_IMPLEMENTED");
     }
 
@@ -173,7 +173,7 @@ contract InboxStub is IInboxBase, IInbox {
         uint256,
         uint256,
         address
-    ) external returns (uint256) {
+    ) external pure returns (uint256) {
         revert("NOT_IMPLEMENTED");
     }
 

package/src/mocks/SequencerInboxStub.sol

@@ -13,11 +13,16 @@ contract SequencerInboxStub is SequencerInbox {
         IBridge bridge_,
         address sequencer_,
         ISequencerInbox.MaxTimeVariation memory maxTimeVariation_,
-        uint256 maxDataSize_
-    ) SequencerInbox(maxDataSize_) {
+        uint256 maxDataSize_,
+        IReader4844 reader4844_,
+        bool isUsingFeeToken_
+    ) SequencerInbox(maxDataSize_, reader4844_, isUsingFeeToken_) {
         bridge = bridge_;
         rollup = IOwnable(msg.sender);
-        maxTimeVariation = maxTimeVariation_;
+        delayBlocks = maxTimeVariation_.delayBlocks;
+        futureBlocks = maxTimeVariation_.futureBlocks;
+        delaySeconds = maxTimeVariation_.delaySeconds;
+        futureSeconds = maxTimeVariation_.futureSeconds;
         isBatchPoster[sequencer_] = true;
     }
 
@@ -30,7 +35,7 @@ contract SequencerInboxStub is SequencerInbox {
         );
         require(num == 0, "ALREADY_DELAYED_INIT");
         emit InboxMessageDelivered(num, initMsg);
-        (bytes32 dataHash, TimeBounds memory timeBounds) = formEmptyDataHash(1);
+        (bytes32 dataHash, IBridge.TimeBounds memory timeBounds) = formEmptyDataHash(1);
         (
             uint256 sequencerMessageCount,
             bytes32 beforeAcc,
@@ -45,11 +50,11 @@ contract SequencerInboxStub is SequencerInbox {
             delayedAcc,
             totalDelayedMessagesRead,
             timeBounds,
-            BatchDataLocation.NoData
+            IBridge.BatchDataLocation.NoData
         );
     }
 
-    function getTimeBounds() internal view override returns (TimeBounds memory bounds) {
+    function getTimeBounds() internal view override returns (IBridge.TimeBounds memory bounds) {
         this; // silence warning about function not being view
         return bounds;
     }

package/src/mocks/Simple.sol

@@ -4,11 +4,13 @@
 
 pragma solidity ^0.8.0;
 
+import "../bridge/ISequencerInbox.sol";
 import "../precompiles/ArbRetryableTx.sol";
 import "../precompiles/ArbSys.sol";
 
 contract Simple {
     uint64 public counter;
+    uint256 public difficulty;
 
     event CounterEvent(uint64 count);
     event RedeemedEvent(address caller, address redeemer);
@@ -30,6 +32,7 @@ contract Simple {
     }
 
     function incrementRedeem() external {
+        // solhint-disable-next-line avoid-tx-origin
         require(msg.sender == tx.origin, "SENDER_NOT_ORIGIN");
         require(ArbSys(address(0x64)).wasMyCallersAddressAliased(), "NOT_ALIASED");
         counter++;
@@ -45,8 +48,12 @@ contract Simple {
         return block.number;
     }
 
+    function storeDifficulty() external {
+        difficulty = block.difficulty;
+    }
+
     function getBlockDifficulty() external view returns (uint256) {
-        return block.difficulty;
+        return difficulty;
     }
 
     function noop() external pure {}
@@ -93,6 +100,7 @@ contract Simple {
             useTopLevel,
             delegateCase
         );
+        // solhint-disable-next-line avoid-low-level-calls
         (bool success, ) = address(this).delegatecall(data);
         require(success, "DELEGATE_CALL_FAILED");
 
@@ -113,6 +121,7 @@ contract Simple {
             useTopLevel,
             callCase
         );
+        // solhint-disable-next-line avoid-low-level-calls
         (success, ) = address(this).call(data);
         require(success, "CALL_FAILED");
     }
@@ -121,8 +130,29 @@ contract Simple {
         uint256 before = gasleft();
         // The inner call may revert, but we still want to return the amount of gas used,
         // so we ignore the result of this call.
+        // solhint-disable-next-line avoid-low-level-calls
         // solc-ignore-next-line unused-call-retval
         to.staticcall{gas: before - 10000}(input);
         return before - gasleft();
     }
+
+    function postManyBatches(
+        ISequencerInbox sequencerInbox,
+        bytes memory batchData,
+        uint256 numberToPost
+    ) external {
+        uint256 sequenceNumber = sequencerInbox.batchCount();
+        uint256 delayedMessagesRead = sequencerInbox.totalDelayedMessagesRead();
+        for (uint256 i = 0; i < numberToPost; i++) {
+            sequencerInbox.addSequencerL2Batch(
+                sequenceNumber,
+                batchData,
+                delayedMessagesRead,
+                IGasRefunder(address(0)),
+                0,
+                0
+            );
+            sequenceNumber++;
+        }
+    }
 }

package/src/osp/OneStepProverHostIo.sol

@@ -101,16 +101,35 @@ contract OneStepProverHostIo is IOneStepProver {
         state.u64Vals[idx] = val;
     }
 
+    uint256 internal constant BLS_MODULUS =
+        52435875175126190479447740508185965837690552500527637822603658699938581184513;
+    uint256 internal constant PRIMITIVE_ROOT_OF_UNITY =
+        10238227357739495823651030575849232062558860180284477541189508159991286009131;
+
+    // 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) {
+        bytes memory modExpInput = abi.encode(32, 32, 32, b, e, m);
+        (bool modexpSuccess, bytes memory modExpOutput) = address(0x05).staticcall(modExpInput);
+        require(modexpSuccess, "MODEXP_FAILED");
+        require(modExpOutput.length == 32, "MODEXP_WRONG_LENGTH");
+        return uint256(bytes32(modExpOutput));
+    }
+
     function executeReadPreImage(
         ExecutionContext calldata,
         Machine memory mach,
         Module memory mod,
-        Instruction calldata,
+        Instruction calldata inst,
         bytes calldata proof
-    ) internal pure {
+    ) internal view {
         uint256 preimageOffset = mach.valueStack.pop().assumeI32();
         uint256 ptr = mach.valueStack.pop().assumeI32();
-        if (ptr + 32 > mod.moduleMemory.size || ptr % LEAF_SIZE != 0) {
+        if (preimageOffset % 32 != 0 || ptr + 32 > mod.moduleMemory.size || ptr % LEAF_SIZE != 0) {
             mach.status = MachineStatus.ERRORED;
             return;
         }
@@ -128,18 +147,92 @@ contract OneStepProverHostIo is IOneStepProver {
         bytes memory extracted;
         uint8 proofType = uint8(proof[proofOffset]);
         proofOffset++;
-        if (proofType == 0) {
+        // These values must be kept in sync with `arbitrator/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
+
+            if (proofType == 0) {
+                bytes calldata preimage = proof[proofOffset:];
+                require(keccak256(preimage) == leafContents, "BAD_PREIMAGE");
+
+                uint256 preimageEnd = preimageOffset + 32;
+                if (preimageEnd > preimage.length) {
+                    preimageEnd = preimage.length;
+                }
+                extracted = preimage[preimageOffset:preimageEnd];
+            } else {
+                // TODO: support proving via an authenticated contract
+                revert("UNKNOWN_PREIMAGE_PROOF");
+            }
+        } else if (inst.argumentData == 1) {
+            // The machine is asking for a sha2-256 preimage
+
+            require(proofType == 0, "UNKNOWN_PREIMAGE_PROOF");
             bytes calldata preimage = proof[proofOffset:];
-            require(keccak256(preimage) == leafContents, "BAD_PREIMAGE");
+            require(sha256(preimage) == leafContents, "BAD_PREIMAGE");
 
             uint256 preimageEnd = preimageOffset + 32;
             if (preimageEnd > preimage.length) {
                 preimageEnd = preimage.length;
             }
             extracted = preimage[preimageOffset:preimageEnd];
+        } else if (inst.argumentData == 2) {
+            // The machine is asking for an Ethereum versioned hash preimage
+
+            require(proofType == 0, "UNKNOWN_PREIMAGE_PROOF");
+
+            // kzgProof should be a valid input to the EIP-4844 point evaluation precompile at address 0x0A.
+            // It should prove the preimageOffset/32'th word of the machine's requested KZG commitment.
+            bytes calldata kzgProof = proof[proofOffset:];
+
+            require(bytes32(kzgProof[:32]) == leafContents, "KZG_PROOF_WRONG_HASH");
+
+            uint256 fieldElementsPerBlob;
+            uint256 blsModulus;
+            {
+                (bool success, bytes memory kzgParams) = address(0x0A).staticcall(kzgProof);
+                require(success, "INVALID_KZG_PROOF");
+                require(kzgParams.length > 0, "KZG_PRECOMPILE_MISSING");
+                (fieldElementsPerBlob, blsModulus) = abi.decode(kzgParams, (uint256, uint256));
+            }
+
+            // With a hardcoded PRIMITIVE_ROOT_OF_UNITY, we can only support this BLS modulus.
+            // It may be worth in the future supporting arbitrary BLS moduli, but we would likely need to
+            // validate a user-supplied root of unity.
+            require(blsModulus == BLS_MODULUS, "UNKNOWN_BLS_MODULUS");
+
+            // If preimageOffset is greater than or equal to the blob size, leave extracted empty and call it here.
+            if (preimageOffset < fieldElementsPerBlob * 32) {
+                // We need to compute what point the polynomial should be evaluated at to get the right part of the preimage.
+                // KZG commitments use a bit reversal permutation to order the roots of unity.
+                // To account for that, we reverse the bit order of the index.
+                uint256 bitReversedIndex = 0;
+                // preimageOffset was required to be 32 byte aligned above
+                uint256 tmp = preimageOffset / 32;
+                for (uint256 i = 1; i < fieldElementsPerBlob; i <<= 1) {
+                    bitReversedIndex <<= 1;
+                    if (tmp & 1 == 1) {
+                        bitReversedIndex |= 1;
+                    }
+                    tmp >>= 1;
+                }
+
+                // First, we get the root of unity of order 2**fieldElementsPerBlob.
+                // We start with a root of unity of order 2**32 and then raise it to
+                // the power of (2**32)/fieldElementsPerBlob to get root of unity we need.
+                uint256 rootOfUnityPower = (1 << 32) / fieldElementsPerBlob;
+                // Then, we raise the root of unity to the power of bitReversedIndex,
+                // to retrieve this word of the KZG commitment.
+                rootOfUnityPower *= bitReversedIndex;
+                // z is the point the polynomial is evaluated at to retrieve this word of data
+                uint256 z = modExp256(PRIMITIVE_ROOT_OF_UNITY, rootOfUnityPower, blsModulus);
+                require(bytes32(kzgProof[32:64]) == bytes32(z), "KZG_PROOF_WRONG_Z");
+
+                extracted = kzgProof[64:96];
+            }
         } else {
-            // TODO: support proving via an authenticated contract
-            revert("UNKNOWN_PREIMAGE_PROOF");
+            revert("UNKNOWN_PREIMAGE_TYPE");
         }
 
         for (uint256 i = 0; i < extracted.length; i++) {

package/src/precompiles/ArbGasInfo.sol

@@ -129,4 +129,24 @@ interface ArbGasInfo {
 
     /// @notice Returns the available funds from L1 fees
     function getL1FeesAvailable() external view returns (uint256);
+
+    /// @notice Returns the equilibration units parameter for L1 price adjustment algorithm
+    /// Available in ArbOS version 20
+    function getL1PricingEquilibrationUnits() external view returns (uint256);
+
+    /// @notice Returns the last time the L1 calldata pricer was updated.
+    /// Available in ArbOS version 20
+    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
+    function getL1PricingFundsDueForRewards() external view returns (uint256);
+
+    /// @notice Returns the amount of L1 calldata posted since the last update.
+    /// Available in ArbOS version 20
+    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
+    function getLastL1PricingSurplus() external view returns (int256);
 }

package/src/precompiles/ArbOwnerPublic.sol

@@ -29,5 +29,13 @@ interface ArbOwnerPublic {
     /// @notice Get the Brotli compression level used for fast compression
     function getBrotliCompressionLevel() external view returns (uint64);
 
+    /// @notice Get the next scheduled ArbOS version upgrade and its activation timestamp.
+    /// Returns (0, 0) if no ArbOS upgrade is scheduled.
+    /// Available in ArbOS version 20.
+    function getScheduledUpgrade()
+        external
+        view
+        returns (uint64 arbosVersion, uint64 scheduledForTimestamp);
+
     event ChainOwnerRectified(address rectifiedOwner);
 }

package/src/rollup/BridgeCreator.sol

@@ -96,7 +96,7 @@ contract BridgeCreator is Ownable {
         } else {
             IERC20Bridge(address(frame.bridge)).initialize(IOwnable(rollup), nativeToken);
         }
-        frame.sequencerInbox.initialize(frame.bridge, maxTimeVariation);
+        frame.sequencerInbox.initialize(IBridge(frame.bridge), maxTimeVariation);
         frame.inbox.initialize(frame.bridge, frame.sequencerInbox);
         frame.rollupEventInbox.initialize(frame.bridge);
         frame.outbox.initialize(frame.bridge);

package/src/rollup/RollupCreator.sol

@@ -35,12 +35,14 @@ contract RollupCreator is Ownable {
 
     struct RollupDeploymentParams {
         Config config;
-        address batchPoster;
         address[] validators;
         uint256 maxDataSize;
         address nativeToken;
         bool deployFactoriesToL2;
         uint256 maxFeePerGasForRetryables;
+        //// @dev The address of the batch poster, not used when set to zero address
+        address[] batchPosters;
+        address batchPosterManager;
     }
 
     BridgeCreator public bridgeCreator;
@@ -102,6 +104,7 @@ contract RollupCreator is Ownable {
      *                          anyone can try to deploy factories and potentially burn the nonce 0 (ie. due to gas price spike when doing direct
      *                          L2 TX). That would mean we permanently lost capability to deploy deterministic factory at expected address.
      *          - maxFeePerGasForRetryables price bid for L2 execution.
+     *          - dataHashReader The address of the data hash reader used to read blob hashes
      * @return The address of the newly created rollup
      */
     function createRollup(RollupDeploymentParams memory deployParams)
@@ -109,22 +112,27 @@ contract RollupCreator is Ownable {
         payable
         returns (address)
     {
-        // Make sure the immutable maxDataSize is as expected
-        (, ISequencerInbox ethSequencerInbox, IInboxBase ethInbox, , ) = bridgeCreator
-            .ethBasedTemplates();
-        require(
-            deployParams.maxDataSize == ethSequencerInbox.maxDataSize(),
-            "SI_MAX_DATA_SIZE_MISMATCH"
-        );
-        require(deployParams.maxDataSize == ethInbox.maxDataSize(), "I_MAX_DATA_SIZE_MISMATCH");
+        {
+            // Make sure the immutable maxDataSize is as expected
+            (, ISequencerInbox ethSequencerInbox, IInboxBase ethInbox, , ) = bridgeCreator
+                .ethBasedTemplates();
+            require(
+                deployParams.maxDataSize == ethSequencerInbox.maxDataSize(),
+                "SI_MAX_DATA_SIZE_MISMATCH"
+            );
+            require(deployParams.maxDataSize == ethInbox.maxDataSize(), "I_MAX_DATA_SIZE_MISMATCH");
 
-        (, ISequencerInbox erc20SequencerInbox, IInboxBase erc20Inbox, , ) = bridgeCreator
-            .erc20BasedTemplates();
-        require(
-            deployParams.maxDataSize == erc20SequencerInbox.maxDataSize(),
-            "SI_MAX_DATA_SIZE_MISMATCH"
-        );
-        require(deployParams.maxDataSize == erc20Inbox.maxDataSize(), "I_MAX_DATA_SIZE_MISMATCH");
+            (, ISequencerInbox erc20SequencerInbox, IInboxBase erc20Inbox, , ) = bridgeCreator
+                .erc20BasedTemplates();
+            require(
+                deployParams.maxDataSize == erc20SequencerInbox.maxDataSize(),
+                "SI_MAX_DATA_SIZE_MISMATCH"
+            );
+            require(
+                deployParams.maxDataSize == erc20Inbox.maxDataSize(),
+                "I_MAX_DATA_SIZE_MISMATCH"
+            );
+        }
 
         // create proxy admin which will manage bridge contracts
         ProxyAdmin proxyAdmin = new ProxyAdmin();
@@ -180,9 +188,12 @@ contract RollupCreator is Ownable {
             })
         );
 
-        // setting batch poster, if the address provided is not zero address
-        if (deployParams.batchPoster != address(0)) {
-            bridgeContracts.sequencerInbox.setIsBatchPoster(deployParams.batchPoster, true);
+        // Setting batch posters and batch poster manager
+        for (uint256 i = 0; i < deployParams.batchPosters.length; i++) {
+            bridgeContracts.sequencerInbox.setIsBatchPoster(deployParams.batchPosters[i], true);
+        }
+        if (deployParams.batchPosterManager != address(0)) {
+            bridgeContracts.sequencerInbox.setBatchPosterManager(deployParams.batchPosterManager);
         }
 
         // Call setValidator on the newly created rollup contract just if validator set is not empty
@@ -257,6 +268,7 @@ contract RollupCreator is Ownable {
             l2FactoriesDeployer.perform{value: cost}(_inbox, _nativeToken, _maxFeePerGas);
 
             // refund the caller
+            // solhint-disable-next-line avoid-low-level-calls
             (bool sent, ) = msg.sender.call{value: address(this).balance}("");
             require(sent, "Refund failed");
         } else {

package/src/rollup/ValidatorWallet.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.0;
 import "../challenge/IChallengeManager.sol";
 import "../libraries/DelegateCallAware.sol";
 import "../libraries/IGasRefunder.sol";
+import "../libraries/GasRefundEnabled.sol";
 import "@openzeppelin/contracts/utils/Address.sol";
 import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
@@ -109,7 +110,7 @@ contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware, GasRefundEnab
         bytes[] calldata data,
         address[] calldata destination,
         uint256[] calldata amount
-    ) public payable onlyExecutorOrOwner refundsGas(gasRefunder) {
+    ) public payable onlyExecutorOrOwner refundsGas(gasRefunder, IReader4844(address(0))) {
         uint256 numTxes = data.length;
         if (numTxes != destination.length) revert BadArrayLength(numTxes, destination.length);
         if (numTxes != amount.length) revert BadArrayLength(numTxes, amount.length);
@@ -144,7 +145,7 @@ contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware, GasRefundEnab
         bytes calldata data,
         address destination,
         uint256 amount
-    ) public payable onlyExecutorOrOwner refundsGas(gasRefunder) {
+    ) public payable onlyExecutorOrOwner refundsGas(gasRefunder, IReader4844(address(0))) {
         if (data.length > 0) require(destination.isContract(), "NO_CODE_AT_ADDR");
         validateExecuteTransaction(destination);
         // We use a low level call here to allow for contract and non-contract calls
@@ -168,7 +169,7 @@ contract ValidatorWallet is OwnableUpgradeable, DelegateCallAware, GasRefundEnab
         IGasRefunder gasRefunder,
         IChallengeManager manager,
         uint64[] calldata challenges
-    ) public onlyExecutorOrOwner refundsGas(gasRefunder) {
+    ) public onlyExecutorOrOwner refundsGas(gasRefunder, IReader4844(address(0))) {
         uint256 challengesCount = challenges.length;
         for (uint256 i = 0; i < challengesCount; i++) {
             try manager.timeout(challenges[i]) {} catch (bytes memory error) {

package/src/test-helpers/RollupMock.sol

@@ -8,6 +8,12 @@ contract RollupMock {
     event WithdrawTriggered();
     event ZombieTriggered();
 
+    address public owner;
+
+    constructor(address _owner) {
+        owner = _owner;
+    }
+
     function withdrawStakerFunds() external returns (uint256) {
         emit WithdrawTriggered();
         return 0;

package/build/contracts/src/libraries/IGasRefunder.sol/GasRefundEnabled.dbg.json

@@ -1,4 +0,0 @@
-{
-  "_format": "hh-sol-dbg-1",
-  "buildInfo": "../../../build-info/bd6d911e8af19014a6d3612fec6f93ac.json"
-}