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

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

@@ -0,0 +1,567 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.0;
+
+import "./Errors.sol";
+import {Balance, BalanceLib} from "./Balance.sol";
+import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import {AccessControlEnumerableUpgradeable} from
+    "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
+import {DelegateCallAware} from "../libraries/DelegateCallAware.sol";
+import {IExpressLaneAuction, Bid, InitArgs, Transferor} from "./IExpressLaneAuction.sol";
+import {ELCRound, LatestELCRoundsLib} from "./ELCRound.sol";
+import {RoundTimingInfo, RoundTimingInfoLib} from "./RoundTimingInfo.sol";
+import {EIP712Upgradeable} from
+    "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+
+/// @title ExpressLaneAuction
+/// @notice The express lane allows a controller to submit undelayed transactions to the sequencer
+///         The right to be the express lane controller are auctioned off in rounds, by an offchain auctioneer.
+///         The auctioneer then submits the winning bids to this control to deduct funds from the bidders and register the winner
+contract ExpressLaneAuction is
+    IExpressLaneAuction,
+    AccessControlEnumerableUpgradeable,
+    DelegateCallAware,
+    EIP712Upgradeable
+{
+    using SafeERC20 for IERC20;
+    using RoundTimingInfoLib for RoundTimingInfo;
+    using BalanceLib for Balance;
+    using ECDSA for bytes32;
+    using ECDSA for bytes;
+    using LatestELCRoundsLib for ELCRound[2];
+
+    /// @inheritdoc IExpressLaneAuction
+    bytes32 public constant AUCTIONEER_ROLE = keccak256("AUCTIONEER");
+    /// @inheritdoc IExpressLaneAuction
+    bytes32 public constant AUCTIONEER_ADMIN_ROLE = keccak256("AUCTIONEER_ADMIN");
+    /// @inheritdoc IExpressLaneAuction
+    bytes32 public constant MIN_RESERVE_SETTER_ROLE = keccak256("MIN_RESERVE_SETTER");
+    /// @inheritdoc IExpressLaneAuction
+    bytes32 public constant RESERVE_SETTER_ROLE = keccak256("RESERVE_SETTER");
+    /// @inheritdoc IExpressLaneAuction
+    bytes32 public constant RESERVE_SETTER_ADMIN_ROLE = keccak256("RESERVE_SETTER_ADMIN");
+    /// @inheritdoc IExpressLaneAuction
+    bytes32 public constant BENEFICIARY_SETTER_ROLE = keccak256("BENEFICIARY_SETTER");
+    /// @inheritdoc IExpressLaneAuction
+    bytes32 public constant ROUND_TIMING_SETTER_ROLE = keccak256("ROUND_TIMING_SETTER");
+
+    /// @notice The balances of each address
+    mapping(address => Balance) internal _balanceOf;
+
+    /// @dev Recently resolved round information. Contains the two most recently resolved rounds
+    ELCRound[2] internal latestResolvedRounds;
+
+    /// @inheritdoc IExpressLaneAuction
+    address public beneficiary;
+
+    /// @inheritdoc IExpressLaneAuction
+    IERC20 public biddingToken;
+
+    /// @inheritdoc IExpressLaneAuction
+    uint256 public reservePrice;
+
+    /// @inheritdoc IExpressLaneAuction
+    uint256 public minReservePrice;
+
+    /// @inheritdoc IExpressLaneAuction
+    RoundTimingInfo public roundTimingInfo;
+
+    /// @inheritdoc IExpressLaneAuction
+    uint256 public beneficiaryBalance;
+
+    /// @inheritdoc IExpressLaneAuction
+    mapping(address => Transferor) public transferorOf;
+
+    /// @inheritdoc IExpressLaneAuction
+    function initialize(
+        InitArgs calldata args
+    ) public initializer onlyDelegated {
+        __AccessControl_init();
+        __EIP712_init("ExpressLaneAuction", "1");
+
+        if (address(args._biddingToken) == address(0)) {
+            revert ZeroBiddingToken();
+        }
+        biddingToken = IERC20(args._biddingToken);
+
+        beneficiary = args._beneficiary;
+        emit SetBeneficiary(address(0), args._beneficiary);
+
+        minReservePrice = args._minReservePrice;
+        emit SetMinReservePrice(0, args._minReservePrice);
+
+        reservePrice = args._minReservePrice;
+        emit SetReservePrice(0, args._minReservePrice);
+
+        // the initial timestamp cannot be negative
+        if (args._roundTimingInfo.offsetTimestamp < 0) {
+            revert NegativeOffset();
+        }
+        setRoundTimingInfoInternal(args._roundTimingInfo);
+
+        // roles without a custom role admin set will have this as the admin
+        _grantRole(DEFAULT_ADMIN_ROLE, args._masterAdmin);
+        _grantRole(MIN_RESERVE_SETTER_ROLE, args._minReservePriceSetter);
+        _grantRole(BENEFICIARY_SETTER_ROLE, args._beneficiarySetter);
+
+        // the following roles are expected to be controlled by hot wallets, so we add
+        // additional custom admin role for each of them to allow for key rotation management
+        setRoleAndAdmin(
+            AUCTIONEER_ROLE, args._auctioneer, AUCTIONEER_ADMIN_ROLE, args._auctioneerAdmin
+        );
+        setRoleAndAdmin(
+            RESERVE_SETTER_ROLE,
+            args._reservePriceSetter,
+            RESERVE_SETTER_ADMIN_ROLE,
+            args._reservePriceSetterAdmin
+        );
+        _grantRole(ROUND_TIMING_SETTER_ROLE, args._roundTimingSetter);
+    }
+
+    /// @notice Set an address for a role, an admin role for the role, and an address for the admin role
+    function setRoleAndAdmin(
+        bytes32 role,
+        address roleAddr,
+        bytes32 adminRole,
+        address adminRoleAddr
+    ) internal {
+        _grantRole(role, roleAddr);
+        _grantRole(adminRole, adminRoleAddr);
+        _setRoleAdmin(role, adminRole);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function currentRound() external view returns (uint64) {
+        return roundTimingInfo.currentRound();
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function isAuctionRoundClosed() external view returns (bool) {
+        return roundTimingInfo.isAuctionRoundClosed();
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function isReserveBlackout() external view returns (bool) {
+        (ELCRound storage lastRoundResolved,) = latestResolvedRounds.latestELCRound();
+        return roundTimingInfo.isReserveBlackout(lastRoundResolved.round);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function roundTimestamps(
+        uint64 round
+    ) external view returns (uint64, uint64) {
+        return roundTimingInfo.roundTimestamps(round);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function setBeneficiary(
+        address newBeneficiary
+    ) external onlyRole(BENEFICIARY_SETTER_ROLE) {
+        emit SetBeneficiary(beneficiary, newBeneficiary);
+        beneficiary = newBeneficiary;
+    }
+
+    function _setReservePrice(
+        uint256 newReservePrice
+    ) private {
+        if (newReservePrice < minReservePrice) {
+            revert ReservePriceTooLow(newReservePrice, minReservePrice);
+        }
+
+        emit SetReservePrice(reservePrice, newReservePrice);
+        reservePrice = newReservePrice;
+    }
+
+    function setRoundTimingInfoInternal(
+        RoundTimingInfo calldata newRoundTimingInfo
+    ) internal {
+        // auction closing seconds of 0 wouldnt make sense as it would then be impossible to close the round
+        // due to the check below this also causes round duration > 0
+        if (newRoundTimingInfo.auctionClosingSeconds == 0) {
+            revert ZeroAuctionClosingSeconds();
+        }
+
+        // ensure that round duration cannot be too high, other wise this could be used to lock balances
+        // in the contract by setting round duration = uint.max
+        if (newRoundTimingInfo.roundDurationSeconds > 1 days) {
+            revert RoundTooLong(newRoundTimingInfo.roundDurationSeconds);
+        }
+
+        // the same check as in initialization - reserve submission and auction closing are non overlapping
+        // sub sections of a round, so must fit within it
+        if (
+            newRoundTimingInfo.reserveSubmissionSeconds + newRoundTimingInfo.auctionClosingSeconds
+                > newRoundTimingInfo.roundDurationSeconds
+        ) {
+            revert RoundDurationTooShort();
+        }
+
+        roundTimingInfo = newRoundTimingInfo;
+        emit SetRoundTimingInfo(
+            newRoundTimingInfo.currentRound(),
+            newRoundTimingInfo.offsetTimestamp,
+            newRoundTimingInfo.roundDurationSeconds,
+            newRoundTimingInfo.auctionClosingSeconds,
+            newRoundTimingInfo.reserveSubmissionSeconds
+        );
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function setRoundTimingInfo(
+        RoundTimingInfo calldata newRoundTimingInfo
+    ) external onlyRole(ROUND_TIMING_SETTER_ROLE) {
+        RoundTimingInfo memory currentRoundTimingInfo = roundTimingInfo;
+        uint64 currentCurrentRound = currentRoundTimingInfo.currentRound();
+        uint64 newCurrentRound = newRoundTimingInfo.currentRound();
+        // updating round timing info needs to be synchronised
+        // so we ensure that the current round won't change
+        if (currentCurrentRound != newCurrentRound) {
+            revert InvalidNewRound(currentCurrentRound, newCurrentRound);
+        }
+
+        (uint64 currentStart,) = currentRoundTimingInfo.roundTimestamps(currentCurrentRound + 1);
+        (uint64 newStart,) = newRoundTimingInfo.roundTimestamps(newCurrentRound + 1);
+        // we also ensure that the current round end time/next round start time, will not change
+        if (currentStart != newStart) {
+            revert InvalidNewStart(currentStart, newStart);
+        }
+
+        setRoundTimingInfoInternal(newRoundTimingInfo);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function setMinReservePrice(
+        uint256 newMinReservePrice
+    ) external onlyRole(MIN_RESERVE_SETTER_ROLE) {
+        emit SetMinReservePrice(minReservePrice, newMinReservePrice);
+
+        minReservePrice = newMinReservePrice;
+
+        if (newMinReservePrice > reservePrice) {
+            _setReservePrice(newMinReservePrice);
+        }
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function setReservePrice(
+        uint256 newReservePrice
+    ) external onlyRole(RESERVE_SETTER_ROLE) {
+        (ELCRound storage lastRoundResolved,) = latestResolvedRounds.latestELCRound();
+        if (roundTimingInfo.isReserveBlackout(lastRoundResolved.round)) {
+            revert ReserveBlackout();
+        }
+
+        _setReservePrice(newReservePrice);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function balanceOf(
+        address account
+    ) external view returns (uint256) {
+        return _balanceOf[account].balanceAtRound(roundTimingInfo.currentRound());
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function balanceOfAtRound(address account, uint64 round) external view returns (uint256) {
+        if (round < roundTimingInfo.currentRound()) {
+            revert RoundTooOld(round, roundTimingInfo.currentRound());
+        }
+        return _balanceOf[account].balanceAtRound(round);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function withdrawableBalance(
+        address account
+    ) external view returns (uint256) {
+        return _balanceOf[account].withdrawableBalanceAtRound(roundTimingInfo.currentRound());
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function withdrawableBalanceAtRound(
+        address account,
+        uint64 round
+    ) external view returns (uint256) {
+        if (round < roundTimingInfo.currentRound()) {
+            revert RoundTooOld(round, roundTimingInfo.currentRound());
+        }
+        return _balanceOf[account].withdrawableBalanceAtRound(round);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function deposit(
+        uint256 amount
+    ) external {
+        _balanceOf[msg.sender].increase(amount);
+        biddingToken.safeTransferFrom(msg.sender, address(this), amount);
+        emit Deposit(msg.sender, amount);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function initiateWithdrawal() external {
+        // The withdrawal can be finalized 2 rounds for now. We dont make it round + 1 in
+        // case the initiation were to occur right at the end of a round. Doing round + 2 ensures
+        // observers always have at least one full round to become aware of the future balance change.
+        uint64 withdrawalRound = roundTimingInfo.currentRound() + 2;
+        uint256 amount = _balanceOf[msg.sender].balance;
+        _balanceOf[msg.sender].initiateWithdrawal(withdrawalRound);
+        emit WithdrawalInitiated(msg.sender, amount, withdrawalRound);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function finalizeWithdrawal() external {
+        uint256 amountReduced =
+            _balanceOf[msg.sender].finalizeWithdrawal(roundTimingInfo.currentRound());
+        biddingToken.safeTransfer(msg.sender, amountReduced);
+        emit WithdrawalFinalized(msg.sender, amountReduced);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function flushBeneficiaryBalance() external {
+        uint256 bal = beneficiaryBalance;
+        if (bal == 0) {
+            revert ZeroAmount();
+        }
+        beneficiaryBalance = 0;
+        biddingToken.safeTransfer(beneficiary, bal);
+    }
+
+    /// @dev Update local state to resolve an auction
+    /// @param isMultiBid Where the auction should be resolved from multiple bids
+    /// @param firstPriceBid The winning bid
+    /// @param firstPriceBidder The winning bidder
+    /// @param priceToPay The price that needs to be paid by the winner
+    /// @param biddingInRound The round bidding is taking place in. This is not the round the bidding is taking place for, which is biddingInRound + 1
+    /// @param roundStart The timestamp at which the bidding for round starts
+    /// @param roundEnd The timestamp at which the bidding for round ends
+    function resolveAuction(
+        bool isMultiBid,
+        Bid calldata firstPriceBid,
+        address firstPriceBidder,
+        uint256 priceToPay,
+        uint64 biddingInRound,
+        uint64 roundStart,
+        uint64 roundEnd
+    ) internal {
+        // store that a round has been resolved
+        uint64 biddingForRound = biddingInRound + 1;
+        latestResolvedRounds.setResolvedRound(biddingForRound, firstPriceBid.expressLaneController);
+
+        // first price bidder pays the beneficiary
+        _balanceOf[firstPriceBidder].reduce(priceToPay, biddingInRound);
+        beneficiaryBalance += priceToPay;
+
+        // emit events so that the offchain sequencer knows a new express lane controller has been selected
+        emit SetExpressLaneController(
+            biddingForRound,
+            address(0),
+            firstPriceBid.expressLaneController,
+            address(0),
+            roundStart,
+            roundEnd
+        );
+        emit AuctionResolved(
+            isMultiBid,
+            biddingForRound,
+            firstPriceBidder,
+            firstPriceBid.expressLaneController,
+            firstPriceBid.amount,
+            priceToPay,
+            roundStart,
+            roundEnd
+        );
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function domainSeparator() external view returns (bytes32) {
+        return _domainSeparatorV4();
+    }
+
+    /// @dev Internal bid domain hash
+    bytes32 private constant BID_DOMAIN =
+        keccak256("Bid(uint64 round,address expressLaneController,uint256 amount)");
+
+    /// @inheritdoc IExpressLaneAuction
+    function getBidHash(
+        uint64 round,
+        address expressLaneController,
+        uint256 amount
+    ) public view returns (bytes32) {
+        return _hashTypedDataV4(
+            keccak256(abi.encode(BID_DOMAIN, round, expressLaneController, amount))
+        );
+    }
+
+    /// @notice Recover the signing address of the provided bid, and check that that address has enough funds to fulfil that bid
+    ///         Returns the signing address and the bid hash that was signed
+    /// @param bid The bid to recover the signing address of
+    /// @param biddingForRound The round the bid is for the control of
+    function recoverAndCheckBalance(
+        Bid memory bid,
+        uint64 biddingForRound
+    ) internal view returns (address, bytes32) {
+        bytes32 bidHash = getBidHash(biddingForRound, bid.expressLaneController, bid.amount);
+        address bidder = bidHash.recover(bid.signature);
+        // we are always bidding for in the current round for the next round
+        uint64 curRnd = biddingForRound - 1;
+        // always check that the bidder has as much as they're claiming
+        if (_balanceOf[bidder].balanceAtRound(curRnd) < bid.amount) {
+            revert InsufficientBalanceAcc(
+                bidder, bid.amount, _balanceOf[bidder].balanceAtRound(curRnd)
+            );
+        }
+
+        return (bidder, bidHash);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function resolveSingleBidAuction(
+        Bid calldata firstPriceBid
+    ) external onlyRole(AUCTIONEER_ROLE) {
+        RoundTimingInfo memory info = roundTimingInfo;
+        if (!info.isAuctionRoundClosed()) {
+            revert AuctionNotClosed();
+        }
+
+        if (firstPriceBid.amount < reservePrice) {
+            revert ReservePriceNotMet(firstPriceBid.amount, reservePrice);
+        }
+
+        uint64 biddingInRound = info.currentRound();
+        uint64 biddingForRound = biddingInRound + 1;
+        (address firstPriceBidder,) = recoverAndCheckBalance(firstPriceBid, biddingForRound);
+
+        (uint64 roundStart, uint64 roundEnd) = info.roundTimestamps(biddingForRound);
+        resolveAuction(
+            false,
+            firstPriceBid,
+            firstPriceBidder,
+            reservePrice,
+            biddingInRound,
+            roundStart,
+            roundEnd
+        );
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function resolveMultiBidAuction(
+        Bid calldata firstPriceBid,
+        Bid calldata secondPriceBid
+    ) external onlyRole(AUCTIONEER_ROLE) {
+        RoundTimingInfo memory info = roundTimingInfo;
+        if (!info.isAuctionRoundClosed()) {
+            revert AuctionNotClosed();
+        }
+
+        if (firstPriceBid.amount < secondPriceBid.amount) {
+            revert BidsWrongOrder();
+        }
+
+        // second amount must be greater than or equal the reserve
+        if (secondPriceBid.amount < reservePrice) {
+            revert ReservePriceNotMet(secondPriceBid.amount, reservePrice);
+        }
+
+        uint64 biddingInRound = info.currentRound();
+        uint64 biddingForRound = biddingInRound + 1;
+        // check the signatures and balances of both bids
+        // even the second price bid must have the balance it's claiming
+        (address firstPriceBidder, bytes32 firstBidHash) =
+            recoverAndCheckBalance(firstPriceBid, biddingForRound);
+        (address secondPriceBidder, bytes32 secondBidHash) =
+            recoverAndCheckBalance(secondPriceBid, biddingForRound);
+
+        // The bidders must be different so that our balance check isnt fooled into thinking
+        // that the same balance is valid for both the first and second bid
+        if (firstPriceBidder == secondPriceBidder) {
+            revert SameBidder();
+        }
+
+        // when bids have the same amount we break ties based on the bid hash
+        // although we include equality in the check we know this isnt possible due
+        // to the check above that ensures the first price bidder and second price bidder are different
+        if (
+            firstPriceBid.amount == secondPriceBid.amount
+                && uint256(keccak256(abi.encodePacked(firstPriceBidder, firstBidHash)))
+                    < uint256(keccak256(abi.encodePacked(secondPriceBidder, secondBidHash)))
+        ) {
+            revert TieBidsWrongOrder();
+        }
+
+        (uint64 roundStart, uint64 roundEnd) = info.roundTimestamps(biddingForRound);
+        resolveAuction(
+            true,
+            firstPriceBid,
+            firstPriceBidder,
+            secondPriceBid.amount,
+            biddingInRound,
+            roundStart,
+            roundEnd
+        );
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function setTransferor(
+        Transferor calldata transferor
+    ) external {
+        // if a transferor has already been set, it may be fixed until a future round
+        Transferor storage currentTransferor = transferorOf[msg.sender];
+        if (
+            currentTransferor.addr != address(0)
+                && currentTransferor.fixedUntilRound > roundTimingInfo.currentRound()
+        ) {
+            revert FixedTransferor(currentTransferor.fixedUntilRound);
+        }
+
+        transferorOf[msg.sender] = transferor;
+
+        emit SetTransferor(msg.sender, transferor.addr, transferor.fixedUntilRound);
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function transferExpressLaneController(
+        uint64 round,
+        address newExpressLaneController
+    ) external {
+        // past rounds cannot be transferred
+        RoundTimingInfo memory info = roundTimingInfo;
+        uint64 curRnd = info.currentRound();
+        if (round < curRnd) {
+            revert RoundTooOld(round, curRnd);
+        }
+
+        // only resolved rounds can be transferred
+        ELCRound storage resolvedRound = latestResolvedRounds.resolvedRound(round);
+
+        address resolvedELC = resolvedRound.expressLaneController;
+        address transferor = transferorOf[resolvedELC].addr;
+        // can only be the transferor if one has been set
+        // otherwise we default to the express lane controller to do the transfer
+        if (transferor != address(0)) {
+            if (transferor != msg.sender) {
+                revert NotTransferor(round, transferor, msg.sender);
+            }
+        } else if (resolvedELC != msg.sender) {
+            revert NotExpressLaneController(round, resolvedELC, msg.sender);
+        }
+
+        resolvedRound.expressLaneController = newExpressLaneController;
+
+        (uint64 start, uint64 end) = info.roundTimestamps(round);
+        emit SetExpressLaneController(
+            round,
+            resolvedELC,
+            newExpressLaneController,
+            transferor != address(0) ? transferor : resolvedELC,
+            start < uint64(block.timestamp) ? uint64(block.timestamp) : start,
+            end
+        );
+    }
+
+    /// @inheritdoc IExpressLaneAuction
+    function resolvedRounds() external view returns (ELCRound memory, ELCRound memory) {
+        return latestResolvedRounds[0].round > latestResolvedRounds[1].round
+            ? (latestResolvedRounds[0], latestResolvedRounds[1])
+            : (latestResolvedRounds[1], latestResolvedRounds[0]);
+    }
+}