@arbitrum/nitro-contracts 1.0.0-beta.1

package/src/mocks/BridgeStub.sol

@@ -0,0 +1,115 @@
+// Copyright 2021-2022, 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 "./InboxStub.sol";
+
+import "../bridge/IBridge.sol";
+
+contract BridgeStub is IBridge {
+    struct InOutInfo {
+        uint256 index;
+        bool allowed;
+    }
+
+    mapping(address => InOutInfo) private allowedInboxesMap;
+    //mapping(address => InOutInfo) private allowedOutboxesMap;
+
+    address[] public allowedInboxList;
+    address[] public allowedOutboxList;
+
+    address public override activeOutbox;
+
+    // Accumulator for delayed inbox; tail represents hash of the current state; each element represents the inclusion of a new message.
+    bytes32[] public override inboxAccs;
+
+    function allowedInboxes(address inbox) external view override returns (bool) {
+        return allowedInboxesMap[inbox].allowed;
+    }
+
+    function allowedOutboxes(address) external pure override returns (bool) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function enqueueDelayedMessage(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash
+    ) external payable override returns (uint256) {
+        require(allowedInboxesMap[msg.sender].allowed, "NOT_FROM_INBOX");
+        return
+            addMessageToAccumulator(
+                kind,
+                sender,
+                block.number,
+                block.timestamp, // solhint-disable-line not-rely-on-time
+                block.basefee,
+                messageDataHash
+            );
+    }
+
+    function addMessageToAccumulator(
+        uint8,
+        address,
+        uint256,
+        uint256,
+        uint256,
+        bytes32 messageDataHash
+    ) internal returns (uint256) {
+        uint256 count = inboxAccs.length;
+        bytes32 messageHash = Messages.messageHash(
+            0,
+            address(uint160(0)),
+            0,
+            0,
+            0,
+            0,
+            messageDataHash
+        );
+        bytes32 prevAcc = 0;
+        if (count > 0) {
+            prevAcc = inboxAccs[count - 1];
+        }
+        inboxAccs.push(Messages.accumulateInboxMessage(prevAcc, messageHash));
+        return count;
+    }
+
+    function executeCall(
+        address,
+        uint256,
+        bytes calldata
+    ) external pure override returns (bool, bytes memory) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function setInbox(address inbox, bool enabled) external override {
+        InOutInfo storage info = allowedInboxesMap[inbox];
+        bool alreadyEnabled = info.allowed;
+        emit InboxToggle(inbox, enabled);
+        if ((alreadyEnabled && enabled) || (!alreadyEnabled && !enabled)) {
+            return;
+        }
+        if (enabled) {
+            allowedInboxesMap[inbox] = InOutInfo(allowedInboxList.length, true);
+            allowedInboxList.push(inbox);
+        } else {
+            allowedInboxList[info.index] = allowedInboxList[allowedInboxList.length - 1];
+            allowedInboxesMap[allowedInboxList[info.index]].index = info.index;
+            allowedInboxList.pop();
+            delete allowedInboxesMap[inbox];
+        }
+    }
+
+    function setOutbox(
+        address, /* outbox */
+        bool /* enabled*/
+    ) external pure override {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function messageCount() external view override returns (uint256) {
+        return inboxAccs.length;
+    }
+}

package/src/mocks/Counter.sol

@@ -0,0 +1,13 @@
+// Copyright 2021-2022, 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 Simple {
+    uint64 public counter;
+
+    function increment() external {
+        counter++;
+    }
+}

package/src/mocks/ExecutionManager.sol

@@ -0,0 +1,41 @@
+// Copyright 2021-2022, 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 "../challenge/ChallengeManager.sol";
+
+contract SingleExecutionChallenge is ChallengeManager {
+    constructor(
+        IOneStepProofEntry osp_,
+        IChallengeResultReceiver resultReceiver_,
+        uint64 maxInboxMessagesRead_,
+        bytes32[2] memory startAndEndHashes,
+        uint256 numSteps_,
+        address asserter_,
+        address challenger_,
+        uint256 asserterTimeLeft_,
+        uint256 challengerTimeLeft_
+    ) {
+        osp = osp_;
+        resultReceiver = resultReceiver_;
+        uint64 challengeIndex = ++totalChallengesCreated;
+        ChallengeLib.Challenge storage challenge = challenges[challengeIndex];
+        challenge.maxInboxMessages = maxInboxMessagesRead_;
+        bytes32[] memory segments = new bytes32[](2);
+        segments[0] = startAndEndHashes[0];
+        segments[1] = startAndEndHashes[1];
+        bytes32 challengeStateHash = ChallengeLib.hashChallengeState(0, numSteps_, segments);
+        challenge.challengeStateHash = challengeStateHash;
+        challenge.next = ChallengeLib.Participant({addr: asserter_, timeLeft: asserterTimeLeft_});
+        challenge.current = ChallengeLib.Participant({
+            addr: challenger_,
+            timeLeft: challengerTimeLeft_
+        });
+        challenge.lastMoveTimestamp = block.timestamp;
+        challenge.mode = ChallengeLib.ChallengeMode.EXECUTION;
+
+        emit Bisected(challengeIndex, challengeStateHash, 0, numSteps_, segments);
+    }
+}

package/src/mocks/InboxStub.sol

@@ -0,0 +1,131 @@
+// Copyright 2021-2022, 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 "../bridge/IInbox.sol";
+import "../bridge/IBridge.sol";
+
+import "../bridge/Messages.sol";
+import "./BridgeStub.sol";
+import {
+    L2_MSG,
+    L1MessageType_L2FundedByL1,
+    L1MessageType_submitRetryableTx,
+    L2MessageType_unsignedEOATx,
+    L2MessageType_unsignedContractTx
+} from "../libraries/MessageTypes.sol";
+
+contract InboxStub is IInbox {
+    IBridge public override bridge;
+
+    bool public paused;
+
+    function initialize(IBridge _bridge) external {
+        require(address(bridge) == address(0), "ALREADY_INIT");
+        bridge = _bridge;
+    }
+
+    /**
+     * @notice Send a generic L2 message to the chain
+     * @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) {
+        // solhint-disable-next-line avoid-tx-origin
+        require(msg.sender == tx.origin, "origin only");
+        uint256 msgNum = deliverToBridge(L2_MSG, msg.sender, keccak256(messageData));
+        emit InboxMessageDeliveredFromOrigin(msgNum);
+        return msgNum;
+    }
+
+    /**
+     * @notice Send a generic L2 message to the chain
+     * @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) {
+        uint256 msgNum = deliverToBridge(L2_MSG, msg.sender, keccak256(messageData));
+        emit InboxMessageDelivered(msgNum, messageData);
+        return msgNum;
+    }
+
+    function deliverToBridge(
+        uint8 kind,
+        address sender,
+        bytes32 messageDataHash
+    ) internal returns (uint256) {
+        return bridge.enqueueDelayedMessage{value: msg.value}(kind, sender, messageDataHash);
+    }
+
+    function sendUnsignedTransaction(
+        uint256,
+        uint256,
+        uint256,
+        address,
+        uint256,
+        bytes calldata
+    ) external pure override returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function sendContractTransaction(
+        uint256,
+        uint256,
+        address,
+        uint256,
+        bytes calldata
+    ) external pure override returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function sendL1FundedUnsignedTransaction(
+        uint256,
+        uint256,
+        uint256,
+        address,
+        bytes calldata
+    ) external payable override returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function sendL1FundedContractTransaction(
+        uint256,
+        uint256,
+        address,
+        bytes calldata
+    ) external payable override returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function createRetryableTicket(
+        address,
+        uint256,
+        uint256,
+        address,
+        address,
+        uint256,
+        uint256,
+        bytes calldata
+    ) external payable override returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function unsafeCreateRetryableTicket(
+        address,
+        uint256,
+        uint256,
+        address,
+        address,
+        uint256,
+        uint256,
+        bytes calldata
+    ) external payable override returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+
+    function depositEth(uint256) external payable override returns (uint256) {
+        revert("NOT_IMPLEMENTED");
+    }
+}

package/src/mocks/MockResultReceiver.sol

@@ -0,0 +1,59 @@
+// Copyright 2021-2022, 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 "../challenge/IChallengeResultReceiver.sol";
+import "../challenge/IChallengeManager.sol";
+
+contract MockResultReceiver is IChallengeResultReceiver {
+    IChallengeManager public manager;
+    address public winner;
+    address public loser;
+    uint256 public challengeIndex;
+
+    event ChallengeCompleted(
+        uint256 indexed challengeIndex,
+        address indexed winner,
+        address indexed loser
+    );
+
+    constructor(IChallengeManager manager_) {
+        manager = manager_;
+    }
+
+    function createChallenge(
+        bytes32 wasmModuleRoot_,
+        MachineStatus[2] calldata startAndEndMachineStatuses_,
+        GlobalState[2] calldata startAndEndGlobalStates_,
+        uint64 numBlocks,
+        address asserter_,
+        address challenger_,
+        uint256 asserterTimeLeft_,
+        uint256 challengerTimeLeft_
+    ) external returns (uint64) {
+        return
+            manager.createChallenge(
+                wasmModuleRoot_,
+                startAndEndMachineStatuses_,
+                startAndEndGlobalStates_,
+                numBlocks,
+                asserter_,
+                challenger_,
+                asserterTimeLeft_,
+                challengerTimeLeft_
+            );
+    }
+
+    function completeChallenge(
+        uint256 challengeIndex_,
+        address winner_,
+        address loser_
+    ) external override {
+        winner = winner_;
+        loser = loser_;
+        challengeIndex = challengeIndex_;
+        emit ChallengeCompleted(challengeIndex, winner_, loser_);
+    }
+}

package/src/mocks/SequencerInboxStub.sol

@@ -0,0 +1,42 @@
+// Copyright 2021-2022, 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 "../bridge/SequencerInbox.sol";
+
+contract SequencerInboxStub is SequencerInbox {
+    constructor(
+        IBridge delayedBridge_,
+        address sequencer_,
+        ISequencerInbox.MaxTimeVariation memory maxTimeVariation_
+    ) {
+        delayedBridge = delayedBridge_;
+        rollup = msg.sender;
+        maxTimeVariation = maxTimeVariation_;
+        isBatchPoster[sequencer_] = true;
+    }
+
+    function addInitMessage() external {
+        (bytes32 dataHash, TimeBounds memory timeBounds) = formEmptyDataHash(0);
+        (bytes32 beforeAcc, bytes32 delayedAcc, bytes32 afterAcc) = addSequencerL2BatchImpl(
+            dataHash,
+            0
+        );
+        emit SequencerBatchDelivered(
+            inboxAccs.length - 1,
+            beforeAcc,
+            afterAcc,
+            delayedAcc,
+            totalDelayedMessagesRead,
+            timeBounds,
+            BatchDataLocation.NoData
+        );
+    }
+
+    function getTimeBounds() internal view override returns (TimeBounds memory bounds) {
+        this; // silence warning about function not being view
+        return bounds;
+    }
+}

package/src/mocks/SimpleProxy.sol

@@ -0,0 +1,19 @@
+// Copyright 2021-2022, 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 "@openzeppelin/contracts/proxy/Proxy.sol";
+
+contract SimpleProxy is Proxy {
+    address private immutable impl;
+
+    constructor(address impl_) {
+        impl = impl_;
+    }
+
+    function _implementation() internal view override returns (address) {
+        return impl;
+    }
+}

package/src/node-interface/NodeInterface.sol

@@ -0,0 +1,50 @@
+// Copyright 2021-2022, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity >=0.4.21 <0.9.0;
+
+/** @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
+ */
+
+interface NodeInterface {
+    /**
+     * @notice Estimate the cost of putting a message in the L2 inbox that is reexecuted
+     * @param sender sender of the L1 and L2 transaction
+     * @param deposit amount to deposit to sender in L2
+     * @param to destination L2 contract address
+     * @param l2CallValue call value for retryable L2 message
+     * @param excessFeeRefundAddress gasLimit x maxFeePerGas - execution cost gets credited here on L2 balance
+     * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
+     * @param data ABI encoded data of L2 message
+     */
+    function estimateRetryableTicket(
+        address sender,
+        uint256 deposit,
+        address to,
+        uint256 l2CallValue,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
+        bytes calldata data
+    ) external;
+
+    /**
+     * @notice Constructs an outbox proof of an l2->l1 send's existence in the outbox accumulator
+     * @param size the number of elements in the accumulator
+     * @param leaf the position of the send in the accumulator
+     * @return send the l2->l1 send's hash
+     * @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
+        );
+}

package/src/osp/HashProofHelper.sol

@@ -0,0 +1,154 @@
+// Copyright 2021-2022, 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 "../libraries/CryptographyPrimitives.sol";
+
+/// @dev The requested hash preimage at the given offset has not been proven yet
+error NotProven(bytes32 fullHash, uint64 offset);
+
+contract HashProofHelper {
+    struct KeccakState {
+        uint64 offset;
+        bytes part;
+        uint64[25] state;
+        uint256 length;
+    }
+
+    struct PreimagePart {
+        bool proven;
+        bytes part;
+    }
+
+    mapping(bytes32 => mapping(uint64 => PreimagePart)) private preimageParts;
+    mapping(address => KeccakState) public keccakStates;
+
+    event PreimagePartProven(bytes32 indexed fullHash, uint64 indexed offset, bytes part);
+
+    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)
+    {
+        fullHash = keccak256(data);
+        bytes memory part;
+        if (data.length > offset) {
+            uint256 partLength = data.length - offset;
+            if (partLength > 32) {
+                partLength = 32;
+            }
+            part = data[offset:(offset + partLength)];
+        }
+        preimageParts[fullHash][offset] = PreimagePart({proven: true, part: part});
+        emit PreimagePartProven(fullHash, offset, part);
+    }
+
+    // Flags: a bitset signaling various things about the proof, ordered from least to most significant bits.
+    //   0th bit: indicates that this data is the final chunk of preimage data.
+    //   1st bit: indicates that the preimage part currently being built should be cleared before this.
+    function proveWithSplitPreimage(
+        bytes calldata data,
+        uint64 offset,
+        uint256 flags
+    ) external returns (bytes32 fullHash) {
+        bool isFinal = (flags & (1 << 0)) != 0;
+        if ((flags & (1 << 1)) != 0) {
+            delete keccakStates[msg.sender];
+        }
+        require(isFinal || data.length % KECCAK_ROUND_INPUT == 0, "NOT_BLOCK_ALIGNED");
+        KeccakState storage state = keccakStates[msg.sender];
+        uint256 startLength = state.length;
+        if (startLength == 0) {
+            state.offset = offset;
+        } else {
+            require(state.offset == offset, "DIFF_OFFSET");
+        }
+        keccakUpdate(state, data, isFinal);
+        if (uint256(offset) + MAX_PART_LENGTH > startLength && offset < state.length) {
+            uint256 startIdx = 0;
+            if (offset > startLength) {
+                startIdx = offset - startLength;
+            }
+            uint256 endIdx = uint256(offset) + MAX_PART_LENGTH - startLength;
+            if (endIdx > data.length) {
+                endIdx = data.length;
+            }
+            for (uint256 i = startIdx; i < endIdx; i++) {
+                state.part.push(data[i]);
+            }
+        }
+        if (!isFinal) {
+            return bytes32(0);
+        }
+        for (uint256 i = 0; i < 32; i++) {
+            uint256 stateIdx = i / 8;
+            // work around our weird keccakF function state ordering
+            stateIdx = 5 * (stateIdx % 5) + stateIdx / 5;
+            uint8 b = uint8(state.state[stateIdx] >> ((i % 8) * 8));
+            fullHash |= bytes32(uint256(b) << (248 - (i * 8)));
+        }
+        preimageParts[fullHash][state.offset] = PreimagePart({proven: true, part: state.part});
+        emit PreimagePartProven(fullHash, state.offset, state.part);
+        delete keccakStates[msg.sender];
+    }
+
+    function keccakUpdate(
+        KeccakState storage state,
+        bytes calldata data,
+        bool isFinal
+    ) internal {
+        state.length += data.length;
+        while (true) {
+            if (data.length == 0 && !isFinal) {
+                break;
+            }
+            for (uint256 i = 0; i < KECCAK_ROUND_INPUT; i++) {
+                uint8 b = 0;
+                if (i < data.length) {
+                    b = uint8(data[i]);
+                } else {
+                    // Padding
+                    if (i == data.length) {
+                        b |= uint8(0x01);
+                    }
+                    if (i == KECCAK_ROUND_INPUT - 1) {
+                        b |= uint8(0x80);
+                    }
+                }
+                uint256 stateIdx = i / 8;
+                // work around our weird keccakF function state ordering
+                stateIdx = 5 * (stateIdx % 5) + stateIdx / 5;
+                state.state[stateIdx] ^= uint64(b) << uint64((i % 8) * 8);
+            }
+            uint256[25] memory state256;
+            for (uint256 i = 0; i < 25; i++) {
+                state256[i] = state.state[i];
+            }
+            state256 = CryptographyPrimitives.keccakF(state256);
+            for (uint256 i = 0; i < 25; i++) {
+                state.state[i] = uint64(state256[i]);
+            }
+            if (data.length < KECCAK_ROUND_INPUT) {
+                break;
+            }
+            data = data[KECCAK_ROUND_INPUT:];
+        }
+    }
+
+    function clearSplitProof() external {
+        delete keccakStates[msg.sender];
+    }
+
+    /// 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) {
+        PreimagePart storage part = preimageParts[fullHash][offset];
+        if (!part.proven) {
+            revert NotProven(fullHash, offset);
+        }
+        return part.part;
+    }
+}

package/src/osp/IOneStepProofEntry.sol

@@ -0,0 +1,20 @@
+// Copyright 2021-2022, 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 "./IOneStepProver.sol";
+
+library OneStepProofEntryLib {
+    uint256 internal constant MAX_STEPS = 1 << 43;
+}
+
+interface IOneStepProofEntry {
+    function proveOneStep(
+        ExecutionContext calldata execCtx,
+        uint256 machineStep,
+        bytes32 beforeHash,
+        bytes calldata proof
+    ) external view returns (bytes32 afterHash);
+}

package/src/osp/IOneStepProver.sol

@@ -0,0 +1,27 @@
+// Copyright 2021-2022, 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 "../state/Machine.sol";
+import "../state/Module.sol";
+import "../state/Instructions.sol";
+import "../bridge/ISequencerInbox.sol";
+import "../bridge/IBridge.sol";
+
+struct ExecutionContext {
+    uint256 maxInboxMessagesRead;
+    ISequencerInbox sequencerInbox;
+    IBridge delayedBridge;
+}
+
+abstract contract IOneStepProver {
+    function executeOneStep(
+        ExecutionContext memory execCtx,
+        Machine calldata mach,
+        Module calldata mod,
+        Instruction calldata instruction,
+        bytes calldata proof
+    ) external view virtual returns (Machine memory result, Module memory resultMod);
+}