@arbitrum/nitro-contracts 2.1.1-beta.0 → 3.0.0-alpha.1

package/src/mocks/CreateTest.sol

@@ -12,7 +12,9 @@ contract CreateTest {
     // solhint-disable reason-string
     // solhint-disable avoid-low-level-calls
     // solhint-disable-next-line prettier/prettier
-    fallback(bytes calldata input) external returns (bytes memory) {
+    fallback(
+        bytes calldata input
+    ) external returns (bytes memory) {
         uint8 kind = uint8(input[0]);
         input = input[1:];
 

package/src/mocks/HostioTest.sol

@@ -14,7 +14,9 @@ contract HostioTest {
         }
     }
 
-    function transientLoadBytes32(bytes32 key) external view returns (bytes32) {
+    function transientLoadBytes32(
+        bytes32 key
+    ) external view returns (bytes32) {
         bytes32 data;
         assembly {
             data := tload(key)
@@ -71,11 +73,15 @@ contract HostioTest {
         }
     }
 
-    function accountBalance(address account) external view returns (uint256) {
+    function accountBalance(
+        address account
+    ) external view returns (uint256) {
         return account.balance;
     }
 
-    function accountCode(address account) external view returns (bytes memory) {
+    function accountCode(
+        address account
+    ) external view returns (bytes memory) {
         uint256 size = 10000;
         bytes memory code = new bytes(size);
         assembly {
@@ -86,7 +92,9 @@ contract HostioTest {
         return code;
     }
 
-    function accountCodeSize(address account) external view returns (uint256) {
+    function accountCodeSize(
+        address account
+    ) external view returns (uint256) {
         uint256 size;
         assembly {
             size := extcodesize(account)
@@ -94,7 +102,9 @@ contract HostioTest {
         return size;
     }
 
-    function accountCodehash(address account) external view returns (bytes32) {
+    function accountCodehash(
+        address account
+    ) external view returns (bytes32) {
         bytes32 hash;
         assembly {
             hash := extcodehash(account)
@@ -154,19 +164,11 @@ contract HostioTest {
         return result;
     }
 
-    function mathAddMod(
-        uint256 a,
-        uint256 b,
-        uint256 c
-    ) external pure returns (uint256) {
+    function mathAddMod(uint256 a, uint256 b, uint256 c) external pure returns (uint256) {
         return addmod(a, b, c);
     }
 
-    function mathMulMod(
-        uint256 a,
-        uint256 b,
-        uint256 c
-    ) external pure returns (uint256) {
+    function mathMulMod(uint256 a, uint256 b, uint256 c) external pure returns (uint256) {
         return mulmod(a, b, c);
     }
 
@@ -178,7 +180,9 @@ contract HostioTest {
         return msg.value;
     }
 
-    function keccak(bytes calldata preimage) external pure returns (bytes32) {
+    function keccak(
+        bytes calldata preimage
+    ) external pure returns (bytes32) {
         return keccak256(preimage);
     }
 

package/src/mocks/InboxStub.sol

@@ -48,7 +48,9 @@ contract InboxStub is IInboxBase, IInbox {
      * @dev This method is an optimization to avoid having to emit the entirety of the messageData in a log. Instead validators are expected to be able to parse the data from the transaction's input
      * @param messageData Data of the message being sent
      */
-    function sendL2MessageFromOrigin(bytes calldata messageData) external returns (uint256) {
+    function sendL2MessageFromOrigin(
+        bytes calldata messageData
+    ) external returns (uint256) {
         // solhint-disable-next-line avoid-tx-origin
         require(msg.sender == tx.origin, "origin only");
         uint256 msgNum = deliverToBridge(L2_MSG, msg.sender, keccak256(messageData));
@@ -61,7 +63,9 @@ contract InboxStub is IInboxBase, IInbox {
      * @dev This method can be used to send any type of message that doesn't require L1 validation
      * @param messageData Data of the message being sent
      */
-    function sendL2Message(bytes calldata messageData) external override returns (uint256) {
+    function sendL2Message(
+        bytes calldata messageData
+    ) external override returns (uint256) {
         uint256 msgNum = deliverToBridge(L2_MSG, msg.sender, keccak256(messageData));
         emit InboxMessageDelivered(msgNum, messageData);
         return msgNum;
@@ -72,12 +76,9 @@ contract InboxStub is IInboxBase, IInbox {
         address sender,
         bytes32 messageDataHash
     ) internal returns (uint256) {
-        return
-            IEthBridge(address(bridge)).enqueueDelayedMessage{value: msg.value}(
-                kind,
-                sender,
-                messageDataHash
-            );
+        return IEthBridge(address(bridge)).enqueueDelayedMessage{value: msg.value}(
+            kind, sender, messageDataHash
+        );
     }
 
     function sendUnsignedTransaction(
@@ -181,14 +182,14 @@ contract InboxStub is IInboxBase, IInbox {
         revert("NOT_IMPLEMENTED");
     }
 
-    function postUpgradeInit(IBridge _bridge) external {}
+    function postUpgradeInit(
+        IBridge _bridge
+    ) external {}
 
-    function calculateRetryableSubmissionFee(uint256, uint256)
-        external
-        pure
-        override
-        returns (uint256)
-    {
+    function calculateRetryableSubmissionFee(
+        uint256,
+        uint256
+    ) external pure override returns (uint256) {
         revert("NOT_IMPLEMENTED");
     }
 
@@ -196,11 +197,15 @@ contract InboxStub is IInboxBase, IInbox {
         revert("NOT_IMPLEMENTED");
     }
 
-    function setAllowListEnabled(bool) external pure {
+    function setAllowListEnabled(
+        bool
+    ) external pure {
         revert("NOT_IMPLEMENTED");
     }
 
-    function isAllowed(address) external pure returns (bool) {
+    function isAllowed(
+        address
+    ) external pure returns (bool) {
         revert("NOT_IMPLEMENTED");
     }
 

package/src/mocks/MerkleTreeAccess.sol

@@ -0,0 +1,72 @@
+// 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/libraries/MerkleTreeAccumulatorLib.sol";
+import "../challengeV2/libraries/UintUtilsLib.sol";
+
+contract MerkleTreeAccess {
+    function mostSignificantBit(
+        uint256 x
+    ) external pure returns (uint256) {
+        return UintUtilsLib.mostSignificantBit(x);
+    }
+
+    function leastSignificantBit(
+        uint256 x
+    ) external pure returns (uint256) {
+        return UintUtilsLib.leastSignificantBit(x);
+    }
+
+    function root(
+        bytes32[] memory me
+    ) external pure returns (bytes32) {
+        return MerkleTreeAccumulatorLib.root(me);
+    }
+
+    function appendCompleteSubTree(
+        bytes32[] memory me,
+        uint256 level,
+        bytes32 subtreeRoot
+    ) external pure returns (bytes32[] memory) {
+        return MerkleTreeAccumulatorLib.appendCompleteSubTree(me, level, subtreeRoot);
+    }
+
+    function appendLeaf(
+        bytes32[] memory me,
+        bytes32 leaf
+    ) external pure returns (bytes32[] memory) {
+        return MerkleTreeAccumulatorLib.appendLeaf(me, leaf);
+    }
+
+    function maximumAppendBetween(
+        uint256 startSize,
+        uint256 endSize
+    ) external pure returns (uint256) {
+        return MerkleTreeAccumulatorLib.maximumAppendBetween(startSize, endSize);
+    }
+
+    function verifyPrefixProof(
+        bytes32 preRoot,
+        uint256 preSize,
+        bytes32 postRoot,
+        uint256 postSize,
+        bytes32[] memory preExpansion,
+        bytes32[] memory proof
+    ) external pure {
+        return MerkleTreeAccumulatorLib.verifyPrefixProof(
+            preRoot, preSize, postRoot, postSize, preExpansion, proof
+        );
+    }
+
+    function verifyInclusionProof(
+        bytes32 rootHash,
+        bytes32 leaf,
+        uint256 index,
+        bytes32[] memory proof
+    ) external pure {
+        MerkleTreeAccumulatorLib.verifyInclusionProof(rootHash, leaf, index, proof);
+    }
+}

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);
+    }
+}