@arbitrum/nitro-contracts 2.0.0 → 3.0.0-alpha.0

package/src/mocks/MockRollupEventInbox.sol

@@ -0,0 +1,59 @@
+// 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
+
+pragma solidity ^0.8.0;
+
+import "../rollup/IRollupEventInbox.sol";
+import "../bridge/IEthBridge.sol";
+import "../bridge/IDelayedMessageProvider.sol";
+import "../precompiles/ArbGasInfo.sol";
+import "../libraries/DelegateCallAware.sol";
+import "../libraries/ArbitrumChecker.sol";
+import {INITIALIZATION_MSG_TYPE} from "../libraries/MessageTypes.sol";
+import {AlreadyInit, HadZeroInit} from "../libraries/Error.sol";
+
+/**
+ * @title The inbox for rollup protocol events
+ */
+contract MockRollupEventInbox is IRollupEventInbox, IDelayedMessageProvider, DelegateCallAware {
+    IBridge public override bridge;
+    address public override rollup;
+
+    modifier onlyRollup() {
+        require(msg.sender == rollup, "ONLY_ROLLUP");
+        _;
+    }
+
+    function initialize(
+        IBridge _bridge
+    ) external override onlyDelegated {
+        if (address(bridge) != address(0)) revert AlreadyInit();
+        if (address(_bridge) == address(0)) revert HadZeroInit();
+        bridge = _bridge;
+        rollup = address(_bridge.rollup());
+    }
+
+    /// @notice Allows the proxy owner to set the rollup address
+    function updateRollupAddress() external onlyDelegated onlyProxyOwner {
+        rollup = address(bridge.rollup());
+    }
+
+    function rollupInitialized(
+        uint256 chainId,
+        string calldata chainConfig
+    ) external override onlyRollup {
+        require(bytes(chainConfig).length > 0, "EMPTY_CHAIN_CONFIG");
+        uint8 initMsgVersion = 1;
+        uint256 currentDataCost = 1; // Set to a base fee of 1.
+        if (ArbitrumChecker.runningOnArbitrum()) {
+            currentDataCost += ArbGasInfo(address(0x6c)).getL1BaseFeeEstimate();
+        }
+        bytes memory initMsg =
+            abi.encodePacked(chainId, initMsgVersion, currentDataCost, chainConfig);
+        uint256 num = IEthBridge(address(bridge)).enqueueDelayedMessage(
+            INITIALIZATION_MSG_TYPE, address(0), keccak256(initMsg)
+        );
+        emit InboxMessageDelivered(num, initMsg);
+    }
+}

package/src/mocks/MultiCallTest.sol

@@ -26,7 +26,9 @@ contract MultiCallTest {
     // solhint-disable reason-string
     // solhint-disable avoid-low-level-calls
     // solhint-disable-next-line prettier/prettier
-    fallback(bytes calldata input) external payable returns (bytes memory) {
+    fallback(
+        bytes calldata input
+    ) external payable returns (bytes memory) {
         require(input.length > 0);
         uint8 count = uint8(input[0]);
         input = input[1:];

package/src/mocks/PendingBlkTimeAndNrAdvanceCheck.sol

@@ -21,7 +21,9 @@ contract PendingBlkTimeAndNrAdvanceCheck {
         require(ARB_SYS.arbBlockNumber() > deployedAtBlock, "Block didn't advance");
     }
 
-    function checkArbBlockHashReturnsLatest(bytes32 expected) external {
+    function checkArbBlockHashReturnsLatest(
+        bytes32 expected
+    ) external {
         bytes32 gotBlockHash = ARB_SYS.arbBlockHash(ARB_SYS.arbBlockNumber() - 1);
         require(gotBlockHash != bytes32(0), "ZERO_BLOCK_HASH");
         require(gotBlockHash == expected, "WRONG_BLOCK_HASH");

package/src/mocks/Program.sol

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: BUSL-1.1
 
 pragma solidity ^0.8.0;
+
 import "../precompiles/ArbSys.sol";
 import "@openzeppelin/contracts/utils/Strings.sol";
 
@@ -20,11 +21,10 @@ contract ProgramTest {
         require(hash == keccak256(data[1:]));
     }
 
-    function staticcallProgram(address program, bytes calldata data)
-        external
-        view
-        returns (bytes memory)
-    {
+    function staticcallProgram(
+        address program,
+        bytes calldata data
+    ) external view returns (bytes memory) {
         (bool success, bytes memory result) = address(program).staticcall(data);
         require(success, "call failed");
         return result;
@@ -101,7 +101,9 @@ contract ProgramTest {
         return result;
     }
 
-    function mathTest(address program) external {
+    function mathTest(
+        address program
+    ) external {
         uint256 value = 0xeddecf107b5740cef7f5a01e3ea7e287665c4e75a8eb6afae2fda2e3d4367786;
         value = mulmod(
             value,
@@ -115,7 +117,7 @@ contract ProgramTest {
         );
         unchecked {
             value /= 0xeddecf107b5740ce;
-            value = value**0xfffffffefffffc2f;
+            value = value ** 0xfffffffefffffc2f;
             value = value % 0xc6178c2de1078cd3;
         }
 

package/src/mocks/SequencerInboxBlobMock.sol

@@ -0,0 +1,38 @@
+// 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
+
+pragma solidity ^0.8.0;
+
+import "../bridge/SequencerInbox.sol";
+
+contract SequencerInboxBlobMock is SequencerInbox {
+    constructor(
+        uint256 maxDataSize_,
+        IReader4844 reader_,
+        bool isUsingFeeToken_,
+        bool isDelayBufferable_
+    ) SequencerInbox(maxDataSize_, reader_, isUsingFeeToken_, isDelayBufferable_) {}
+
+    /// @dev    Form a hash of the data being provided in 4844 data blobs
+    /// @param  afterDelayedMessagesRead The delayed messages count read up to
+    /// @return The data hash
+    /// @return The timebounds within which the message should be processed
+    /// @return The normalized amount of gas used for blob posting
+    function formBlobDataHash(
+        uint256 afterDelayedMessagesRead
+    ) internal view override returns (bytes32, IBridge.TimeBounds memory, uint256) {
+        bytes32[3] memory dataHashes = [bytes32(0), bytes32(0), bytes32(0)];
+        if (dataHashes.length == 0) revert MissingDataHashes();
+
+        (bytes memory header, IBridge.TimeBounds memory timeBounds) =
+            packHeader(afterDelayedMessagesRead);
+        uint256 BLOB_BASE_FEE = 1 gwei;
+        uint256 blobCost = BLOB_BASE_FEE * GAS_PER_BLOB * dataHashes.length;
+        return (
+            keccak256(bytes.concat(header, DATA_BLOB_HEADER_FLAG, abi.encodePacked(dataHashes))),
+            timeBounds,
+            block.basefee > 0 ? blobCost / block.basefee : 0
+        );
+    }
+}

package/src/mocks/SequencerInboxStub.sol

@@ -15,8 +15,9 @@ contract SequencerInboxStub is SequencerInbox {
         ISequencerInbox.MaxTimeVariation memory maxTimeVariation_,
         uint256 maxDataSize_,
         IReader4844 reader4844_,
-        bool isUsingFeeToken_
-    ) SequencerInbox(maxDataSize_, reader4844_, isUsingFeeToken_) {
+        bool isUsingFeeToken_,
+        bool isDelayBufferable_
+    ) SequencerInbox(maxDataSize_, reader4844_, isUsingFeeToken_, isDelayBufferable_) {
         bridge = bridge_;
         rollup = IOwnable(msg.sender);
         delayBlocks = uint64(maxTimeVariation_.delayBlocks);
@@ -26,22 +27,18 @@ contract SequencerInboxStub is SequencerInbox {
         isBatchPoster[sequencer_] = true;
     }
 
-    function addInitMessage(uint256 chainId) external {
+    function addInitMessage(
+        uint256 chainId
+    ) external {
         bytes memory initMsg = abi.encodePacked(chainId);
         uint256 num = IEthBridge(address(bridge)).enqueueDelayedMessage(
-            INITIALIZATION_MSG_TYPE,
-            address(0),
-            keccak256(initMsg)
+            INITIALIZATION_MSG_TYPE, address(0), keccak256(initMsg)
         );
         require(num == 0, "ALREADY_DELAYED_INIT");
         emit InboxMessageDelivered(num, initMsg);
         (bytes32 dataHash, IBridge.TimeBounds memory timeBounds) = formEmptyDataHash(1);
-        (
-            uint256 sequencerMessageCount,
-            bytes32 beforeAcc,
-            bytes32 delayedAcc,
-            bytes32 afterAcc
-        ) = addSequencerL2BatchImpl(dataHash, 1, 0, 0, 1);
+        (uint256 sequencerMessageCount, bytes32 beforeAcc, bytes32 delayedAcc, bytes32 afterAcc) =
+            addSequencerL2BatchImpl(dataHash, 1, 0, 0, 1);
         require(sequencerMessageCount == 0, "ALREADY_SEQ_INIT");
         emit SequencerBatchDelivered(
             sequencerMessageCount,

package/src/mocks/Simple.sol

@@ -21,7 +21,9 @@ contract Simple {
         counter++;
     }
 
-    function logAndIncrement(uint256 expected) external {
+    function logAndIncrement(
+        uint256 expected
+    ) external {
         emit LogAndIncrementCalled(expected, counter);
         counter++;
     }
@@ -67,8 +69,7 @@ contract Simple {
             require(ArbSys(address(100)).isTopLevelCall() == expected, "UNEXPECTED_RESULT");
         } else {
             require(
-                ArbSys(address(100)).wasMyCallersAddressAliased() == expected,
-                "UNEXPECTED_RESULT"
+                ArbSys(address(100)).wasMyCallersAddressAliased() == expected, "UNEXPECTED_RESULT"
             );
         }
     }
@@ -86,8 +87,7 @@ contract Simple {
             require(ArbSys(address(100)).isTopLevelCall() == directCase, "UNEXPECTED_RESULT");
         } else {
             require(
-                ArbSys(address(100)).wasMyCallersAddressAliased() == directCase,
-                "UNEXPECTED_RESULT"
+                ArbSys(address(100)).wasMyCallersAddressAliased() == directCase, "UNEXPECTED_RESULT"
             );
         }
 
@@ -96,19 +96,15 @@ contract Simple {
 
         // DELEGATE CALL
         bytes memory data = abi.encodeWithSelector(
-            this.checkIsTopLevelOrWasAliased.selector,
-            useTopLevel,
-            delegateCase
+            this.checkIsTopLevelOrWasAliased.selector, useTopLevel, delegateCase
         );
         // solhint-disable-next-line avoid-low-level-calls
-        (bool success, ) = address(this).delegatecall(data);
+        (bool success,) = address(this).delegatecall(data);
         require(success, "DELEGATE_CALL_FAILED");
 
         // CALLCODE
         data = abi.encodeWithSelector(
-            this.checkIsTopLevelOrWasAliased.selector,
-            useTopLevel,
-            callcodeCase
+            this.checkIsTopLevelOrWasAliased.selector, useTopLevel, callcodeCase
         );
         assembly {
             success := callcode(gas(), address(), 0, add(data, 32), mload(data), 0, 0)
@@ -116,13 +112,10 @@ contract Simple {
         require(success, "CALLCODE_FAILED");
 
         // CALL
-        data = abi.encodeWithSelector(
-            this.checkIsTopLevelOrWasAliased.selector,
-            useTopLevel,
-            callCase
-        );
+        data =
+            abi.encodeWithSelector(this.checkIsTopLevelOrWasAliased.selector, useTopLevel, callCase);
         // solhint-disable-next-line avoid-low-level-calls
-        (success, ) = address(this).call(data);
+        (success,) = address(this).call(data);
         require(success, "CALL_FAILED");
     }
 
@@ -132,7 +125,7 @@ contract Simple {
         // 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);
+        to.staticcall{gas: before - 10000}(input);// forgefmt: disable-line
         return before - gasleft();
     }
 
@@ -145,12 +138,7 @@ contract Simple {
         uint256 delayedMessagesRead = sequencerInbox.totalDelayedMessagesRead();
         for (uint256 i = 0; i < numberToPost; i++) {
             sequencerInbox.addSequencerL2Batch(
-                sequenceNumber,
-                batchData,
-                delayedMessagesRead,
-                IGasRefunder(address(0)),
-                0,
-                0
+                sequenceNumber, batchData, delayedMessagesRead, IGasRefunder(address(0)), 0, 0
             );
             sequenceNumber++;
         }

package/src/mocks/SimpleCacheManager.sol

@@ -3,18 +3,25 @@
 // SPDX-License-Identifier: BUSL-1.1
 
 pragma solidity ^0.8.0;
+
 import "../precompiles/ArbWasmCache.sol";
 
 contract SimpleCacheManager {
-    function cacheProgram(address program) external {
+    function cacheProgram(
+        address program
+    ) external {
         ArbWasmCache(address(0x72)).cacheProgram(program);
     }
 
-    function evictProgram(address program) external {
+    function evictProgram(
+        address program
+    ) external {
         ArbWasmCache(address(0x72)).evictCodehash(codehash(program));
     }
 
-    function codehash(address program) internal view returns (bytes32 hash) {
+    function codehash(
+        address program
+    ) internal view returns (bytes32 hash) {
         assembly {
             hash := extcodehash(program)
         }

package/src/mocks/SimpleOneStepProofEntry.sol

@@ -0,0 +1,60 @@
+// Copyright 2023, Offchain Labs, Inc.
+// For license information, see https://github.com/offchainlabs/bold/blob/main/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+//
+pragma solidity ^0.8.17;
+
+import "../challengeV2/EdgeChallengeManager.sol";
+import "../state/Deserialize.sol";
+
+contract SimpleOneStepProofEntry is IOneStepProofEntry {
+    using GlobalStateLib for GlobalState;
+
+    // End the batch after 2000 steps. This results in 11 blocks for an honest validator.
+    // This constant must be synchronized with the one in execution/engine.go
+    uint64 public constant STEPS_PER_BATCH = 2000;
+
+    function getStartMachineHash(
+        bytes32 globalStateHash,
+        bytes32 wasmModuleRoot
+    ) external pure returns (bytes32) {
+        return keccak256(abi.encodePacked("Machine:", globalStateHash, wasmModuleRoot));
+    }
+
+    function proveOneStep(
+        ExecutionContext calldata execCtx,
+        uint256 step,
+        bytes32 beforeHash,
+        bytes calldata proof
+    ) external view returns (bytes32 afterHash) {
+        if (proof.length == 0) {
+            revert("EMPTY_PROOF");
+        }
+        GlobalState memory globalState;
+        uint256 offset;
+        (globalState.u64Vals[0], offset) = Deserialize.u64(proof, offset);
+        (globalState.u64Vals[1], offset) = Deserialize.u64(proof, offset);
+        if (step > 0 && (beforeHash[0] == 0 || globalState.getPositionInMessage() == 0)) {
+            // We end the block when the first byte of the hash hits 0 or we advance a batch
+            return beforeHash;
+        }
+        if (globalState.getInboxPosition() >= execCtx.maxInboxMessagesRead) {
+            // We can't continue further because we've hit the max inbox messages read
+            return beforeHash;
+        }
+        require(globalState.hash() == beforeHash, "BAD_PROOF");
+        globalState.u64Vals[1]++;
+        if (globalState.u64Vals[1] % STEPS_PER_BATCH == 0) {
+            globalState.u64Vals[0]++;
+            globalState.u64Vals[1] = 0;
+        }
+        return globalState.hash();
+    }
+
+    function getMachineHash(
+        ExecutionState calldata execState
+    ) external pure override returns (bytes32) {
+        require(execState.machineStatus == MachineStatus.FINISHED, "BAD_MACHINE_STATUS");
+        return execState.globalState.hash();
+    }
+}

package/src/mocks/SimpleProxy.sol

@@ -9,7 +9,9 @@ import "@openzeppelin/contracts/proxy/Proxy.sol";
 contract SimpleProxy is Proxy {
     address private immutable impl;
 
-    constructor(address impl_) {
+    constructor(
+        address impl_
+    ) {
         impl = impl_;
     }
 

package/src/mocks/TestWETH9.sol

@@ -0,0 +1,30 @@
+// 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
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+interface IWETH9 {
+    function deposit() external payable;
+
+    function withdraw(
+        uint256 _amount
+    ) external;
+}
+
+contract TestWETH9 is ERC20, IWETH9 {
+    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) {}
+
+    function deposit() external payable override {
+        _mint(msg.sender, msg.value);
+    }
+
+    function withdraw(
+        uint256 _amount
+    ) external override {
+        _burn(msg.sender, _amount);
+        payable(address(msg.sender)).transfer(_amount);
+    }
+}

package/src/mocks/UpgradeExecutorMock.sol

@@ -47,16 +47,13 @@ contract UpgradeExecutorMock is
     /// @dev    Only executor can call this. Since we're using a delegatecall here the Upgrade contract
     ///         will have access to the state of this contract - including the roles. Only upgrade contracts
     ///         that do not touch local state should be used.
-    function execute(address upgrade, bytes memory upgradeCallData)
-        public
-        payable
-        onlyRole(EXECUTOR_ROLE)
-        nonReentrant
-    {
+    function execute(
+        address upgrade,
+        bytes memory upgradeCallData
+    ) public payable onlyRole(EXECUTOR_ROLE) nonReentrant {
         // OZ Address library check if the address is a contract and bubble up inner revert reason
         address(upgrade).functionDelegateCall(
-            upgradeCallData,
-            "UpgradeExecutor: inner delegate call failed without reason"
+            upgradeCallData, "UpgradeExecutor: inner delegate call failed without reason"
         );
 
         emit UpgradeExecuted(upgrade, msg.value, upgradeCallData);
@@ -64,17 +61,13 @@ contract UpgradeExecutorMock is
 
     /// @notice Execute an upgrade by directly calling target contract
     /// @dev    Only executor can call this.
-    function executeCall(address target, bytes memory targetCallData)
-        public
-        payable
-        onlyRole(EXECUTOR_ROLE)
-        nonReentrant
-    {
+    function executeCall(
+        address target,
+        bytes memory targetCallData
+    ) public payable onlyRole(EXECUTOR_ROLE) nonReentrant {
         // OZ Address library check if the address is a contract and bubble up inner revert reason
         address(target).functionCallWithValue(
-            targetCallData,
-            msg.value,
-            "UpgradeExecutor: inner call failed without reason"
+            targetCallData, msg.value, "UpgradeExecutor: inner call failed without reason"
         );
 
         emit TargetCallExecuted(target, msg.value, targetCallData);

package/src/node-interface/NodeInterface.sol

@@ -4,7 +4,8 @@
 
 pragma solidity >=0.4.21 <0.9.0;
 
-/** @title Interface for providing gas estimation for retryable auto-redeems and constructing outbox proofs
+/**
+ * @title Interface for providing gas estimation for retryable auto-redeems and constructing outbox proofs
  *  @notice This contract doesn't exist on-chain. Instead it is a virtual interface accessible at
  *  0x00000000000000000000000000000000000000C8
  *  This is a cute trick to allow an Arbitrum node to provide data without us having to implement additional RPCs
@@ -41,14 +42,10 @@ interface NodeInterface {
      * @return root the root of the outbox accumulator
      * @return proof level-by-level branch hashes constituting a proof of the send's membership at the given size
      */
-    function constructOutboxProof(uint64 size, uint64 leaf)
-        external
-        view
-        returns (
-            bytes32 send,
-            bytes32 root,
-            bytes32[] memory proof
-        );
+    function constructOutboxProof(
+        uint64 size,
+        uint64 leaf
+    ) external view returns (bytes32 send, bytes32 root, bytes32[] memory proof);
 
     /**
      * @notice Finds the L1 batch containing a requested L2 block, reverting if none does.
@@ -57,7 +54,9 @@ interface NodeInterface {
      * @param blockNum The L2 block being queried
      * @return batch The sequencer batch number containing the requested L2 block
      */
-    function findBatchContainingBlock(uint64 blockNum) external view returns (uint64 batch);
+    function findBatchContainingBlock(
+        uint64 blockNum
+    ) external view returns (uint64 batch);
 
     /**
      * @notice Gets the number of L1 confirmations of the sequencer batch producing the requested L2 block
@@ -68,7 +67,9 @@ interface NodeInterface {
      * @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);
+    function getL1Confirmations(
+        bytes32 blockHash
+    ) external view returns (uint64 confirmations);
 
     /**
      * @notice Same as native gas estimation, but with additional info on the l1 costs.
@@ -116,11 +117,7 @@ interface NodeInterface {
     )
         external
         payable
-        returns (
-            uint64 gasEstimateForL1,
-            uint256 baseFee,
-            uint256 l1BaseFeeEstimate
-        );
+        returns (uint64 gasEstimateForL1, uint256 baseFee, uint256 l1BaseFeeEstimate);
 
     /**
      * @notice Returns the proof necessary to redeem a message
@@ -136,7 +133,10 @@ interface NodeInterface {
      * @return amount value in L1 message in wei
      * @return calldataForL1 abi-encoded L1 message data
      */
-    function legacyLookupMessageBatchProof(uint256 batchNum, uint64 index)
+    function legacyLookupMessageBatchProof(
+        uint256 batchNum,
+        uint64 index
+    )
         external
         view
         returns (
@@ -158,7 +158,9 @@ interface NodeInterface {
 
     // @notice Returns the L1 block number of the L2 block
     // @return l1BlockNum The L1 block number
-    function blockL1Num(uint64 l2BlockNum) external view returns (uint64 l1BlockNum);
+    function blockL1Num(
+        uint64 l2BlockNum
+    ) external view returns (uint64 l1BlockNum);
 
     /**
      * @notice Finds the L2 block number range that has the given L1 block number
@@ -167,8 +169,7 @@ interface NodeInterface {
      * @return firstBlock The first L2 block number with the given L1 block number
      * @return lastBlock The last L2 block number with the given L1 block number
      */
-    function l2BlockRangeForL1(uint64 blockNum)
-        external
-        view
-        returns (uint64 firstBlock, uint64 lastBlock);
+    function l2BlockRangeForL1(
+        uint64 blockNum
+    ) external view returns (uint64 firstBlock, uint64 lastBlock);
 }

package/src/node-interface/NodeInterfaceDebug.sol

@@ -4,12 +4,12 @@
 
 pragma solidity >=0.4.21 <0.9.0;
 
-/** @title An extension to NodeInterface not meant for public consumption. Do not call.
+/**
+ * @title An extension to NodeInterface not meant for public consumption. Do not call.
  *  @notice This contract doesn't exist on-chain. Instead it is a virtual interface accessible at 0xc9.
  *  These methods add additional debugging and network monitoring instruments not intended for end users and
  *  as such may change without notice.
  */
-
 interface NodeInterfaceDebug {
     struct RetryableInfo {
         uint64 timeout;
@@ -26,5 +26,7 @@ interface NodeInterfaceDebug {
      * @param ticket the retryable's id
      * @return retryable the serialized retryable
      */
-    function getRetryable(bytes32 ticket) external view returns (RetryableInfo memory retryable);
+    function getRetryable(
+        bytes32 ticket
+    ) external view returns (RetryableInfo memory retryable);
 }

package/src/osp/HashProofHelper.sol

@@ -30,10 +30,10 @@ contract HashProofHelper {
     uint256 private constant MAX_PART_LENGTH = 32;
     uint256 private constant KECCAK_ROUND_INPUT = 136;
 
-    function proveWithFullPreimage(bytes calldata data, uint64 offset)
-        external
-        returns (bytes32 fullHash)
-    {
+    function proveWithFullPreimage(
+        bytes calldata data,
+        uint64 offset
+    ) external returns (bytes32 fullHash) {
         fullHash = keccak256(data);
         bytes memory part;
         if (data.length > offset) {
@@ -96,11 +96,7 @@ contract HashProofHelper {
         delete keccakStates[msg.sender];
     }
 
-    function keccakUpdate(
-        KeccakState storage state,
-        bytes calldata data,
-        bool isFinal
-    ) internal {
+    function keccakUpdate(KeccakState storage state, bytes calldata data, bool isFinal) internal {
         state.length += data.length;
         while (true) {
             if (data.length == 0 && !isFinal) {
@@ -144,7 +140,10 @@ contract HashProofHelper {
     }
 
     /// Retrieves up to 32 bytes of the preimage of fullHash at the given offset, reverting if it hasn't been proven yet.
-    function getPreimagePart(bytes32 fullHash, uint64 offset) external view returns (bytes memory) {
+    function getPreimagePart(
+        bytes32 fullHash,
+        uint64 offset
+    ) external view returns (bytes memory) {
         PreimagePart storage part = preimageParts[fullHash][offset];
         if (!part.proven) {
             revert NotProven(fullHash, offset);