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

package/src/challenge/ChallengeManager.sol

@@ -1,375 +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 "../libraries/DelegateCallAware.sol";
-import "../osp/IOneStepProofEntry.sol";
-import "../state/GlobalState.sol";
-import "./IChallengeResultReceiver.sol";
-import "./ChallengeLib.sol";
-import "./IChallengeManager.sol";
-
-import {NO_CHAL_INDEX} from "../libraries/Constants.sol";
-
-contract ChallengeManager is DelegateCallAware, IChallengeManager {
-    using GlobalStateLib for GlobalState;
-    using MachineLib for Machine;
-    using ChallengeLib for ChallengeLib.Challenge;
-
-    enum ChallengeModeRequirement {
-        ANY,
-        BLOCK,
-        EXECUTION
-    }
-
-    string private constant NO_CHAL = "NO_CHAL";
-    uint256 private constant MAX_CHALLENGE_DEGREE = 40;
-
-    uint64 public totalChallengesCreated;
-    mapping(uint256 => ChallengeLib.Challenge) public challenges;
-
-    IChallengeResultReceiver public resultReceiver;
-
-    ISequencerInbox public sequencerInbox;
-    IBridge public bridge;
-    IOneStepProofEntry public osp;
-    mapping(bytes32 => IOneStepProofEntry) public ospCond;
-
-    function challengeInfo(uint64 challengeIndex)
-        external
-        view
-        override
-        returns (ChallengeLib.Challenge memory)
-    {
-        return challenges[challengeIndex];
-    }
-
-    modifier takeTurn(
-        uint64 challengeIndex,
-        ChallengeLib.SegmentSelection calldata selection,
-        ChallengeModeRequirement expectedMode
-    ) {
-        ChallengeLib.Challenge storage challenge = challenges[challengeIndex];
-        require(msg.sender == currentResponder(challengeIndex), "CHAL_SENDER");
-        require(!isTimedOut(challengeIndex), "CHAL_DEADLINE");
-
-        if (expectedMode == ChallengeModeRequirement.ANY) {
-            require(challenge.mode != ChallengeLib.ChallengeMode.NONE, NO_CHAL);
-        } else if (expectedMode == ChallengeModeRequirement.BLOCK) {
-            require(challenge.mode == ChallengeLib.ChallengeMode.BLOCK, "CHAL_NOT_BLOCK");
-        } else if (expectedMode == ChallengeModeRequirement.EXECUTION) {
-            require(challenge.mode == ChallengeLib.ChallengeMode.EXECUTION, "CHAL_NOT_EXECUTION");
-        } else {
-            assert(false);
-        }
-
-        require(
-            challenge.challengeStateHash ==
-                ChallengeLib.hashChallengeState(
-                    selection.oldSegmentsStart,
-                    selection.oldSegmentsLength,
-                    selection.oldSegments
-                ),
-            "BIS_STATE"
-        );
-        if (
-            selection.oldSegments.length < 2 ||
-            selection.challengePosition >= selection.oldSegments.length - 1
-        ) {
-            revert("BAD_CHALLENGE_POS");
-        }
-
-        _;
-
-        if (challenge.mode == ChallengeLib.ChallengeMode.NONE) {
-            // Early return since challenge must have terminated
-            return;
-        }
-
-        ChallengeLib.Participant memory current = challenge.current;
-        current.timeLeft -= block.timestamp - challenge.lastMoveTimestamp;
-
-        challenge.current = challenge.next;
-        challenge.next = current;
-
-        challenge.lastMoveTimestamp = block.timestamp;
-    }
-
-    function initialize(
-        IChallengeResultReceiver resultReceiver_,
-        ISequencerInbox sequencerInbox_,
-        IBridge bridge_,
-        IOneStepProofEntry osp_
-    ) external override onlyDelegated {
-        require(address(resultReceiver) == address(0), "ALREADY_INIT");
-        require(address(resultReceiver_) != address(0), "NO_RESULT_RECEIVER");
-        resultReceiver = resultReceiver_;
-        sequencerInbox = sequencerInbox_;
-        bridge = bridge_;
-        osp = osp_;
-    }
-
-    /// @dev A osp breaking change is introduced as part of Stylus upgrade, where the new osp would not support
-    ///      pre-Stylus legacy wasmModuleRoot. To ensure that the new osp is not used for legacy wasmModuleRoot,
-    ///      we introduce a conditional OSP where condRoot should be set to the pre-Stylus root and condOsp should
-    ///      be set to the pre-Stylus osp. The correct value should be handled by the upgrade action contract.
-    function postUpgradeInit(
-        IOneStepProofEntry osp_,
-        bytes32 condRoot,
-        IOneStepProofEntry condOsp
-    ) external onlyDelegated onlyProxyOwner {
-        ospCond[condRoot] = condOsp;
-        osp = osp_;
-    }
-
-    function getOsp(bytes32 wasmModuleRoot) public view returns (IOneStepProofEntry) {
-        IOneStepProofEntry t = ospCond[wasmModuleRoot];
-        if (address(t) == address(0)) {
-            return osp;
-        } else {
-            return t;
-        }
-    }
-
-    function createChallenge(
-        bytes32 wasmModuleRoot_,
-        MachineStatus[2] calldata startAndEndMachineStatuses_,
-        GlobalState[2] calldata startAndEndGlobalStates_,
-        uint64 numBlocks,
-        address asserter_,
-        address challenger_,
-        uint256 asserterTimeLeft_,
-        uint256 challengerTimeLeft_
-    ) external override returns (uint64) {
-        require(msg.sender == address(resultReceiver), "ONLY_ROLLUP_CHAL");
-        bytes32[] memory segments = new bytes32[](2);
-        segments[0] = ChallengeLib.blockStateHash(
-            startAndEndMachineStatuses_[0],
-            startAndEndGlobalStates_[0].hash()
-        );
-        segments[1] = ChallengeLib.blockStateHash(
-            startAndEndMachineStatuses_[1],
-            startAndEndGlobalStates_[1].hash()
-        );
-
-        uint64 challengeIndex = ++totalChallengesCreated;
-        // The following is an assertion since it should never be possible, but it's an important invariant
-        assert(challengeIndex != NO_CHAL_INDEX);
-        ChallengeLib.Challenge storage challenge = challenges[challengeIndex];
-        challenge.wasmModuleRoot = wasmModuleRoot_;
-
-        // See validator/assertion.go ExecutionState RequiredBatches() for reasoning
-        uint64 maxInboxMessagesRead = startAndEndGlobalStates_[1].getInboxPosition();
-        if (
-            startAndEndMachineStatuses_[1] == MachineStatus.ERRORED ||
-            startAndEndGlobalStates_[1].getPositionInMessage() > 0
-        ) {
-            maxInboxMessagesRead++;
-        }
-        challenge.maxInboxMessages = maxInboxMessagesRead;
-        challenge.next = ChallengeLib.Participant({addr: asserter_, timeLeft: asserterTimeLeft_});
-        challenge.current = ChallengeLib.Participant({
-            addr: challenger_,
-            timeLeft: challengerTimeLeft_
-        });
-        challenge.lastMoveTimestamp = block.timestamp;
-        challenge.mode = ChallengeLib.ChallengeMode.BLOCK;
-
-        emit InitiatedChallenge(
-            challengeIndex,
-            startAndEndGlobalStates_[0],
-            startAndEndGlobalStates_[1]
-        );
-        completeBisection(challengeIndex, 0, numBlocks, segments);
-        return challengeIndex;
-    }
-
-    /**
-     * @notice Initiate the next round in the bisection by objecting to execution correctness with a bisection
-     * of an execution segment with the same length but a different endpoint. This is either the initial move
-     * or follows another execution objection
-     */
-    function bisectExecution(
-        uint64 challengeIndex,
-        ChallengeLib.SegmentSelection calldata selection,
-        bytes32[] calldata newSegments
-    ) external takeTurn(challengeIndex, selection, ChallengeModeRequirement.ANY) {
-        (uint256 challengeStart, uint256 challengeLength) = ChallengeLib.extractChallengeSegment(
-            selection
-        );
-        require(challengeLength > 1, "TOO_SHORT");
-        {
-            uint256 expectedDegree = challengeLength;
-            if (expectedDegree > MAX_CHALLENGE_DEGREE) {
-                expectedDegree = MAX_CHALLENGE_DEGREE;
-            }
-            require(newSegments.length == expectedDegree + 1, "WRONG_DEGREE");
-        }
-
-        requireValidBisection(selection, newSegments[0], newSegments[newSegments.length - 1]);
-
-        completeBisection(challengeIndex, challengeStart, challengeLength, newSegments);
-    }
-
-    function challengeExecution(
-        uint64 challengeIndex,
-        ChallengeLib.SegmentSelection calldata selection,
-        MachineStatus[2] calldata machineStatuses,
-        bytes32[2] calldata globalStateHashes,
-        uint256 numSteps
-    ) external takeTurn(challengeIndex, selection, ChallengeModeRequirement.BLOCK) {
-        require(numSteps >= 1, "CHALLENGE_TOO_SHORT");
-        require(numSteps <= OneStepProofEntryLib.MAX_STEPS, "CHALLENGE_TOO_LONG");
-        requireValidBisection(
-            selection,
-            ChallengeLib.blockStateHash(machineStatuses[0], globalStateHashes[0]),
-            ChallengeLib.blockStateHash(machineStatuses[1], globalStateHashes[1])
-        );
-
-        ChallengeLib.Challenge storage challenge = challenges[challengeIndex];
-        (uint256 executionChallengeAtSteps, uint256 challengeLength) = ChallengeLib
-            .extractChallengeSegment(selection);
-        require(challengeLength == 1, "TOO_LONG");
-
-        if (machineStatuses[0] != MachineStatus.FINISHED) {
-            // If the machine is in a halted state, it can't change
-            require(
-                machineStatuses[0] == machineStatuses[1] &&
-                    globalStateHashes[0] == globalStateHashes[1],
-                "HALTED_CHANGE"
-            );
-            _currentWin(challengeIndex, ChallengeTerminationType.BLOCK_PROOF);
-            return;
-        }
-
-        if (machineStatuses[1] == MachineStatus.ERRORED) {
-            // If the machine errors, it must return to the previous global state
-            require(globalStateHashes[0] == globalStateHashes[1], "ERROR_CHANGE");
-        }
-
-        bytes32[] memory segments = new bytes32[](2);
-        IOneStepProofEntry _osp = getOsp(challenge.wasmModuleRoot);
-        segments[0] = _osp.getStartMachineHash(globalStateHashes[0], challenge.wasmModuleRoot);
-        segments[1] = _osp.getEndMachineHash(machineStatuses[1], globalStateHashes[1]);
-
-        challenge.mode = ChallengeLib.ChallengeMode.EXECUTION;
-
-        completeBisection(challengeIndex, 0, numSteps, segments);
-
-        emit ExecutionChallengeBegun(challengeIndex, executionChallengeAtSteps);
-    }
-
-    function oneStepProveExecution(
-        uint64 challengeIndex,
-        ChallengeLib.SegmentSelection calldata selection,
-        bytes calldata proof
-    ) external takeTurn(challengeIndex, selection, ChallengeModeRequirement.EXECUTION) {
-        ChallengeLib.Challenge storage challenge = challenges[challengeIndex];
-        uint256 challengeStart;
-        {
-            uint256 challengeLength;
-            (challengeStart, challengeLength) = ChallengeLib.extractChallengeSegment(selection);
-            require(challengeLength == 1, "TOO_LONG");
-        }
-
-        bytes32 afterHash = getOsp(challenge.wasmModuleRoot).proveOneStep(
-            ExecutionContext({maxInboxMessagesRead: challenge.maxInboxMessages, bridge: bridge}),
-            challengeStart,
-            selection.oldSegments[selection.challengePosition],
-            proof
-        );
-        require(
-            afterHash != selection.oldSegments[selection.challengePosition + 1],
-            "SAME_OSP_END"
-        );
-
-        emit OneStepProofCompleted(challengeIndex);
-        _currentWin(challengeIndex, ChallengeTerminationType.EXECUTION_PROOF);
-    }
-
-    function timeout(uint64 challengeIndex) external override {
-        require(challenges[challengeIndex].mode != ChallengeLib.ChallengeMode.NONE, NO_CHAL);
-        require(isTimedOut(challengeIndex), "TIMEOUT_DEADLINE");
-        _nextWin(challengeIndex, ChallengeTerminationType.TIMEOUT);
-    }
-
-    function clearChallenge(uint64 challengeIndex) external override {
-        require(msg.sender == address(resultReceiver), "NOT_RES_RECEIVER");
-        require(challenges[challengeIndex].mode != ChallengeLib.ChallengeMode.NONE, NO_CHAL);
-        delete challenges[challengeIndex];
-        emit ChallengeEnded(challengeIndex, ChallengeTerminationType.CLEARED);
-    }
-
-    function currentResponder(uint64 challengeIndex) public view override returns (address) {
-        return challenges[challengeIndex].current.addr;
-    }
-
-    function isTimedOut(uint64 challengeIndex) public view virtual override returns (bool) {
-        return challenges[challengeIndex].isTimedOut();
-    }
-
-    function requireValidBisection(
-        ChallengeLib.SegmentSelection calldata selection,
-        bytes32 startHash,
-        bytes32 endHash
-    ) private pure {
-        require(selection.oldSegments[selection.challengePosition] == startHash, "WRONG_START");
-        require(selection.oldSegments[selection.challengePosition + 1] != endHash, "SAME_END");
-    }
-
-    function completeBisection(
-        uint64 challengeIndex,
-        uint256 challengeStart,
-        uint256 challengeLength,
-        bytes32[] memory newSegments
-    ) private {
-        assert(challengeLength >= 1);
-        assert(newSegments.length >= 2);
-
-        bytes32 challengeStateHash = ChallengeLib.hashChallengeState(
-            challengeStart,
-            challengeLength,
-            newSegments
-        );
-        challenges[challengeIndex].challengeStateHash = challengeStateHash;
-
-        emit Bisected(
-            challengeIndex,
-            challengeStateHash,
-            challengeStart,
-            challengeLength,
-            newSegments
-        );
-    }
-
-    /// @dev This function causes the mode of the challenge to be set to NONE by deleting the challenge
-    function _nextWin(uint64 challengeIndex, ChallengeTerminationType reason) private {
-        ChallengeLib.Challenge storage challenge = challenges[challengeIndex];
-        address next = challenge.next.addr;
-        address current = challenge.current.addr;
-        delete challenges[challengeIndex];
-        resultReceiver.completeChallenge(challengeIndex, next, current);
-        emit ChallengeEnded(challengeIndex, reason);
-    }
-
-    /**
-     * @dev this currently sets a challenge hash of 0 - no move is possible for the next participant to progress the
-     * state. It is assumed that wherever this function is consumed, the turn is then adjusted for the opposite party
-     * to timeout. This is done as a safety measure so challenges can only be resolved by timeouts during mainnet beta.
-     */
-    function _currentWin(
-        uint64 challengeIndex,
-        ChallengeTerminationType /* reason */
-    ) private {
-        ChallengeLib.Challenge storage challenge = challenges[challengeIndex];
-        challenge.challengeStateHash = bytes32(0);
-
-        //        address next = challenge.next.addr;
-        //        address current = challenge.current.addr;
-        //        delete challenges[challengeIndex];
-        //        resultReceiver.completeChallenge(challengeIndex, current, next);
-        //        emit ChallengeEnded(challengeIndex, reason);
-    }
-}

package/src/challenge/IChallengeManager.sol

@@ -1,86 +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 "../state/Machine.sol";
-import "../bridge/IBridge.sol";
-import "../bridge/ISequencerInbox.sol";
-import "../osp/IOneStepProofEntry.sol";
-
-import "./IChallengeResultReceiver.sol";
-
-import "./ChallengeLib.sol";
-
-interface IChallengeManager {
-    enum ChallengeTerminationType {
-        TIMEOUT,
-        BLOCK_PROOF,
-        EXECUTION_PROOF,
-        CLEARED
-    }
-
-    event InitiatedChallenge(
-        uint64 indexed challengeIndex,
-        GlobalState startState,
-        GlobalState endState
-    );
-
-    event Bisected(
-        uint64 indexed challengeIndex,
-        bytes32 indexed challengeRoot,
-        uint256 challengedSegmentStart,
-        uint256 challengedSegmentLength,
-        bytes32[] chainHashes
-    );
-
-    event ExecutionChallengeBegun(uint64 indexed challengeIndex, uint256 blockSteps);
-    event OneStepProofCompleted(uint64 indexed challengeIndex);
-
-    event ChallengeEnded(uint64 indexed challengeIndex, ChallengeTerminationType kind);
-
-    function initialize(
-        IChallengeResultReceiver resultReceiver_,
-        ISequencerInbox sequencerInbox_,
-        IBridge bridge_,
-        IOneStepProofEntry osp_
-    ) external;
-
-    function postUpgradeInit(
-        IOneStepProofEntry osp_,
-        bytes32 condRoot,
-        IOneStepProofEntry condOsp
-    ) external;
-
-    /// @notice Get the default osp, which is used for all wasm module roots that don't have a conditional OSP set
-    ///         Use getOsp(wasmModuleRoot) to get the OSP for a specific wasm module root
-    function osp() external view returns (IOneStepProofEntry);
-
-    /// @notice Get the OSP for a given wasm module root
-    function getOsp(bytes32 wasmModuleRoot) external view returns (IOneStepProofEntry);
-
-    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);
-
-    function challengeInfo(uint64 challengeIndex_)
-        external
-        view
-        returns (ChallengeLib.Challenge memory);
-
-    function currentResponder(uint64 challengeIndex) external view returns (address);
-
-    function isTimedOut(uint64 challengeIndex) external view returns (bool);
-
-    function clearChallenge(uint64 challengeIndex_) external;
-
-    function timeout(uint64 challengeIndex_) external;
-}

package/src/challenge/IChallengeResultReceiver.sol

@@ -1,13 +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;
-
-interface IChallengeResultReceiver {
-    function completeChallenge(
-        uint256 challengeIndex,
-        address winner,
-        address loser
-    ) external;
-}

package/src/express-lane-auction/Balance.sol

@@ -1,142 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-pragma solidity ^0.8.0;
-
-import "./Errors.sol";
-
-/// @notice Account balance and the round at which it can be withdrawn
-///         Balances are withdrawn as part of a two step process - initiation and finalization
-///         This is so that a bidder can't withdraw their balance after making a bid
-///         Instead, if they initiate their withdrawal in round r, they must wait until the beginning of
-///         round r+2 before they can withdraw the balance. In the mean time their balance can be used to
-///         resolve an auction if it is part of a valid bid, however the auctioneer may choose to
-///         reject bids from accounts with an initiated balance withdrawal
-struct Balance {
-    /// @notice The amount of balance in the account
-    uint256 balance;
-    /// @notice The round at which all of the balance can be withdrawn
-    ///         Is set to uint64.max when no withdrawal has been intiated
-    uint64 withdrawalRound;
-}
-
-/// @notice Balance mutation and view functionality. This is in it's own library so that we can
-//          reason about and test how the different ways balance mutations interact with each other
-library BalanceLib {
-    /// @notice The available balance at the supplied round. Returns 0 if a withdrawal has been initiated and has
-    ///         past the withdrawal round.
-    /// @param bal The balance to query
-    /// @param round The round to check the balance in
-    function balanceAtRound(Balance storage bal, uint64 round) internal view returns (uint256) {
-        return bal.balance - withdrawableBalanceAtRound(bal, round);
-    }
-
-    /// @notice The withdrawable balance at the supplied round. If a withdrawal has been initiated, the
-    ///         supplied round is past the withdrawal round and has yet to be finalized, then the balance
-    ///         of this account is returned. Otherwise 0.
-    /// @param bal The balance to query
-    /// @param round The round to check the withdrawable balance in
-    function withdrawableBalanceAtRound(Balance storage bal, uint64 round)
-        internal
-        view
-        returns (uint256)
-    {
-        return round >= bal.withdrawalRound ? bal.balance : 0;
-    }
-
-    /// @notice Increase a balance by a specified amount
-    ///         Will cancel a withdrawal if called after a withdrawal has been initiated
-    /// @param bal The balance info
-    /// @param amount The amount to increase the balance by
-    function increase(Balance storage bal, uint256 amount) internal {
-        // no point increasing if no amount is being supplied
-        if (amount == 0) {
-            revert ZeroAmount();
-        }
-
-        // if the balance have never been used before then balance and withdrawal round will be 0
-        // in this case we initialize the balance by setting the withdrawal round into the future
-        // if a withdrawal for the balance has been initialized (withdrawal round != 0 and != max)
-        // then we cancel that initiated withdrawal. We do this since if a increase is being made that
-        // means a user wishes to increase their balance, not withdraw it.
-        if (bal.withdrawalRound != type(uint64).max) {
-            bal.withdrawalRound = type(uint64).max;
-        }
-
-        bal.balance += amount;
-    }
-
-    /// @notice Reduce a balance immediately. The balance must already be greater than the amount
-    ///         and a withdrawal has been initiated for this balance it must be occuring in
-    ///         a round after the supplied round. Withdrawals earlier than that will block this reduce.
-    /// @param bal The balance to reduce
-    /// @param amount The amount to reduce by
-    /// @param round The round to check withdrawals against. A withdrawal after this round will be ignored
-    ///              and the balance reduced anyway, withdrawals before or on this round will be respected
-    ///              and the reduce will revert
-    function reduce(
-        Balance storage bal,
-        uint256 amount,
-        uint64 round
-    ) internal {
-        uint256 balRnd = balanceAtRound(bal, round);
-        // we add a zero check since it's possible for the amount to be zero
-        // but even in that case the user must have some balance
-        // to enforce that parties that havent done the deposit step cannot take part in the auction
-        if (balRnd == 0 || balRnd < amount) {
-            revert InsufficientBalance(amount, balRnd);
-        }
-
-        bal.balance -= amount;
-    }
-
-    /// @notice Initiate a withdrawal. A withdrawal is a reduction of the full amount.
-    ///         Withdrawal is a two step process initialization and finalization. Finalization is only
-    ///         after the supplied round parameter. The expected usage is to specify a round that is 2
-    ///         in the future to ensure that the balance cannot be reduced unexpectedly without notice.
-    //          An external observer can see that a withdrawal has been initiated, and will therefore
-    ///         be able to take it into account and not rely on the balance being there.
-    ///         In the case of the auction contract this allows the bidders to withdraw their
-    ///         balance, but an auctioneer will know not to accept there bids in the mean time
-    /// @param bal The balance to iniate a reduction on
-    /// @param round The round that the withdrawal will be available in. Cannot be specified as the max round
-    function initiateWithdrawal(Balance storage bal, uint64 round) internal {
-        if (bal.balance == 0) {
-            revert ZeroAmount();
-        }
-
-        if (round == type(uint64).max) {
-            // we use max round to specify that a withdrawal is not taking place
-            // so we dont allow it as a withdrawal round. In practice max round should never
-            // be reached so this isnt an issue, we just put this here as an additional
-            // safety check
-            revert WithdrawalMaxRound();
-        }
-
-        if (bal.withdrawalRound != type(uint64).max) {
-            revert WithdrawalInProgress();
-        }
-
-        bal.withdrawalRound = round;
-    }
-
-    /// @notice Finalize an already initialized withdrawal. Reduces the balance to 0.
-    ///         Can only be called two round after the withdrawal was initiated.
-    /// @param bal The balance to finalize
-    /// @param round The round to check whether withdrawal is valid in. Usually the current round. Cannot be max round.
-    function finalizeWithdrawal(Balance storage bal, uint64 round) internal returns (uint256) {
-        if (round == type(uint64).max) {
-            // we use max round to specify that a withdrawal is not taking place
-            // so we dont allow it as a withdrawal round. In practice max round should never
-            // be reached so this isnt an issue, we just put this here as an additional
-            // safety check
-            revert WithdrawalMaxRound();
-        }
-
-        uint256 withdrawableBalance = withdrawableBalanceAtRound(bal, round);
-        if (withdrawableBalance == 0) {
-            revert NothingToWithdraw();
-        }
-
-        bal.balance = 0;
-        return withdrawableBalance;
-    }
-}

package/src/express-lane-auction/Burner.sol

@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-pragma solidity ^0.8.0;
-
-import {
-    ERC20BurnableUpgradeable
-} from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol";
-import "./Errors.sol";
-
-/// @notice A simple contract that can burn any tokens that are transferred to it
-///         Token must support the ERC20BurnableUpgradeable.burn(uint256) interface
-contract Burner {
-    ERC20BurnableUpgradeable public immutable token;
-
-    constructor(address _token) {
-        if (_token == address(0)) {
-            revert ZeroAddress();
-        }
-        token = ERC20BurnableUpgradeable(_token);
-    }
-
-    /// @notice Can be called at any time by anyone to burn any tokens held by this burner
-    function burn() external {
-        token.burn(token.balanceOf(address(this)));
-    }
-}