@arbitrum/nitro-contracts 3.1.0 → 3.1.1

package/src/mocks/HostioTest.sol

@@ -1,200 +0,0 @@
-// Copyright 2024, Offchain Labs, Inc.
-// For license information, see https://github.com/nitro/blob/master/LICENSE
-// SPDX-License-Identifier: BUSL-1.1
-
-pragma solidity ^0.8.24;
-
-/*
- * HostioTest is a test contract used to compare EVM with Stylus.
- */
-contract HostioTest {
-    function exitEarly() external pure {
-        assembly {
-            stop()
-        }
-    }
-
-    function transientLoadBytes32(
-        bytes32 key
-    ) external view returns (bytes32) {
-        bytes32 data;
-        assembly {
-            data := tload(key)
-        }
-        return data;
-    }
-
-    function transientStoreBytes32(bytes32 key, bytes32 value) external {
-        assembly {
-            // solc-ignore-next-line transient-storage
-            tstore(key, value)
-        }
-    }
-
-    function returnDataSize() external pure returns (uint256) {
-        uint256 size;
-        assembly {
-            size := returndatasize()
-        }
-        return size;
-    }
-
-    function emitLog(
-        bytes calldata _data,
-        int8 n,
-        bytes32 t1,
-        bytes32 t2,
-        bytes32 t3,
-        bytes32 t4
-    ) external {
-        bytes memory data = _data;
-        if (n == 0) {
-            assembly {
-                log0(add(data, 32), mload(data))
-            }
-        } else if (n == 1) {
-            assembly {
-                log1(add(data, 32), mload(data), t1)
-            }
-        } else if (n == 2) {
-            assembly {
-                log2(add(data, 32), mload(data), t1, t2)
-            }
-        } else if (n == 3) {
-            assembly {
-                log3(add(data, 32), mload(data), t1, t2, t3)
-            }
-        } else if (n == 4) {
-            assembly {
-                log4(add(data, 32), mload(data), t1, t2, t3, t4)
-            }
-        } else {
-            revert("invalid n for emit log");
-        }
-    }
-
-    function accountBalance(
-        address account
-    ) external view returns (uint256) {
-        return account.balance;
-    }
-
-    function accountCode(
-        address account
-    ) external view returns (bytes memory) {
-        uint256 size = 10000;
-        bytes memory code = new bytes(size);
-        assembly {
-            extcodecopy(account, add(code, 32), 0, size)
-            size := extcodesize(account)
-            mstore(code, size)
-        }
-        return code;
-    }
-
-    function accountCodeSize(
-        address account
-    ) external view returns (uint256) {
-        uint256 size;
-        assembly {
-            size := extcodesize(account)
-        }
-        return size;
-    }
-
-    function accountCodehash(
-        address account
-    ) external view returns (bytes32) {
-        bytes32 hash;
-        assembly {
-            hash := extcodehash(account)
-        }
-        return hash;
-    }
-
-    function evmGasLeft() external view returns (uint256) {
-        return gasleft();
-    }
-
-    function evmInkLeft() external view returns (uint256) {
-        return gasleft();
-    }
-
-    function blockBasefee() external view returns (uint256) {
-        return block.basefee;
-    }
-
-    function chainid() external view returns (uint256) {
-        return block.chainid;
-    }
-
-    function blockCoinbase() external view returns (address) {
-        return block.coinbase;
-    }
-
-    function blockGasLimit() external view returns (uint256) {
-        return block.gaslimit;
-    }
-
-    function blockNumber() external view returns (uint256) {
-        return block.number;
-    }
-
-    function blockTimestamp() external view returns (uint256) {
-        return block.timestamp;
-    }
-
-    function contractAddress() external view returns (address) {
-        return address(this);
-    }
-
-    function mathDiv(uint256 a, uint256 b) external pure returns (uint256) {
-        return a / b;
-    }
-
-    function mathMod(uint256 a, uint256 b) external pure returns (uint256) {
-        return a % b;
-    }
-
-    function mathPow(uint256 a, uint256 b) external pure returns (uint256) {
-        uint256 result;
-        assembly {
-            result := exp(a, b)
-        }
-        return result;
-    }
-
-    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) {
-        return mulmod(a, b, c);
-    }
-
-    function msgSender() external view returns (address) {
-        return msg.sender;
-    }
-
-    function msgValue() external payable returns (uint256) {
-        return msg.value;
-    }
-
-    function keccak(
-        bytes calldata preimage
-    ) external pure returns (bytes32) {
-        return keccak256(preimage);
-    }
-
-    function txGasPrice() external view returns (uint256) {
-        return tx.gasprice;
-    }
-
-    function txInkPrice() external view returns (uint256) {
-        return tx.gasprice;
-    }
-
-    function txOrigin() external view returns (address) {
-        return tx.origin;
-    }
-}

package/src/mocks/MultiCallTest.sol

@@ -1,119 +0,0 @@
-// Copyright 2024, Offchain Labs, Inc.
-// For license information, see https://github.com/nitro/blob/master/LICENSE
-// SPDX-License-Identifier: BUSL-1.1
-
-pragma solidity ^0.8.0;
-
-/*
- * this contract is the solidity equivalent of stylus multicall test contract
- * it should only be used for stylus tests, and it ignores good solidity good practices
- */
-
-contract MultiCallTest {
-    event Called(address addr, uint8 count, bool success, bytes returnData);
-    event Storage(bytes32 slot, bytes32 data, bool write);
-
-    function getBE(bytes calldata data, uint8 numBytes) internal pure returns (uint256) {
-        uint256 res = 0;
-        for (uint8 i = 0; i < numBytes; i++) {
-            res = res << 8;
-            res = res | uint8(data[i]);
-        }
-        return res;
-    }
-
-    // solhint-disable no-complex-fallback
-    // 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) {
-        require(input.length > 0);
-        uint8 count = uint8(input[0]);
-        input = input[1:];
-
-        // combined output of all calls
-        bytes memory output;
-
-        for (uint8 i = 0; i < count; i++) {
-            uint32 length = uint32(getBE(input, 4));
-            input = input[4:];
-
-            bytes calldata curr = input[:length];
-            input = input[length:];
-
-            uint8 kind = uint8(curr[0]);
-            curr = curr[1:];
-
-            if (kind & 0xf0 == 0x0) {
-                // call
-                uint256 value;
-                if (kind & 0x3 == 0) {
-                    value = getBE(curr, 32);
-                    curr = curr[32:];
-                }
-
-                address addr = address(bytes20(curr[:20]));
-                bytes calldata data = curr[20:];
-                bytes memory out;
-                bool success;
-
-                if (kind & 0x3 == 0) {
-                    (success, out) = addr.call{value: value}(data);
-                } else if (kind & 0x3 == 1) {
-                    (success, out) = addr.delegatecall(data);
-                } else if (kind & 0x3 == 2) {
-                    (success, out) = addr.staticcall(data);
-                } else {
-                    revert("unknown call kind");
-                }
-                if (!success) {
-                    if (kind & 0x4 == 0) {
-                        uint256 len = out.length;
-                        if (len > 0) {
-                            assembly {
-                                revert(add(out, 32), len)
-                            }
-                        } else {
-                            revert();
-                        }
-                    }
-                    out = "";
-                }
-                if (kind & 0x8 != 0) {
-                    emit Called(addr, count, success, out);
-                }
-                output = bytes.concat(output, out);
-            } else if (kind & 0xf0 == 0x10) {
-                // storage
-                bytes32 slot = bytes32(curr[:32]);
-                curr = curr[32:];
-                bytes32 data;
-                bool write;
-                if (kind & 0x3 == 0) {
-                    data = bytes32(curr[:32]);
-                    write = true;
-                    assembly {
-                        sstore(slot, data)
-                    }
-                } else if (kind & 0x3 == 1) {
-                    write = false;
-                    assembly {
-                        data := sload(slot)
-                    }
-                    output = bytes.concat(output, data);
-                } else {
-                    revert("unknown storage kind");
-                }
-                if (kind & 0x8 != 0) {
-                    emit Storage(slot, data, write);
-                }
-            } else {
-                revert("unknown command");
-            }
-        }
-
-        return output;
-    }
-}

package/src/mocks/PendingBlkTimeAndNrAdvanceCheck.sol

@@ -1,31 +0,0 @@
-// 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 "../precompiles/ArbSys.sol";
-
-contract PendingBlkTimeAndNrAdvanceCheck {
-    uint256 immutable deployedAt;
-    uint256 immutable deployedAtBlock;
-    ArbSys constant ARB_SYS = ArbSys(address(100));
-
-    constructor() {
-        deployedAt = block.timestamp;
-        deployedAtBlock = ARB_SYS.arbBlockNumber();
-    }
-
-    function isAdvancing() external {
-        require(block.timestamp > deployedAt, "Time didn't advance");
-        require(ARB_SYS.arbBlockNumber() > deployedAtBlock, "Block didn't advance");
-    }
-
-    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

@@ -1,128 +0,0 @@
-// Copyright 2022-2023, Offchain Labs, Inc.
-// For license information, see https://github.com/nitro/blob/master/LICENSE
-// SPDX-License-Identifier: BUSL-1.1
-
-pragma solidity ^0.8.0;
-
-import "../precompiles/ArbSys.sol";
-import "@openzeppelin/contracts/utils/Strings.sol";
-
-contract ProgramTest {
-    event Hash(bytes32 result);
-
-    function callKeccak(address program, bytes calldata data) external {
-        // in keccak.rs
-        //     the input is the # of hashings followed by a preimage
-        //     the output is the iterated hash of the preimage
-        (bool success, bytes memory result) = address(program).call(data);
-        require(success, "call failed");
-        bytes32 hash = bytes32(result);
-        emit Hash(hash);
-        require(hash == keccak256(data[1:]));
-    }
-
-    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;
-    }
-
-    function assert256(
-        bytes memory data,
-        string memory text,
-        uint256 expected
-    ) internal pure returns (bytes memory) {
-        uint256 value = abi.decode(data, (uint256));
-        require(value == expected, text);
-
-        bytes memory rest = new bytes(data.length - 32);
-        for (uint256 i = 32; i < data.length; i++) {
-            rest[i - 32] = data[i];
-        }
-        return rest;
-    }
-
-    function staticcallEvmData(
-        address program,
-        address fundedAccount,
-        uint64 gas,
-        bytes calldata data
-    ) external view returns (bytes memory) {
-        (bool success, bytes memory result) = address(program).staticcall{gas: gas}(data);
-        require(success, "call failed");
-
-        address arbPrecompile = address(0x69);
-        address ethPrecompile = address(0x01);
-
-        result = assert256(result, "block number ", block.number - 1);
-        result = assert256(result, "chain id     ", block.chainid);
-        result = assert256(result, "base fee     ", block.basefee);
-        result = assert256(result, "gas price    ", tx.gasprice);
-        result = assert256(result, "gas limit    ", block.gaslimit);
-        result = assert256(result, "value        ", 0);
-        result = assert256(result, "timestamp    ", block.timestamp);
-        result = assert256(result, "balance      ", fundedAccount.balance);
-        result = assert256(result, "rust address ", uint256(uint160(program)));
-        result = assert256(result, "sender       ", uint256(uint160(address(this))));
-        result = assert256(result, "origin       ", uint256(uint160(tx.origin)));
-        result = assert256(result, "coinbase     ", uint256(uint160(address(block.coinbase))));
-        result = assert256(result, "rust codehash", uint256(program.codehash));
-        result = assert256(result, "arb codehash ", uint256(arbPrecompile.codehash));
-        result = assert256(result, "eth codehash ", uint256(ethPrecompile.codehash));
-
-        bytes memory code = new bytes(program.code.length);
-        for (uint256 i = 0; i < program.code.length; i++) {
-            code[i] = result[i];
-        }
-        require(keccak256(code) == keccak256(program.code), "code");
-        bytes memory rest = new bytes(result.length - program.code.length);
-        for (uint256 i = program.code.length; i < result.length; i++) {
-            rest[i - program.code.length] = result[i];
-        }
-
-        result = rest;
-        return result;
-    }
-
-    function checkRevertData(
-        address program,
-        bytes calldata data,
-        bytes calldata expected
-    ) external payable returns (bytes memory) {
-        (bool success, bytes memory result) = address(program).call{value: msg.value}(data);
-        require(!success, "unexpected success");
-        require(result.length == expected.length, "wrong revert data length");
-        for (uint256 i = 0; i < result.length; i++) {
-            require(result[i] == expected[i], "revert data mismatch");
-        }
-        return result;
-    }
-
-    function mathTest(
-        address program
-    ) external {
-        uint256 value = 0xeddecf107b5740cef7f5a01e3ea7e287665c4e75a8eb6afae2fda2e3d4367786;
-        value = mulmod(
-            value,
-            0xc6178c2de1078cd36c3bd302cde755340d7f17fcb3fcc0b9c333ba03b217029f,
-            0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
-        );
-        value = addmod(
-            value,
-            0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f,
-            0xc6178c2de1078cd36c3bd302cde755340d7f17fcb3fcc0b9c333ba03b217029f
-        );
-        unchecked {
-            value /= 0xeddecf107b5740ce;
-            value = value ** 0xfffffffefffffc2f;
-            value = value % 0xc6178c2de1078cd3;
-        }
-
-        (bool success, bytes memory result) = address(program).call("");
-        require(success, "call failed");
-        require(keccak256(result) == keccak256(abi.encodePacked(value)));
-    }
-}

package/src/mocks/ProxyAdminForBinding.sol

@@ -1,9 +0,0 @@
-// 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/proxy/transparent/ProxyAdmin.sol";
-
-contract ProxyAdminForBinding is ProxyAdmin {}

package/src/mocks/SdkStorage.sol

@@ -1,176 +0,0 @@
-// Copyright 2022-2023, Offchain Labs, Inc.
-// For license information, see https://github.com/nitro/blob/master/LICENSE
-// SPDX-License-Identifier: BUSL-1.1
-
-pragma solidity ^0.8.0;
-
-contract SdkStorage {
-    bool flag;
-    address owner;
-    address other;
-    Struct sub;
-    Struct[] structs;
-    uint64[] vector;
-    uint40[][] nested;
-    bytes bytesFull;
-    bytes bytesLong;
-    string chars;
-    Maps maps;
-    Arrays arrays;
-
-    struct Struct {
-        uint16 num;
-        int32 other;
-        bytes32 word;
-    }
-
-    struct Maps {
-        mapping(uint256 => address) basic;
-        mapping(address => bool[]) vects;
-        mapping(int32 => address)[] array;
-        mapping(bytes1 => mapping(bool => uint256)) nested;
-        mapping(string => Struct) structs;
-    }
-
-    struct Arrays {
-        string[4] strings;
-        uint8 spacer;
-        uint24[5] packed;
-        uint8 trail;
-        address[2] spill;
-        uint8[2][4] matrix;
-        int96[4][] vector;
-        int96[][4] vectors;
-        Struct[3] structs;
-    }
-
-    function populate() external {
-        flag = true;
-        owner = address(0x70);
-        other = address(0x30);
-
-        sub.num = 32;
-        sub.other = type(int32).max;
-        sub.word = bytes32(uint256(64));
-
-        for (uint64 i = 0; i < 32; i++) {
-            vector.push(i);
-        }
-        vector[7] = 77;
-
-        for (uint256 w = 0; w < 10; w++) {
-            nested.push(new uint40[](w));
-            for (uint256 i = 0; i < w; i++) {
-                nested[w][i] = uint40(i);
-            }
-        }
-        for (uint256 w = 0; w < 10; w++) {
-            for (uint256 i = 0; i < w; i++) {
-                nested[w][i] *= 2;
-            }
-        }
-
-        for (uint8 i = 0; i < 31; i++) {
-            bytesFull = abi.encodePacked(bytesFull, i);
-        }
-        for (uint8 i = 0; i < 80; i++) {
-            bytesLong = abi.encodePacked(bytesLong, i);
-        }
-        chars = "arbitrum stylus";
-
-        for (uint256 i = 0; i < 16; i++) {
-            maps.basic[i] = address(uint160(i));
-        }
-
-        for (uint160 a = 0; a < 4; a++) {
-            maps.vects[address(a)] = new bool[](0);
-            for (uint256 i = 0; i <= a; i++) {
-                maps.vects[address(a)].push(true);
-            }
-        }
-
-        for (int32 i = 0; i < 4; i++) {
-            maps.array.push();
-            maps.array[uint256(uint32(i))][i] = address(uint160(uint32(i)));
-        }
-
-        for (uint8 i = 0; i < 4; i++) {
-            maps.nested[bytes1(i)][i % 2 == 0] = i + 1;
-        }
-
-        maps.structs["stylus"] = sub;
-
-        for (uint256 i = 0; i < 4; i++) {
-            structs.push(sub);
-        }
-
-        arrays.strings[2] = "L2 is for you!";
-
-        for (uint256 i = 0; i < 5; i++) {
-            arrays.packed[i] = uint24(i);
-        }
-
-        for (uint256 i = 0; i < 2; i++) {
-            arrays.spill[i] = address(uint160(i));
-        }
-
-        for (uint256 i = 0; i < 4; i++) {
-            arrays.matrix[i][0] = uint8(i);
-            arrays.matrix[i][1] = arrays.matrix[i][0] + 1;
-        }
-
-        for (uint256 w = 0; w < 3; w++) {
-            int96[4] memory array;
-            for (int256 i = 0; i < 4; i++) {
-                array[uint256(i)] = int96(i);
-            }
-            arrays.vector.push(array);
-        }
-
-        for (uint256 w = 0; w < 4; w++) {
-            for (int96 i = 0; i < 4; i++) {
-                arrays.vectors[w].push(i);
-            }
-        }
-
-        for (uint256 i = 0; i < 3; i++) {
-            arrays.structs[i] = sub;
-        }
-    }
-
-    function remove() external {
-        while (bytesFull.length != 0) {
-            bytesFull.pop();
-        }
-
-        while (bytesLong.length > 16) {
-            bytesLong.pop();
-        }
-
-        chars = "wasm is cute <3";
-
-        while (vector.length != 0) {
-            vector.pop();
-        }
-
-        while (nested.length > 1) {
-            nested.pop();
-        }
-
-        for (uint256 i = 0; i < 8; i++) {
-            delete maps.basic[i];
-        }
-        maps.basic[8] = address(32);
-
-        for (uint160 i = 0; i < 4; i++) {
-            delete maps.vects[address(i)];
-        }
-
-        structs.pop();
-
-        delete arrays.matrix;
-        delete arrays.vector;
-        delete arrays.vectors;
-        delete arrays.structs;
-    }
-}

package/src/mocks/SelfDestruct.sol

@@ -1,33 +0,0 @@
-// Copyright 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.8.0;
-
-contract SelfDestructInConstructorWithoutDestination {
-    constructor() public payable {
-        selfdestruct(payable(address(this)));
-    }
-}
-
-contract SelfDestructInConstructorWithDestination {
-    constructor(
-        address payable destination
-    ) public payable {
-        selfdestruct(destination);
-    }
-}
-
-contract SelfDestructOutsideConstructor {
-    constructor() public payable {}
-
-    function selfDestructWithDestination(
-        address payable destination
-    ) public {
-        selfdestruct(destination);
-    }
-
-    function selfDestructWithoutDestination() public {
-        selfdestruct(payable(address(this)));
-    }
-}