Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity 0.7.6;
pragma abicoder v2;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9




import './interfaces/ITwapPair.sol';
import './interfaces/ITwapDelay.sol';
import './interfaces/IWETH.sol';
import './libraries/SafeMath.sol';
import './libraries/Orders.sol';
import './libraries/TokenShares.sol';
import './libraries/AddLiquidity.sol';
import './libraries/WithdrawHelper.sol';
import './libraries/ExecutionHelper.sol';
import './interfaces/ITwapFactoryGovernor.sol';


contract TwapDelay is ITwapDelay {
    using SafeMath for uint256;
    using Orders for Orders.Data;
    using TokenShares for TokenShares.Data;

    Orders.Data internal orders;
    TokenShares.Data internal tokenShares;

    uint256 private constant ORDER_CANCEL_TIME = 24 hours;
    uint256 private constant BOT_EXECUTION_TIME = 20 minutes;

    address public override owner;
    address public override factoryGovernor;
    address public constant RELAYER_ADDRESS = 0xd17b3c9784510E33cD5B87b490E79253BcD81e2E; 
    mapping(address => bool) public override isBot;

    constructor(address _factoryGovernor, address _bot) {
        _setOwner(msg.sender);
        _setFactoryGovernor(_factoryGovernor);
        _setBot(_bot, true);

        orders.gasPrice = tx.gasprice;
        _emitEventWithDefaults();
    }

    function getTransferGasCost(address token) external pure override returns (uint256 gasCost) {
        return Orders.getTransferGasCost(token);
    }

    function getDepositDisabled(address pair) external view override returns (bool) {
        return orders.getDepositDisabled(pair);
    }

    function getWithdrawDisabled(address pair) external view override returns (bool) {
        return orders.getWithdrawDisabled(pair);
    }

    function getBuyDisabled(address pair) external view override returns (bool) {
        return orders.getBuyDisabled(pair);
    }

    function getSellDisabled(address pair) external view override returns (bool) {
        return orders.getSellDisabled(pair);
    }

    function getOrderStatus(uint256 orderId, uint256 validAfterTimestamp)
        external
        view
        override
        returns (Orders.OrderStatus)
    {
        return orders.getOrderStatus(orderId, validAfterTimestamp);
    }

    uint256 private locked;
    modifier lock() {
        require(locked == 0, 'TD06');
        locked = 1;
        _;
        locked = 0;
    }

    function factory() external pure override returns (address) {
        return Orders.FACTORY_ADDRESS;
    }

    function totalShares(address token) external view override returns (uint256) {
        return tokenShares.totalShares[token];
    }

    // returns wrapped native currency for particular blockchain (WETH or WMATIC)
    function weth() external pure override returns (address) {
        return TokenShares.WETH_ADDRESS;
    }

    function relayer() external pure override returns (address) {
        return RELAYER_ADDRESS;
    }

    function isNonRebasingToken(address token) external pure override returns (bool) {
        return TokenShares.isNonRebasing(token);
    }

    function delay() external pure override returns (uint256) {
        return Orders.DELAY;
    }

    function lastProcessedOrderId() external view returns (uint256) {
        return orders.lastProcessedOrderId;
    }

    function newestOrderId() external view returns (uint256) {
        return orders.newestOrderId;
    }

    function isOrderCanceled(uint256 orderId) external view returns (bool) {
        return orders.canceled[orderId];
    }

    function maxGasLimit() external pure override returns (uint256) {
        return Orders.MAX_GAS_LIMIT;
    }

    function maxGasPriceImpact() external pure override returns (uint256) {
        return Orders.MAX_GAS_PRICE_IMPACT;
    }

    function gasPriceInertia() external pure override returns (uint256) {
        return Orders.GAS_PRICE_INERTIA;
    }

    function gasPrice() external view override returns (uint256) {
        return orders.gasPrice;
    }

    function setOrderTypesDisabled(
        address pair,
        Orders.OrderType[] calldata orderTypes,
        bool disabled
    ) external override {
        require(msg.sender == owner, 'TD00');
        orders.setOrderTypesDisabled(pair, orderTypes, disabled);
    }

    function setOwner(address _owner) external override {
        require(msg.sender == owner, 'TD00');
        _setOwner(_owner);
    }

    function _setOwner(address _owner) internal {
        require(_owner != owner, 'TD01');
        require(_owner != address(0), 'TD02');
        owner = _owner;
        emit OwnerSet(_owner);
    }

    function setFactoryGovernor(address _factoryGovernor) external override {
        require(msg.sender == owner, 'TD00');
        _setFactoryGovernor(_factoryGovernor);
    }

    function _setFactoryGovernor(address _factoryGovernor) internal {
        require(_factoryGovernor != factoryGovernor, 'TD01');
        require(_factoryGovernor != address(0), 'TD02');
        factoryGovernor = _factoryGovernor;
        emit FactoryGovernorSet(_factoryGovernor);
    }

    function setBot(address _bot, bool _isBot) external override {
        require(msg.sender == owner, 'TD00');
        _setBot(_bot, _isBot);
    }

    function _setBot(address _bot, bool _isBot) internal {
        require(_isBot != isBot[_bot], 'TD01');
        isBot[_bot] = _isBot;
        emit BotSet(_bot, _isBot);
    }

    function deposit(Orders.DepositParams calldata depositParams)
        external
        payable
        override
        lock
        returns (uint256 orderId)
    {
        orders.deposit(depositParams, tokenShares);
        return orders.newestOrderId;
    }

    function withdraw(Orders.WithdrawParams calldata withdrawParams)
        external
        payable
        override
        lock
        returns (uint256 orderId)
    {
        orders.withdraw(withdrawParams);
        return orders.newestOrderId;
    }

    function sell(Orders.SellParams calldata sellParams) external payable override lock returns (uint256 orderId) {
        orders.sell(sellParams, tokenShares);
        return orders.newestOrderId;
    }

    function relayerSell(Orders.SellParams calldata sellParams)
        external
        payable
        override
        lock
        returns (uint256 orderId)
    {
        require(msg.sender == RELAYER_ADDRESS, 'TD00');
        orders.relayerSell(sellParams, tokenShares);
        return orders.newestOrderId;
    }

    function buy(Orders.BuyParams calldata buyParams) external payable override lock returns (uint256 orderId) {
        orders.buy(buyParams, tokenShares);
        return orders.newestOrderId;
    }

    /// @dev This implementation processes orders sequentially and skips orders that have already been executed.
    /// If it encounters an order that is not yet valid, it stops execution since subsequent orders will also be invalid
    /// at the time.
    function execute(Orders.Order[] calldata _orders) external payable override lock {
        uint256 ordersLength = _orders.length;
        uint256 gasBefore = gasleft();
        bool orderExecuted;
        bool senderCanExecute = isBot[msg.sender] || isBot[address(0)];
        for (uint256 i; i < ordersLength; ++i) {
            if (_orders[i].orderId <= orders.lastProcessedOrderId) {
                continue;
            }
            if (orders.canceled[_orders[i].orderId]) {
                orders.dequeueOrder(_orders[i].orderId);
                continue;
            }
            orders.verifyOrder(_orders[i]);
            uint256 validAfterTimestamp = _orders[i].validAfterTimestamp;
            if (validAfterTimestamp >= block.timestamp) {
                break;
            }
            require(senderCanExecute || block.timestamp >= validAfterTimestamp + BOT_EXECUTION_TIME, 'TD00');
            orderExecuted = true;
            if (_orders[i].orderType == Orders.OrderType.Deposit) {
                executeDeposit(_orders[i]);
            } else if (_orders[i].orderType == Orders.OrderType.Withdraw) {
                executeWithdraw(_orders[i]);
            } else if (_orders[i].orderType == Orders.OrderType.Sell) {
                executeSell(_orders[i]);
            } else if (_orders[i].orderType == Orders.OrderType.Buy) {
                executeBuy(_orders[i]);
            }
        }
        if (orderExecuted) {
            orders.updateGasPrice(gasBefore.sub(gasleft()));
        }
    }

    /// @dev The `order` must be verified by calling `Orders.verifyOrder` before calling this function.
    function executeDeposit(Orders.Order calldata order) internal {
        uint256 gasStart = gasleft();
        orders.dequeueOrder(order.orderId);

        (bool executionSuccess, bytes memory data) = address(this).call{
            gas: order.gasLimit.sub(
                Orders.ORDER_BASE_COST.add(Orders.getTransferGasCost(order.token0)).add(
                    Orders.getTransferGasCost(order.token1)
                )
            )
        }(abi.encodeWithSelector(this._executeDeposit.selector, order));

        bool refundSuccess = true;
        if (!executionSuccess) {
            refundSuccess = refundTokens(
                order.to,
                order.token0,
                order.value0,
                order.token1,
                order.value1,
                order.unwrap
            );
        }
        finalizeOrder(refundSuccess);
        (uint256 gasUsed, uint256 ethRefund) = refund(order.gasLimit, order.gasPrice, gasStart, order.to);
        emit OrderExecuted(orders.lastProcessedOrderId, executionSuccess, data, gasUsed, ethRefund);
    }

    /// @dev The `order` must be verified by calling `Orders.verifyOrder` before calling this function.
    function executeWithdraw(Orders.Order calldata order) internal {
        uint256 gasStart = gasleft();
        orders.dequeueOrder(order.orderId);

        (bool executionSuccess, bytes memory data) = address(this).call{
            gas: order.gasLimit.sub(Orders.ORDER_BASE_COST.add(Orders.PAIR_TRANSFER_COST))
        }(abi.encodeWithSelector(this._executeWithdraw.selector, order));

        bool refundSuccess = true;
        if (!executionSuccess) {
            (address pair, ) = Orders.getPair(order.token0, order.token1);
            refundSuccess = Orders.refundLiquidity(pair, order.to, order.liquidity, this._refundLiquidity.selector);
        }
        finalizeOrder(refundSuccess);
        (uint256 gasUsed, uint256 ethRefund) = refund(order.gasLimit, order.gasPrice, gasStart, order.to);
        emit OrderExecuted(orders.lastProcessedOrderId, executionSuccess, data, gasUsed, ethRefund);
    }

    /// @dev The `order` must be verified by calling `Orders.verifyOrder` before calling this function.
    function executeSell(Orders.Order calldata order) internal {
        uint256 gasStart = gasleft();
        orders.dequeueOrder(order.orderId);

        (bool executionSuccess, bytes memory data) = address(this).call{
            gas: order.gasLimit.sub(Orders.ORDER_BASE_COST.add(Orders.getTransferGasCost(order.token0)))
        }(abi.encodeWithSelector(this._executeSell.selector, order));

        bool refundSuccess = true;
        if (!executionSuccess) {
            refundSuccess = refundToken(order.token0, order.to, order.value0, order.unwrap);
        }
        finalizeOrder(refundSuccess);
        (uint256 gasUsed, uint256 ethRefund) = refund(order.gasLimit, order.gasPrice, gasStart, order.to);
        emit OrderExecuted(orders.lastProcessedOrderId, executionSuccess, data, gasUsed, ethRefund);
    }

    /// @dev The `order` must be verified by calling `Orders.verifyOrder` before calling this function.
    function executeBuy(Orders.Order calldata order) internal {
        uint256 gasStart = gasleft();
        orders.dequeueOrder(order.orderId);

        (bool executionSuccess, bytes memory data) = address(this).call{
            gas: order.gasLimit.sub(Orders.ORDER_BASE_COST.add(Orders.getTransferGasCost(order.token0)))
        }(abi.encodeWithSelector(this._executeBuy.selector, order));

        bool refundSuccess = true;
        if (!executionSuccess) {
            refundSuccess = refundToken(order.token0, order.to, order.value0, order.unwrap);
        }
        finalizeOrder(refundSuccess);
        (uint256 gasUsed, uint256 ethRefund) = refund(order.gasLimit, order.gasPrice, gasStart, order.to);
        emit OrderExecuted(orders.lastProcessedOrderId, executionSuccess, data, gasUsed, ethRefund);
    }

    function finalizeOrder(bool refundSuccess) private {
        if (!refundSuccess) {
            orders.markRefundFailed();
        } else {
            orders.forgetLastProcessedOrder();
        }
    }

    function refund(
        uint256 gasLimit,
        uint256 gasPriceInOrder,
        uint256 gasStart,
        address to
    ) private returns (uint256 gasUsed, uint256 leftOver) {
        uint256 feeCollected = gasLimit.mul(gasPriceInOrder);
        gasUsed = gasStart.sub(gasleft()).add(Orders.REFUND_BASE_COST);
        uint256 actualRefund = Math.min(feeCollected, gasUsed.mul(orders.gasPrice));
        leftOver = feeCollected.sub(actualRefund);
        require(refundEth(msg.sender, actualRefund), 'TD40');
        refundEth(payable(to), leftOver);
    }

    function refundEth(address payable to, uint256 value) internal returns (bool success) {
        if (value == 0) {
            return true;
        }
        success = TransferHelper.transferETH(to, value, Orders.getTransferGasCost(Orders.NATIVE_CURRENCY_SENTINEL));
        emit EthRefund(to, success, value);
    }

    function refundToken(
        address token,
        address to,
        uint256 share,
        bool unwrap
    ) private returns (bool) {
        if (share == 0) {
            return true;
        }
        (bool success, bytes memory data) = address(this).call{ gas: Orders.getTransferGasCost(token) }(
            abi.encodeWithSelector(this._refundToken.selector, token, to, share, unwrap)
        );
        if (!success) {
            emit Orders.RefundFailed(to, token, share, data);
        }
        return success;
    }

    function refundTokens(
        address to,
        address token0,
        uint256 share0,
        address token1,
        uint256 share1,
        bool unwrap
    ) private returns (bool) {
        (bool success, bytes memory data) = address(this).call{
            gas: Orders.getTransferGasCost(token0).add(Orders.getTransferGasCost(token1))
        }(abi.encodeWithSelector(this._refundTokens.selector, to, token0, share0, token1, share1, unwrap));
        if (!success) {
            emit Orders.RefundFailed(to, token0, share0, data);
            emit Orders.RefundFailed(to, token1, share1, data);
        }
        return success;
    }

    function _refundTokens(
        address to,
        address token0,
        uint256 share0,
        address token1,
        uint256 share1,
        bool unwrap
    ) external payable {
        // no need to check sender, because it is checked in _refundToken
        _refundToken(token0, to, share0, unwrap);
        _refundToken(token1, to, share1, unwrap);
    }

    function _refundToken(
        address token,
        address to,
        uint256 share,
        bool unwrap
    ) public payable {
        require(msg.sender == address(this), 'TD00');
        if (token == TokenShares.WETH_ADDRESS && unwrap) {
            uint256 amount = tokenShares.sharesToAmount(token, share, 0, to);
            IWETH(TokenShares.WETH_ADDRESS).withdraw(amount);
            TransferHelper.safeTransferETH(to, amount, Orders.getTransferGasCost(Orders.NATIVE_CURRENCY_SENTINEL));
        } else {
            TransferHelper.safeTransfer(token, to, tokenShares.sharesToAmount(token, share, 0, to));
        }
    }

    function _refundLiquidity(
        address pair,
        address to,
        uint256 liquidity
    ) external payable {
        require(msg.sender == address(this), 'TD00');
        return TransferHelper.safeTransfer(pair, to, liquidity);
    }

    function _executeDeposit(Orders.Order calldata order) external payable {
        require(msg.sender == address(this), 'TD00');

        (address pairAddress, ) = Orders.getPair(order.token0, order.token1);

        ITwapPair(pairAddress).sync();
        ITwapFactoryGovernor(factoryGovernor).distributeFees(order.token0, order.token1, pairAddress);
        ITwapPair(pairAddress).sync();
        ExecutionHelper.executeDeposit(order, pairAddress, getTolerance(pairAddress), tokenShares);
    }

    function _executeWithdraw(Orders.Order calldata order) external payable {
        require(msg.sender == address(this), 'TD00');

        (address pairAddress, ) = Orders.getPair(order.token0, order.token1);

        ITwapPair(pairAddress).sync();
        ITwapFactoryGovernor(factoryGovernor).distributeFees(order.token0, order.token1, pairAddress);
        ITwapPair(pairAddress).sync();
        ExecutionHelper.executeWithdraw(order);
    }

    function _executeBuy(Orders.Order calldata order) external payable {
        require(msg.sender == address(this), 'TD00');

        (address pairAddress, ) = Orders.getPair(order.token0, order.token1);
        ExecutionHelper.ExecuteBuySellParams memory orderParams;
        orderParams.order = order;
        orderParams.pairAddress = pairAddress;
        orderParams.pairTolerance = getTolerance(pairAddress);

        ITwapPair(pairAddress).sync();
        ExecutionHelper.executeBuy(orderParams, tokenShares);
    }

    function _executeSell(Orders.Order calldata order) external payable {
        require(msg.sender == address(this), 'TD00');

        (address pairAddress, ) = Orders.getPair(order.token0, order.token1);
        ExecutionHelper.ExecuteBuySellParams memory orderParams;
        orderParams.order = order;
        orderParams.pairAddress = pairAddress;
        orderParams.pairTolerance = getTolerance(pairAddress);

        ITwapPair(pairAddress).sync();
        ExecutionHelper.executeSell(orderParams, tokenShares);
    }

    /// @dev The `order` must be verified by calling `Orders.verifyOrder` before calling this function.
    function performRefund(Orders.Order calldata order, bool shouldRefundEth) internal {
        bool canOwnerRefund = order.validAfterTimestamp.add(365 days) < block.timestamp;

        if (order.orderType == Orders.OrderType.Deposit) {
            address to = canOwnerRefund ? owner : order.to;
            require(refundTokens(to, order.token0, order.value0, order.token1, order.value1, order.unwrap), 'TD14');
            if (shouldRefundEth) {
                require(refundEth(payable(to), order.gasPrice.mul(order.gasLimit)), 'TD40');
            }
        } else if (order.orderType == Orders.OrderType.Withdraw) {
            (address pair, ) = Orders.getPair(order.token0, order.token1);
            address to = canOwnerRefund ? owner : order.to;
            require(Orders.refundLiquidity(pair, to, order.liquidity, this._refundLiquidity.selector), 'TD14');
            if (shouldRefundEth) {
                require(refundEth(payable(to), order.gasPrice.mul(order.gasLimit)), 'TD40');
            }
        } else if (order.orderType == Orders.OrderType.Sell) {
            address to = canOwnerRefund ? owner : order.to;
            require(refundToken(order.token0, to, order.value0, order.unwrap), 'TD14');
            if (shouldRefundEth) {
                require(refundEth(payable(to), order.gasPrice.mul(order.gasLimit)), 'TD40');
            }
        } else if (order.orderType == Orders.OrderType.Buy) {
            address to = canOwnerRefund ? owner : order.to;
            require(refundToken(order.token0, to, order.value0, order.unwrap), 'TD14');
            if (shouldRefundEth) {
                require(refundEth(payable(to), order.gasPrice.mul(order.gasLimit)), 'TD40');
            }
        } else {
            return;
        }
        orders.forgetOrder(order.orderId);
    }

    function retryRefund(Orders.Order calldata order) external override lock {
        orders.verifyOrder(order);
        require(orders.refundFailed[order.orderId], 'TD21');
        performRefund(order, false);
    }

    function cancelOrder(Orders.Order calldata order) external override lock {
        orders.verifyOrder(order);
        require(
            orders.getOrderStatus(order.orderId, order.validAfterTimestamp) == Orders.OrderStatus.EnqueuedReady,
            'TD52'
        );
        require(order.validAfterTimestamp.sub(Orders.DELAY).add(ORDER_CANCEL_TIME) < block.timestamp, 'TD1C');
        orders.canceled[order.orderId] = true;
        performRefund(order, true);
    }

    function syncPair(address token0, address token1) external override returns (address pairAddress) {
        require(msg.sender == factoryGovernor, 'TD00');

        (pairAddress, ) = Orders.getPair(token0, token1);
        ITwapPair(pairAddress).sync();
    }

    
    function _emitEventWithDefaults() internal {
        emit MaxGasLimitSet(Orders.MAX_GAS_LIMIT);
        emit GasPriceInertiaSet(Orders.GAS_PRICE_INERTIA);
        emit MaxGasPriceImpactSet(Orders.MAX_GAS_PRICE_IMPACT);
        emit DelaySet(Orders.DELAY);
        emit RelayerSet(RELAYER_ADDRESS);

        emit ToleranceSet(0x2fe16Dd18bba26e457B7dD2080d5674312b026a2, 0);
        emit ToleranceSet(0x048f0e7ea2CFD522a4a058D1b1bDd574A0486c46, 0);
        emit ToleranceSet(0x37F6dF71b40c50b2038329CaBf5FDa3682Df1ebF, 0);
        emit ToleranceSet(0x6ec472b613012a492693697FA551420E60567eA7, 0);
        emit ToleranceSet(0x43f0E5f2304F261DfA5359a0b74Ff030E498D904, 0);
        emit ToleranceSet(0xD66f214fB49f81Ac5610e0339A351D7e1c67c35e, 0);
        emit ToleranceSet(0xD4d2140eD70DCF8794A986F0CFD07560ee738C71, 4);

        emit TransferGasCostSet(Orders.NATIVE_CURRENCY_SENTINEL, Orders.ETHER_TRANSFER_CALL_COST);
        emit TransferGasCostSet(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, 60000);
        emit TransferGasCostSet(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48, 70000);
        emit TransferGasCostSet(0xdAC17F958D2ee523a2206206994597C13D831ec7, 60000);
        emit TransferGasCostSet(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599, 60000);
        emit TransferGasCostSet(0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B, 60000);
        emit TransferGasCostSet(0x6B3595068778DD592e39A122f4f5a5cF09C90fE2, 60000);

        emit NonRebasingTokenSet(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, true);
        emit NonRebasingTokenSet(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48, true);
        emit NonRebasingTokenSet(0xdAC17F958D2ee523a2206206994597C13D831ec7, true);
        emit NonRebasingTokenSet(0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599, true);
        emit NonRebasingTokenSet(0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B, false);
        emit NonRebasingTokenSet(0x6B3595068778DD592e39A122f4f5a5cF09C90fE2, false);
    }

    
    // constant mapping for tolerance
    function getTolerance(address pair) public virtual view override returns (uint16 tolerance) {
        if (pair == 0xD4d2140eD70DCF8794A986F0CFD07560ee738C71) return 4;
        return 0;
    }

    receive() external payable {}
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



interface IReserves {
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1);

    function getFees() external view returns (uint256 fee0, uint256 fee1);
}

pragma solidity 0.7.6;
pragma abicoder v2;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9




import '../libraries/Orders.sol';

interface ITwapDelay {
    event OrderExecuted(uint256 indexed id, bool indexed success, bytes data, uint256 gasSpent, uint256 ethRefunded);
    event EthRefund(address indexed to, bool indexed success, uint256 value);
    event OwnerSet(address owner);
    event FactoryGovernorSet(address factoryGovernor);
    event BotSet(address bot, bool isBot);
    event DelaySet(uint256 delay);
    event RelayerSet(address relayer);
    event MaxGasLimitSet(uint256 maxGasLimit);
    event GasPriceInertiaSet(uint256 gasPriceInertia);
    event MaxGasPriceImpactSet(uint256 maxGasPriceImpact);
    event TransferGasCostSet(address token, uint256 gasCost);
    event ToleranceSet(address pair, uint16 amount);
    event NonRebasingTokenSet(address token, bool isNonRebasing);

    function factory() external view returns (address);

    function factoryGovernor() external view returns (address);

    function relayer() external view returns (address);

    function owner() external view returns (address);

    function isBot(address bot) external view returns (bool);

    function getTolerance(address pair) external view returns (uint16);

    function isNonRebasingToken(address token) external view returns (bool);

    function gasPriceInertia() external view returns (uint256);

    function gasPrice() external view returns (uint256);

    function maxGasPriceImpact() external view returns (uint256);

    function maxGasLimit() external view returns (uint256);

    function delay() external view returns (uint256);

    function totalShares(address token) external view returns (uint256);

    function weth() external view returns (address);

    function getTransferGasCost(address token) external pure returns (uint256);

    function getDepositDisabled(address pair) external view returns (bool);

    function getWithdrawDisabled(address pair) external view returns (bool);

    function getBuyDisabled(address pair) external view returns (bool);

    function getSellDisabled(address pair) external view returns (bool);

    function getOrderStatus(uint256 orderId, uint256 validAfterTimestamp) external view returns (Orders.OrderStatus);

    function setOrderTypesDisabled(
        address pair,
        Orders.OrderType[] calldata orderTypes,
        bool disabled
    ) external;

    function setOwner(address _owner) external;

    function setFactoryGovernor(address _factoryGovernor) external;

    function setBot(address _bot, bool _isBot) external;

    function deposit(Orders.DepositParams memory depositParams) external payable returns (uint256 orderId);

    function withdraw(Orders.WithdrawParams memory withdrawParams) external payable returns (uint256 orderId);

    function sell(Orders.SellParams memory sellParams) external payable returns (uint256 orderId);

    function relayerSell(Orders.SellParams memory sellParams) external payable returns (uint256 orderId);

    function buy(Orders.BuyParams memory buyParams) external payable returns (uint256 orderId);

    function execute(Orders.Order[] calldata orders) external payable;

    function retryRefund(Orders.Order calldata order) external;

    function cancelOrder(Orders.Order calldata order) external;

    function syncPair(address token0, address token1) external returns (address pairAddress);
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



import './IERC20.sol';

interface ITwapERC20 is IERC20 {
    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);

    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



interface ITwapFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
    event OwnerSet(address owner);

    function owner() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(
        address tokenA,
        address tokenB,
        address oracle,
        address trader
    ) external returns (address pair);

    function setOwner(address) external;

    function setMintFee(
        address tokenA,
        address tokenB,
        uint256 fee
    ) external;

    function setBurnFee(
        address tokenA,
        address tokenB,
        uint256 fee
    ) external;

    function setSwapFee(
        address tokenA,
        address tokenB,
        uint256 fee
    ) external;

    function setOracle(
        address tokenA,
        address tokenB,
        address oracle
    ) external;

    function setTrader(
        address tokenA,
        address tokenB,
        address trader
    ) external;

    function collect(
        address tokenA,
        address tokenB,
        address to
    ) external;

    function withdraw(
        address tokenA,
        address tokenB,
        uint256 amount,
        address to
    ) external;
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



interface ITwapFactoryGovernor {
    event FactorySet(address factory);
    event DelaySet(address delay);
    event ProtocolFeeRatioSet(uint256 protocolFeeRatio);
    event EthTransferCostSet(uint256 ethTransferCost);
    event FeeDistributed(address indexed token, address indexed pair, uint256 lpAmount, uint256 protocolAmount);
    event OwnerSet(address owner);
    event WithdrawToken(address token, address to, uint256 amount);

    function owner() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function factory() external view returns (address);

    function delay() external view returns (address);

    function protocolFeeRatio() external view returns (uint256);

    function ethTransferCost() external view returns (uint256);

    function setFactoryOwner(address) external;

    function setFactory(address) external;

    function setOwner(address) external;

    function setMintFee(
        address tokenA,
        address tokenB,
        uint256 fee
    ) external;

    function setBurnFee(
        address tokenA,
        address tokenB,
        uint256 fee
    ) external;

    function setSwapFee(
        address tokenA,
        address tokenB,
        uint256 fee
    ) external;

    function setOracle(
        address tokenA,
        address tokenB,
        address oracle
    ) external;

    function setTrader(
        address tokenA,
        address tokenB,
        address trader
    ) external;

    function setDelay(address) external;

    function setProtocolFeeRatio(uint256 _protocolFeeRatio) external;

    function setEthTransferCost(uint256 _ethTransferCost) external;

    function createPair(
        address tokenA,
        address tokenB,
        address oracle,
        address trader
    ) external returns (address pair);

    function collectFees(
        address tokenA,
        address tokenB,
        address to
    ) external;

    function withdrawLiquidity(
        address tokenA,
        address tokenB,
        uint256 amount,
        address to
    ) external;

    function withdrawToken(
        address token,
        uint256 amount,
        address to
    ) external;

    function distributeFees(address tokenA, address tokenB) external;

    function distributeFees(
        address tokenA,
        address tokenB,
        address pairAddress
    ) external;

    function feesToDistribute(address tokenA, address tokenB)
        external
        view
        returns (uint256 fee0ToDistribute, uint256 fee1ToDistribute);
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



interface ITwapOracle {
    event OwnerSet(address owner);
    event UniswapPairSet(address uniswapPair);

    function decimalsConverter() external view returns (int256);

    function xDecimals() external view returns (uint8);

    function yDecimals() external view returns (uint8);

    function owner() external view returns (address);

    function uniswapPair() external view returns (address);

    function getPriceInfo() external view returns (uint256 priceAccumulator, uint256 priceTimestamp);

    function getSpotPrice() external view returns (uint256);

    function getAveragePrice(uint256 priceAccumulator, uint256 priceTimestamp) external view returns (uint256);

    function setOwner(address _owner) external;

    function setUniswapPair(address _uniswapPair) external;

    function tradeX(
        uint256 xAfter,
        uint256 xBefore,
        uint256 yBefore,
        bytes calldata data
    ) external view returns (uint256 yAfter);

    function tradeY(
        uint256 yAfter,
        uint256 yBefore,
        uint256 xBefore,
        bytes calldata data
    ) external view returns (uint256 xAfter);

    function depositTradeXIn(
        uint256 xLeft,
        uint256 xBefore,
        uint256 yBefore,
        bytes calldata data
    ) external view returns (uint256 xIn);

    function depositTradeYIn(
        uint256 yLeft,
        uint256 yBefore,
        uint256 xBefore,
        bytes calldata data
    ) external view returns (uint256 yIn);

    function getSwapAmount0Out(
        uint256 swapFee,
        uint256 amount1In,
        bytes calldata data
    ) external view returns (uint256 amount0Out);

    function getSwapAmount1Out(
        uint256 swapFee,
        uint256 amount0In,
        bytes calldata data
    ) external view returns (uint256 amount1Out);

    function getSwapAmountInMaxOut(
        bool inverse,
        uint256 swapFee,
        uint256 _amountOut,
        bytes calldata data
    ) external view returns (uint256 amountIn, uint256 amountOut);

    function getSwapAmountInMinOut(
        bool inverse,
        uint256 swapFee,
        uint256 _amountOut,
        bytes calldata data
    ) external view returns (uint256 amountIn, uint256 amountOut);
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



import './ITwapERC20.sol';
import './IReserves.sol';

interface ITwapPair is ITwapERC20, IReserves {
    event Mint(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 liquidityOut, address indexed to);
    event Burn(address indexed sender, uint256 amount0Out, uint256 amount1Out, uint256 liquidityIn, address indexed to);
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event SetMintFee(uint256 fee);
    event SetBurnFee(uint256 fee);
    event SetSwapFee(uint256 fee);
    event SetOracle(address account);
    event SetTrader(address trader);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function oracle() external view returns (address);

    function trader() external view returns (address);

    function mintFee() external view returns (uint256);

    function setMintFee(uint256 fee) external;

    function mint(address to) external returns (uint256 liquidity);

    function burnFee() external view returns (uint256);

    function setBurnFee(uint256 fee) external;

    function burn(address to) external returns (uint256 amount0, uint256 amount1);

    function swapFee() external view returns (uint256);

    function setSwapFee(uint256 fee) external;

    function setOracle(address account) external;

    function setTrader(address account) external;

    function collect(address to) external;

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function sync() external;

    function initialize(
        address _token0,
        address _token1,
        address _oracle,
        address _trader
    ) external;

    function getSwapAmount0In(uint256 amount1Out, bytes calldata data) external view returns (uint256 swapAmount0In);

    function getSwapAmount1In(uint256 amount0Out, bytes calldata data) external view returns (uint256 swapAmount1In);

    function getSwapAmount0Out(uint256 amount1In, bytes calldata data) external view returns (uint256 swapAmount0Out);

    function getSwapAmount1Out(uint256 amount0In, bytes calldata data) external view returns (uint256 swapAmount1Out);

    function getDepositAmount0In(uint256 amount0, bytes calldata data) external view returns (uint256 depositAmount0In);

    function getDepositAmount1In(uint256 amount1, bytes calldata data) external view returns (uint256 depositAmount1In);
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



interface IWETH {
    function deposit() external payable;

    function transfer(address to, uint256 value) external returns (bool);

    function withdraw(uint256) external;
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



import './TransferHelper.sol';
import './SafeMath.sol';
import './Math.sol';
import '../interfaces/ITwapPair.sol';
import '../interfaces/ITwapOracle.sol';

library AddLiquidity {
    using SafeMath for uint256;

    function addLiquidity(
        address pair,
        uint256 amount0Desired,
        uint256 amount1Desired
    )
        internal
        view
        returns (
            uint256 amount0,
            uint256 amount1,
            uint256 swapToken
        )
    {
        if (amount0Desired == 0 || amount1Desired == 0) {
            if (amount0Desired > 0) {
                swapToken = 1;
            } else if (amount1Desired > 0) {
                swapToken = 2;
            }
            return (0, 0, swapToken);
        }
        (uint256 reserve0, uint256 reserve1) = ITwapPair(pair).getReserves();
        if (reserve0 == 0 && reserve1 == 0) {
            (amount0, amount1) = (amount0Desired, amount1Desired);
        } else {
            require(reserve0 > 0 && reserve1 > 0, 'AL07');
            uint256 amount1Optimal = amount0Desired.mul(reserve1) / reserve0;
            if (amount1Optimal <= amount1Desired) {
                swapToken = 2;
                (amount0, amount1) = (amount0Desired, amount1Optimal);
            } else {
                uint256 amount0Optimal = amount1Desired.mul(reserve0) / reserve1;
                assert(amount0Optimal <= amount0Desired);
                swapToken = 1;
                (amount0, amount1) = (amount0Optimal, amount1Desired);
            }

            uint256 totalSupply = ITwapPair(pair).totalSupply();
            uint256 liquidityOut = Math.min(amount0.mul(totalSupply) / reserve0, amount1.mul(totalSupply) / reserve1);
            if (liquidityOut == 0) {
                amount0 = 0;
                amount1 = 0;
            }
        }
    }

    function addLiquidityAndMint(
        address pair,
        address to,
        address token0,
        address token1,
        uint256 amount0Desired,
        uint256 amount1Desired
    )
        external
        returns (
            uint256 amount0Left,
            uint256 amount1Left,
            uint256 swapToken
        )
    {
        uint256 amount0;
        uint256 amount1;
        (amount0, amount1, swapToken) = addLiquidity(pair, amount0Desired, amount1Desired);
        if (amount0 == 0 || amount1 == 0) {
            return (amount0Desired, amount1Desired, swapToken);
        }
        TransferHelper.safeTransfer(token0, pair, amount0);
        TransferHelper.safeTransfer(token1, pair, amount1);
        ITwapPair(pair).mint(to);

        amount0Left = amount0Desired.sub(amount0);
        amount1Left = amount1Desired.sub(amount1);
    }

    function swapDeposit0(
        address pair,
        address token0,
        uint256 amount0,
        uint256 minSwapPrice,
        uint16 tolerance,
        bytes calldata data
    ) external returns (uint256 amount0Left, uint256 amount1Left) {
        uint256 amount0In = ITwapPair(pair).getDepositAmount0In(amount0, data);
        amount1Left = ITwapPair(pair).getSwapAmount1Out(amount0In, data).sub(tolerance);
        if (amount1Left == 0) {
            return (amount0, amount1Left);
        }
        uint256 price = getPrice(amount0In, amount1Left, pair);
        require(minSwapPrice == 0 || price >= minSwapPrice, 'AL15');
        TransferHelper.safeTransfer(token0, pair, amount0In);
        ITwapPair(pair).swap(0, amount1Left, address(this), data);
        amount0Left = amount0.sub(amount0In);
    }

    function swapDeposit1(
        address pair,
        address token1,
        uint256 amount1,
        uint256 maxSwapPrice,
        uint16 tolerance,
        bytes calldata data
    ) external returns (uint256 amount0Left, uint256 amount1Left) {
        uint256 amount1In = ITwapPair(pair).getDepositAmount1In(amount1, data);
        amount0Left = ITwapPair(pair).getSwapAmount0Out(amount1In, data).sub(tolerance);
        if (amount0Left == 0) {
            return (amount0Left, amount1);
        }
        uint256 price = getPrice(amount0Left, amount1In, pair);
        require(maxSwapPrice == 0 || price <= maxSwapPrice, 'AL16');
        TransferHelper.safeTransfer(token1, pair, amount1In);
        ITwapPair(pair).swap(amount0Left, 0, address(this), data);
        amount1Left = amount1.sub(amount1In);
    }

    function getPrice(
        uint256 amount0,
        uint256 amount1,
        address pair
    ) internal view returns (uint256) {
        ITwapOracle oracle = ITwapOracle(ITwapPair(pair).oracle());
        return amount1.mul(uint256(oracle.decimalsConverter())).div(amount0);
    }

    function _refundDeposit(
        address to,
        address token0,
        address token1,
        uint256 amount0,
        uint256 amount1
    ) internal {
        if (amount0 > 0) {
            TransferHelper.safeTransfer(token0, to, amount0);
        }
        if (amount1 > 0) {
            TransferHelper.safeTransfer(token1, to, amount1);
        }
    }
}

pragma solidity 0.7.6;
pragma abicoder v2;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9




import '../interfaces/ITwapOracle.sol';
import '../interfaces/ITwapPair.sol';
import '../interfaces/IWETH.sol';
import '../libraries/SafeMath.sol';
import '../libraries/Orders.sol';
import '../libraries/TokenShares.sol';
import '../libraries/AddLiquidity.sol';
import '../libraries/WithdrawHelper.sol';

library ExecutionHelper {
    using SafeMath for uint256;
    using TransferHelper for address;

    using Orders for Orders.Data;
    using TokenShares for TokenShares.Data;

    uint256 private constant ORDER_LIFESPAN = 48 hours;

    struct ExecuteBuySellParams {
        Orders.Order order;
        address pairAddress;
        uint16 pairTolerance;
    }

    function executeDeposit(
        Orders.Order calldata order,
        address pairAddress,
        uint16 pairTolerance,
        TokenShares.Data storage tokenShares
    ) external {
        require(order.validAfterTimestamp + ORDER_LIFESPAN >= block.timestamp, 'EH04');

        (uint256 amount0Left, uint256 amount1Left, uint256 swapToken) = _initialDeposit(
            order,
            pairAddress,
            tokenShares
        );

        if (order.swap && swapToken != 0) {
            bytes memory data = encodePriceInfo(pairAddress, order.priceAccumulator, order.timestamp);
            if (amount0Left != 0 && swapToken == 1) {
                uint256 extraAmount1;
                (amount0Left, extraAmount1) = AddLiquidity.swapDeposit0(
                    pairAddress,
                    order.token0,
                    amount0Left,
                    order.minSwapPrice,
                    pairTolerance,
                    data
                );
                amount1Left = amount1Left.add(extraAmount1);
            } else if (amount1Left != 0 && swapToken == 2) {
                uint256 extraAmount0;
                (extraAmount0, amount1Left) = AddLiquidity.swapDeposit1(
                    pairAddress,
                    order.token1,
                    amount1Left,
                    order.maxSwapPrice,
                    pairTolerance,
                    data
                );
                amount0Left = amount0Left.add(extraAmount0);
            }
        }

        if (amount0Left != 0 && amount1Left != 0) {
            (amount0Left, amount1Left, ) = AddLiquidity.addLiquidityAndMint(
                pairAddress,
                order.to,
                order.token0,
                order.token1,
                amount0Left,
                amount1Left
            );
        }

        AddLiquidity._refundDeposit(order.to, order.token0, order.token1, amount0Left, amount1Left);
    }

    function _initialDeposit(
        Orders.Order calldata order,
        address pairAddress,
        TokenShares.Data storage tokenShares
    )
        private
        returns (
            uint256 amount0Left,
            uint256 amount1Left,
            uint256 swapToken
        )
    {
        uint256 amount0Desired = tokenShares.sharesToAmount(order.token0, order.value0, order.amountLimit0, order.to);
        uint256 amount1Desired = tokenShares.sharesToAmount(order.token1, order.value1, order.amountLimit1, order.to);
        (amount0Left, amount1Left, swapToken) = AddLiquidity.addLiquidityAndMint(
            pairAddress,
            order.to,
            order.token0,
            order.token1,
            amount0Desired,
            amount1Desired
        );
    }

    function executeWithdraw(Orders.Order calldata order) external {
        require(order.validAfterTimestamp + ORDER_LIFESPAN >= block.timestamp, 'EH04');
        (address pairAddress, ) = Orders.getPair(order.token0, order.token1);
        TransferHelper.safeTransfer(pairAddress, pairAddress, order.liquidity);
        uint256 wethAmount;
        uint256 amount0;
        uint256 amount1;
        if (order.unwrap && (order.token0 == TokenShares.WETH_ADDRESS || order.token1 == TokenShares.WETH_ADDRESS)) {
            bool success;
            (success, wethAmount, amount0, amount1) = WithdrawHelper.withdrawAndUnwrap(
                order.token0,
                order.token1,
                pairAddress,
                TokenShares.WETH_ADDRESS,
                order.to,
                Orders.getTransferGasCost(Orders.NATIVE_CURRENCY_SENTINEL)
            );
            if (!success) {
                TokenShares.onUnwrapFailed(order.to, wethAmount);
            }
        } else {
            (amount0, amount1) = ITwapPair(pairAddress).burn(order.to);
        }
        require(amount0 >= order.value0 && amount1 >= order.value1, 'EH03');
    }

    function executeBuy(ExecuteBuySellParams memory orderParams, TokenShares.Data storage tokenShares) external {
        require(orderParams.order.validAfterTimestamp + ORDER_LIFESPAN >= block.timestamp, 'EH04');

        uint256 amountInMax = tokenShares.sharesToAmount(
            orderParams.order.token0,
            orderParams.order.value0,
            orderParams.order.amountLimit0,
            orderParams.order.to
        );
        bytes memory priceInfo = encodePriceInfo(
            orderParams.pairAddress,
            orderParams.order.priceAccumulator,
            orderParams.order.timestamp
        );
        uint256 amountIn;
        uint256 amountOut;
        uint256 reserveOut;
        bool inverted = orderParams.order.inverted;
        {
            // scope for reserve out logic, avoids stack too deep errors
            (uint112 reserve0, uint112 reserve1) = ITwapPair(orderParams.pairAddress).getReserves();
            // subtract 1 to prevent reserve going to 0
            reserveOut = uint256(inverted ? reserve0 : reserve1).sub(1);
        }
        {
            // scope for partial fill logic, avoids stack too deep errors
            address oracle = ITwapPair(orderParams.pairAddress).oracle();
            uint256 swapFee = ITwapPair(orderParams.pairAddress).swapFee();
            (amountIn, amountOut) = ITwapOracle(oracle).getSwapAmountInMaxOut(
                inverted,
                swapFee,
                orderParams.order.value1,
                priceInfo
            );
            uint256 amountInMaxScaled;
            if (amountOut > reserveOut) {
                amountInMaxScaled = amountInMax.mul(reserveOut).ceil_div(orderParams.order.value1);
                (amountIn, amountOut) = ITwapOracle(oracle).getSwapAmountInMinOut(
                    inverted,
                    swapFee,
                    reserveOut,
                    priceInfo
                );
            } else {
                amountInMaxScaled = amountInMax;
                amountOut = orderParams.order.value1; // Truncate to desired out
            }
            require(amountInMaxScaled >= amountIn, 'EH08');
            if (amountInMax > amountIn) {
                if (orderParams.order.token0 == TokenShares.WETH_ADDRESS && orderParams.order.unwrap) {
                    forceEtherTransfer(orderParams.order.to, amountInMax.sub(amountIn));
                } else {
                    TransferHelper.safeTransfer(
                        orderParams.order.token0,
                        orderParams.order.to,
                        amountInMax.sub(amountIn)
                    );
                }
            }
            TransferHelper.safeTransfer(orderParams.order.token0, orderParams.pairAddress, amountIn);
        }
        amountOut = amountOut.sub(orderParams.pairTolerance);
        uint256 amount0Out;
        uint256 amount1Out;
        if (inverted) {
            amount0Out = amountOut;
        } else {
            amount1Out = amountOut;
        }
        if (orderParams.order.token1 == TokenShares.WETH_ADDRESS && orderParams.order.unwrap) {
            ITwapPair(orderParams.pairAddress).swap(amount0Out, amount1Out, address(this), priceInfo);
            forceEtherTransfer(orderParams.order.to, amountOut);
        } else {
            ITwapPair(orderParams.pairAddress).swap(amount0Out, amount1Out, orderParams.order.to, priceInfo);
        }
    }

    function executeSell(ExecuteBuySellParams memory orderParams, TokenShares.Data storage tokenShares) external {
        require(orderParams.order.validAfterTimestamp + ORDER_LIFESPAN >= block.timestamp, 'EH04');

        bytes memory priceInfo = encodePriceInfo(
            orderParams.pairAddress,
            orderParams.order.priceAccumulator,
            orderParams.order.timestamp
        );

        uint256 amountOut = _executeSellHelper(orderParams, priceInfo, tokenShares);

        (uint256 amount0Out, uint256 amount1Out) = orderParams.order.inverted
            ? (amountOut, uint256(0))
            : (uint256(0), amountOut);
        if (orderParams.order.token1 == TokenShares.WETH_ADDRESS && orderParams.order.unwrap) {
            ITwapPair(orderParams.pairAddress).swap(amount0Out, amount1Out, address(this), priceInfo);
            forceEtherTransfer(orderParams.order.to, amountOut);
        } else {
            ITwapPair(orderParams.pairAddress).swap(amount0Out, amount1Out, orderParams.order.to, priceInfo);
        }
    }

    function _executeSellHelper(
        ExecuteBuySellParams memory orderParams,
        bytes memory priceInfo,
        TokenShares.Data storage tokenShares
    ) internal returns (uint256 amountOut) {
        uint256 reserveOut;
        {
            // scope for determining reserve out, avoids stack too deep errors
            (uint112 reserve0, uint112 reserve1) = ITwapPair(orderParams.pairAddress).getReserves();
            // subtract 1 to prevent reserve going to 0
            reserveOut = uint256(orderParams.order.inverted ? reserve0 : reserve1).sub(1);
        }
        {
            // scope for calculations, avoids stack too deep errors
            address oracle = ITwapPair(orderParams.pairAddress).oracle();
            uint256 swapFee = ITwapPair(orderParams.pairAddress).swapFee();
            uint256 amountIn = tokenShares.sharesToAmount(
                orderParams.order.token0,
                orderParams.order.value0,
                orderParams.order.amountLimit0,
                orderParams.order.to
            );
            amountOut = orderParams.order.inverted
                ? ITwapOracle(oracle).getSwapAmount0Out(swapFee, amountIn, priceInfo)
                : ITwapOracle(oracle).getSwapAmount1Out(swapFee, amountIn, priceInfo);

            uint256 amountOutMinScaled;
            if (amountOut > reserveOut) {
                amountOutMinScaled = orderParams.order.value1.mul(reserveOut).div(amountOut);
                uint256 _amountIn = amountIn;
                (amountIn, amountOut) = ITwapOracle(oracle).getSwapAmountInMinOut(
                    orderParams.order.inverted,
                    swapFee,
                    reserveOut,
                    priceInfo
                );
                if (orderParams.order.token0 == TokenShares.WETH_ADDRESS && orderParams.order.unwrap) {
                    forceEtherTransfer(orderParams.order.to, _amountIn.sub(amountIn));
                } else {
                    TransferHelper.safeTransfer(
                        orderParams.order.token0,
                        orderParams.order.to,
                        _amountIn.sub(amountIn)
                    );
                }
            } else {
                amountOutMinScaled = orderParams.order.value1;
            }
            amountOut = amountOut.sub(orderParams.pairTolerance);
            require(amountOut >= amountOutMinScaled, 'EH37');
            TransferHelper.safeTransfer(orderParams.order.token0, orderParams.pairAddress, amountIn);
        }
    }

    function encodePriceInfo(
        address pairAddress,
        uint256 priceAccumulator,
        uint256 priceTimestamp
    ) internal view returns (bytes memory data) {
        uint256 price = ITwapOracle(ITwapPair(pairAddress).oracle()).getAveragePrice(priceAccumulator, priceTimestamp);
        // Pack everything as 32 bytes / uint256 to simplify decoding
        data = abi.encode(price);
    }

    function forceEtherTransfer(address to, uint256 amount) internal {
        IWETH(TokenShares.WETH_ADDRESS).withdraw(amount);
        (bool success, ) = to.call{ value: amount, gas: Orders.getTransferGasCost(Orders.NATIVE_CURRENCY_SENTINEL) }(
            ''
        );
        if (!success) {
            TokenShares.onUnwrapFailed(to, amount);
        }
    }
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



// a library for performing various math operations

library Math {
    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x < y ? x : y;
    }

    function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = x > y ? x : y;
    }

    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
    function sqrt(uint256 y) internal pure returns (uint256 z) {
        if (y > 3) {
            z = y;
            uint256 x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }
}

pragma solidity 0.7.6;
pragma abicoder v2;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9




import './SafeMath.sol';
import '../libraries/Math.sol';
import '../interfaces/ITwapFactory.sol';
import '../interfaces/ITwapPair.sol';
import '../interfaces/ITwapOracle.sol';
import '../libraries/TokenShares.sol';


library Orders {
    using SafeMath for uint256;
    using TokenShares for TokenShares.Data;
    using TransferHelper for address;

    enum OrderType {
        Empty,
        Deposit,
        Withdraw,
        Sell,
        Buy
    }
    enum OrderStatus {
        NonExistent,
        EnqueuedWaiting,
        EnqueuedReady,
        ExecutedSucceeded,
        ExecutedFailed,
        Canceled
    }

    event DepositEnqueued(uint256 indexed orderId, Order order);
    event WithdrawEnqueued(uint256 indexed orderId, Order order);
    event SellEnqueued(uint256 indexed orderId, Order order);
    event BuyEnqueued(uint256 indexed orderId, Order order);

    event OrderTypesDisabled(address pair, Orders.OrderType[] orderTypes, bool disabled);

    event RefundFailed(address indexed to, address indexed token, uint256 amount, bytes data);

    // Note on gas estimation for the full order execution in the UI:
    // Add (ORDER_BASE_COST + token transfer costs) to the actual gas usage
    // of the TwapDelay._execute* functions when updating gas cost in the UI.
    // Remember that ETH unwrap is part of those functions. It is optional,
    // but also needs to be included in the estimate.

    uint256 public constant ETHER_TRANSFER_COST = ETHER_TRANSFER_CALL_COST + 2600 + 1504; // Std cost + EIP-2929 acct access cost + Gnosis Safe receive ETH cost
    uint256 private constant BOT_ETHER_TRANSFER_COST = 10_000;
    uint256 private constant BUFFER_COST = 10_000;
    uint256 private constant ORDER_EXECUTED_EVENT_COST = 3700;
    uint256 private constant EXECUTE_PREPARATION_COST = 30_000; // dequeue + gas calculation before calls to _execute* functions

    uint256 public constant ETHER_TRANSFER_CALL_COST = 10_000;
    uint256 public constant PAIR_TRANSFER_COST = 55_000;
    uint256 public constant REFUND_BASE_COST =
        BOT_ETHER_TRANSFER_COST + ETHER_TRANSFER_COST + BUFFER_COST + ORDER_EXECUTED_EVENT_COST;
    uint256 public constant ORDER_BASE_COST = EXECUTE_PREPARATION_COST + REFUND_BASE_COST;

    // Masks used for setting order disabled
    // Different bits represent different order types
    uint8 private constant DEPOSIT_MASK = uint8(1 << uint8(OrderType.Deposit)); //   00000010
    uint8 private constant WITHDRAW_MASK = uint8(1 << uint8(OrderType.Withdraw)); // 00000100
    uint8 private constant SELL_MASK = uint8(1 << uint8(OrderType.Sell)); //         00001000
    uint8 private constant BUY_MASK = uint8(1 << uint8(OrderType.Buy)); //           00010000

    address public constant FACTORY_ADDRESS = 0xC480b33eE5229DE3FbDFAD1D2DCD3F3BAD0C56c6; 
    uint256 public constant MAX_GAS_LIMIT = 5000000; 
    uint256 public constant GAS_PRICE_INERTIA = 20000000; 
    uint256 public constant MAX_GAS_PRICE_IMPACT = 1000000; 
    uint256 public constant DELAY = 1800; 

    address public constant NATIVE_CURRENCY_SENTINEL = address(0); // A sentinel value for the native currency to distinguish it from ERC20 tokens

    struct Data {
        uint256 newestOrderId;
        uint256 lastProcessedOrderId;
        mapping(uint256 => bytes32) orderQueue;
        uint256 gasPrice;
        mapping(uint256 => bool) canceled;
        // Bit on specific positions indicates whether order type is disabled (1) or enabled (0) on specific pair
        mapping(address => uint8) orderTypesDisabled;
        mapping(uint256 => bool) refundFailed;
    }

    struct Order {
        uint256 orderId;
        OrderType orderType;
        bool inverted;
        uint256 validAfterTimestamp;
        bool unwrap;
        uint256 timestamp;
        uint256 gasLimit;
        uint256 gasPrice;
        uint256 liquidity;
        uint256 value0; // Deposit: share0, Withdraw: amount0Min, Sell: shareIn, Buy: shareInMax
        uint256 value1; // Deposit: share1, Withdraw: amount1Min, Sell: amountOutMin, Buy: amountOut
        address token0; // Sell: tokenIn, Buy: tokenIn
        address token1; // Sell: tokenOut, Buy: tokenOut
        address to;
        uint256 minSwapPrice;
        uint256 maxSwapPrice;
        bool swap;
        uint256 priceAccumulator;
        uint256 amountLimit0;
        uint256 amountLimit1;
    }

    function getOrderStatus(
        Data storage data,
        uint256 orderId,
        uint256 validAfterTimestamp
    ) internal view returns (OrderStatus) {
        if (orderId > data.newestOrderId) {
            return OrderStatus.NonExistent;
        }
        if (data.canceled[orderId]) {
            return OrderStatus.Canceled;
        }
        if (data.refundFailed[orderId]) {
            return OrderStatus.ExecutedFailed;
        }
        if (data.orderQueue[orderId] == bytes32(0)) {
            return OrderStatus.ExecutedSucceeded;
        }
        if (validAfterTimestamp >= block.timestamp) {
            return OrderStatus.EnqueuedWaiting;
        }
        return OrderStatus.EnqueuedReady;
    }

    function getPair(address tokenA, address tokenB) internal view returns (address pair, bool inverted) {
        pair = ITwapFactory(FACTORY_ADDRESS).getPair(tokenA, tokenB);
        require(pair != address(0), 'OS17');
        inverted = tokenA > tokenB;
    }

    function getDepositDisabled(Data storage data, address pair) internal view returns (bool) {
        return data.orderTypesDisabled[pair] & DEPOSIT_MASK != 0;
    }

    function getWithdrawDisabled(Data storage data, address pair) internal view returns (bool) {
        return data.orderTypesDisabled[pair] & WITHDRAW_MASK != 0;
    }

    function getSellDisabled(Data storage data, address pair) internal view returns (bool) {
        return data.orderTypesDisabled[pair] & SELL_MASK != 0;
    }

    function getBuyDisabled(Data storage data, address pair) internal view returns (bool) {
        return data.orderTypesDisabled[pair] & BUY_MASK != 0;
    }

    function setOrderTypesDisabled(
        Data storage data,
        address pair,
        Orders.OrderType[] calldata orderTypes,
        bool disabled
    ) external {
        uint256 orderTypesLength = orderTypes.length;
        uint8 currentSettings = data.orderTypesDisabled[pair];

        uint8 combinedMask;
        for (uint256 i; i < orderTypesLength; ++i) {
            Orders.OrderType orderType = orderTypes[i];
            require(orderType != Orders.OrderType.Empty, 'OS32');
            // zeros with 1 bit set at position specified by orderType
            // e.g. for SELL order type
            // mask for SELL    = 00001000
            // combinedMask     = 00000110 (DEPOSIT and WITHDRAW masks set in previous iterations)
            // the result of OR = 00001110 (DEPOSIT, WITHDRAW and SELL combined mask)
            combinedMask = combinedMask | uint8(1 << uint8(orderType));
        }

        // set/unset a bit accordingly to 'disabled' value
        if (disabled) {
            // OR operation to disable order
            // e.g. for disable DEPOSIT
            // currentSettings   = 00010100 (BUY and WITHDRAW disabled)
            // mask for DEPOSIT  = 00000010
            // the result of OR  = 00010110
            currentSettings = currentSettings | combinedMask;
        } else {
            // AND operation with a mask negation to enable order
            // e.g. for enable DEPOSIT
            // currentSettings   = 00010100 (BUY and WITHDRAW disabled)
            // 0xff              = 11111111
            // mask for Deposit  = 00000010
            // mask negation     = 11111101
            // the result of AND = 00010100
            currentSettings = currentSettings & (combinedMask ^ 0xff);
        }
        require(currentSettings != data.orderTypesDisabled[pair], 'OS01');
        data.orderTypesDisabled[pair] = currentSettings;

        emit OrderTypesDisabled(pair, orderTypes, disabled);
    }

    function markRefundFailed(Data storage data) internal {
        data.refundFailed[data.lastProcessedOrderId] = true;
    }

    /// @dev The passed in order.oderId is ignored and overwritten with the correct value, i.e. an updated data.newestOrderId.
    /// This is done to ensure atomicity of these two actions while optimizing gas usage - adding an order to the queue and incrementing
    /// data.newestOrderId (which should not be done anywhere else in the contract).
    /// Must only be called on verified orders.
    function enqueueOrder(Data storage data, Order memory order) internal {
        order.orderId = ++data.newestOrderId;
        data.orderQueue[order.orderId] = getOrderDigest(order);
    }

    struct DepositParams {
        address token0;
        address token1;
        uint256 amount0;
        uint256 amount1;
        uint256 minSwapPrice;
        uint256 maxSwapPrice;
        bool wrap;
        bool swap;
        address to;
        uint256 gasLimit;
        uint32 submitDeadline;
    }

    function deposit(
        Data storage data,
        DepositParams calldata depositParams,
        TokenShares.Data storage tokenShares
    ) external {
        {
            // scope for checks, avoids stack too deep errors
            uint256 token0TransferCost = getTransferGasCost(depositParams.token0);
            uint256 token1TransferCost = getTransferGasCost(depositParams.token1);
            checkOrderParams(
                depositParams.to,
                depositParams.gasLimit,
                depositParams.submitDeadline,
                ORDER_BASE_COST.add(token0TransferCost).add(token1TransferCost)
            );
        }
        require(depositParams.amount0 != 0 || depositParams.amount1 != 0, 'OS25');
        (address pairAddress, bool inverted) = getPair(depositParams.token0, depositParams.token1);
        require(!getDepositDisabled(data, pairAddress), 'OS46');
        {
            // scope for value, avoids stack too deep errors
            uint256 value = msg.value;

            // allocate gas refund
            if (depositParams.wrap) {
                if (depositParams.token0 == TokenShares.WETH_ADDRESS) {
                    value = msg.value.sub(depositParams.amount0, 'OS1E');
                } else if (depositParams.token1 == TokenShares.WETH_ADDRESS) {
                    value = msg.value.sub(depositParams.amount1, 'OS1E');
                }
            }
            allocateGasRefund(data, value, depositParams.gasLimit);
        }

        uint256 shares0 = tokenShares.amountToShares(
            inverted ? depositParams.token1 : depositParams.token0,
            inverted ? depositParams.amount1 : depositParams.amount0,
            depositParams.wrap
        );
        uint256 shares1 = tokenShares.amountToShares(
            inverted ? depositParams.token0 : depositParams.token1,
            inverted ? depositParams.amount0 : depositParams.amount1,
            depositParams.wrap
        );

        (uint256 priceAccumulator, uint256 timestamp) = ITwapOracle(ITwapPair(pairAddress).oracle()).getPriceInfo();

        Order memory order = Order(
            0,
            OrderType.Deposit,
            inverted,
            timestamp + DELAY, // validAfterTimestamp
            depositParams.wrap,
            timestamp,
            depositParams.gasLimit,
            data.gasPrice,
            0, // liquidity
            shares0,
            shares1,
            inverted ? depositParams.token1 : depositParams.token0,
            inverted ? depositParams.token0 : depositParams.token1,
            depositParams.to,
            depositParams.minSwapPrice,
            depositParams.maxSwapPrice,
            depositParams.swap,
            priceAccumulator,
            inverted ? depositParams.amount1 : depositParams.amount0,
            inverted ? depositParams.amount0 : depositParams.amount1
        );
        enqueueOrder(data, order);

        emit DepositEnqueued(order.orderId, order);
    }

    struct WithdrawParams {
        address token0;
        address token1;
        uint256 liquidity;
        uint256 amount0Min;
        uint256 amount1Min;
        bool unwrap;
        address to;
        uint256 gasLimit;
        uint32 submitDeadline;
    }

    function withdraw(Data storage data, WithdrawParams calldata withdrawParams) external {
        (address pair, bool inverted) = getPair(withdrawParams.token0, withdrawParams.token1);
        require(!getWithdrawDisabled(data, pair), 'OS0A');
        checkOrderParams(
            withdrawParams.to,
            withdrawParams.gasLimit,
            withdrawParams.submitDeadline,
            ORDER_BASE_COST.add(PAIR_TRANSFER_COST)
        );
        require(withdrawParams.liquidity != 0, 'OS22');

        allocateGasRefund(data, msg.value, withdrawParams.gasLimit);
        pair.safeTransferFrom(msg.sender, address(this), withdrawParams.liquidity);

        Order memory order = Order(
            0,
            OrderType.Withdraw,
            inverted,
            block.timestamp + DELAY, // validAfterTimestamp
            withdrawParams.unwrap,
            0, // timestamp
            withdrawParams.gasLimit,
            data.gasPrice,
            withdrawParams.liquidity,
            inverted ? withdrawParams.amount1Min : withdrawParams.amount0Min,
            inverted ? withdrawParams.amount0Min : withdrawParams.amount1Min,
            inverted ? withdrawParams.token1 : withdrawParams.token0,
            inverted ? withdrawParams.token0 : withdrawParams.token1,
            withdrawParams.to,
            0, // minSwapPrice
            0, // maxSwapPrice
            false, // swap
            0, // priceAccumulator
            0, // amountLimit0
            0 // amountLimit1
        );
        enqueueOrder(data, order);

        emit WithdrawEnqueued(order.orderId, order);
    }

    struct SellParams {
        address tokenIn;
        address tokenOut;
        uint256 amountIn;
        uint256 amountOutMin;
        bool wrapUnwrap;
        address to;
        uint256 gasLimit;
        uint32 submitDeadline;
    }

    function sell(
        Data storage data,
        SellParams calldata sellParams,
        TokenShares.Data storage tokenShares
    ) external {
        uint256 tokenTransferCost = getTransferGasCost(sellParams.tokenIn);
        checkOrderParams(
            sellParams.to,
            sellParams.gasLimit,
            sellParams.submitDeadline,
            ORDER_BASE_COST.add(tokenTransferCost)
        );

        (address pairAddress, bool inverted) = sellHelper(data, sellParams);

        (uint256 priceAccumulator, uint256 timestamp) = ITwapOracle(ITwapPair(pairAddress).oracle()).getPriceInfo();

        uint256 shares = tokenShares.amountToShares(sellParams.tokenIn, sellParams.amountIn, sellParams.wrapUnwrap);

        Order memory order = Order(
            0,
            OrderType.Sell,
            inverted,
            timestamp + DELAY, // validAfterTimestamp
            sellParams.wrapUnwrap,
            timestamp,
            sellParams.gasLimit,
            data.gasPrice,
            0, // liquidity
            shares,
            sellParams.amountOutMin,
            sellParams.tokenIn,
            sellParams.tokenOut,
            sellParams.to,
            0, // minSwapPrice
            0, // maxSwapPrice
            false, // swap
            priceAccumulator,
            sellParams.amountIn,
            0 // amountLimit1
        );
        enqueueOrder(data, order);

        emit SellEnqueued(order.orderId, order);
    }

    function relayerSell(
        Data storage data,
        SellParams calldata sellParams,
        TokenShares.Data storage tokenShares
    ) external {
        checkOrderParams(sellParams.to, sellParams.gasLimit, sellParams.submitDeadline, ORDER_BASE_COST);

        (, bool inverted) = sellHelper(data, sellParams);

        uint256 shares = tokenShares.amountToSharesWithoutTransfer(
            sellParams.tokenIn,
            sellParams.amountIn,
            sellParams.wrapUnwrap
        );

        Order memory order = Order(
            0,
            OrderType.Sell,
            inverted,
            block.timestamp + DELAY, // validAfterTimestamp
            false, // Never wrap/unwrap
            block.timestamp,
            sellParams.gasLimit,
            data.gasPrice,
            0, // liquidity
            shares,
            sellParams.amountOutMin,
            sellParams.tokenIn,
            sellParams.tokenOut,
            sellParams.to,
            0, // minSwapPrice
            0, // maxSwapPrice
            false, // swap
            0, // priceAccumulator - oracleV3 pairs don't need priceAccumulator
            sellParams.amountIn,
            0 // amountLimit1
        );
        enqueueOrder(data, order);

        emit SellEnqueued(order.orderId, order);
    }

    function sellHelper(Data storage data, SellParams calldata sellParams)
        internal
        returns (address pairAddress, bool inverted)
    {
        require(sellParams.amountIn != 0, 'OS24');
        (pairAddress, inverted) = getPair(sellParams.tokenIn, sellParams.tokenOut);
        require(!getSellDisabled(data, pairAddress), 'OS13');

        // allocate gas refund
        uint256 value = msg.value;
        if (sellParams.wrapUnwrap && sellParams.tokenIn == TokenShares.WETH_ADDRESS) {
            value = msg.value.sub(sellParams.amountIn, 'OS1E');
        }
        allocateGasRefund(data, value, sellParams.gasLimit);
    }

    struct BuyParams {
        address tokenIn;
        address tokenOut;
        uint256 amountInMax;
        uint256 amountOut;
        bool wrapUnwrap;
        address to;
        uint256 gasLimit;
        uint32 submitDeadline;
    }

    function buy(
        Data storage data,
        BuyParams calldata buyParams,
        TokenShares.Data storage tokenShares
    ) external {
        uint256 tokenTransferCost = getTransferGasCost(buyParams.tokenIn);
        checkOrderParams(
            buyParams.to,
            buyParams.gasLimit,
            buyParams.submitDeadline,
            ORDER_BASE_COST.add(tokenTransferCost)
        );
        require(buyParams.amountOut != 0, 'OS23');
        (address pairAddress, bool inverted) = getPair(buyParams.tokenIn, buyParams.tokenOut);
        require(!getBuyDisabled(data, pairAddress), 'OS49');
        uint256 value = msg.value;

        // allocate gas refund
        if (buyParams.tokenIn == TokenShares.WETH_ADDRESS && buyParams.wrapUnwrap) {
            value = msg.value.sub(buyParams.amountInMax, 'OS1E');
        }

        allocateGasRefund(data, value, buyParams.gasLimit);

        uint256 shares = tokenShares.amountToShares(buyParams.tokenIn, buyParams.amountInMax, buyParams.wrapUnwrap);

        (uint256 priceAccumulator, uint256 timestamp) = ITwapOracle(ITwapPair(pairAddress).oracle()).getPriceInfo();

        Order memory order = Order(
            0,
            OrderType.Buy,
            inverted,
            timestamp + DELAY, // validAfterTimestamp
            buyParams.wrapUnwrap,
            timestamp,
            buyParams.gasLimit,
            data.gasPrice,
            0, // liquidity
            shares,
            buyParams.amountOut,
            buyParams.tokenIn,
            buyParams.tokenOut,
            buyParams.to,
            0, // minSwapPrice
            0, // maxSwapPrice
            false, // swap
            priceAccumulator,
            buyParams.amountInMax,
            0 // amountLimit1
        );
        enqueueOrder(data, order);

        emit BuyEnqueued(order.orderId, order);
    }

    function checkOrderParams(
        address to,
        uint256 gasLimit,
        uint32 submitDeadline,
        uint256 minGasLimit
    ) private view {
        require(submitDeadline >= block.timestamp, 'OS04');
        require(gasLimit <= MAX_GAS_LIMIT, 'OS3E');
        require(gasLimit >= minGasLimit, 'OS3D');
        require(to != address(0), 'OS26');
    }

    function allocateGasRefund(
        Data storage data,
        uint256 value,
        uint256 gasLimit
    ) private returns (uint256 futureFee) {
        futureFee = data.gasPrice.mul(gasLimit);
        require(value >= futureFee, 'OS1E');
        if (value > futureFee) {
            TransferHelper.safeTransferETH(
                msg.sender,
                value.sub(futureFee),
                getTransferGasCost(NATIVE_CURRENCY_SENTINEL)
            );
        }
    }

    function updateGasPrice(Data storage data, uint256 gasUsed) external {
        uint256 scale = Math.min(gasUsed, MAX_GAS_PRICE_IMPACT);
        data.gasPrice = data.gasPrice.mul(GAS_PRICE_INERTIA.sub(scale)).add(tx.gasprice.mul(scale)).div(
            GAS_PRICE_INERTIA
        );
    }

    function refundLiquidity(
        address pair,
        address to,
        uint256 liquidity,
        bytes4 selector
    ) internal returns (bool) {
        if (liquidity == 0) {
            return true;
        }
        (bool success, bytes memory data) = address(this).call{ gas: PAIR_TRANSFER_COST }(
            abi.encodeWithSelector(selector, pair, to, liquidity, false)
        );
        if (!success) {
            emit RefundFailed(to, pair, liquidity, data);
        }
        return success;
    }

    function dequeueOrder(Data storage data, uint256 orderId) internal {
        ++data.lastProcessedOrderId;
        require(orderId == data.lastProcessedOrderId, 'OS72');
    }

    function forgetOrder(Data storage data, uint256 orderId) internal {
        delete data.orderQueue[orderId];
    }

    function forgetLastProcessedOrder(Data storage data) internal {
        delete data.orderQueue[data.lastProcessedOrderId];
    }

    function getOrderDigest(Order memory order) internal pure returns (bytes32) {
        // Used to avoid the 'stack too deep' error.
        bytes memory partialOrderData = abi.encodePacked(
            order.orderId,
            order.orderType,
            order.inverted,
            order.validAfterTimestamp,
            order.unwrap,
            order.timestamp,
            order.gasLimit,
            order.gasPrice,
            order.liquidity,
            order.value0,
            order.value1,
            order.token0,
            order.token1,
            order.to
        );

        return
            keccak256(
                abi.encodePacked(
                    partialOrderData,
                    order.minSwapPrice,
                    order.maxSwapPrice,
                    order.swap,
                    order.priceAccumulator,
                    order.amountLimit0,
                    order.amountLimit1
                )
            );
    }

    function verifyOrder(Data storage data, Order memory order) external view {
        require(getOrderDigest(order) == data.orderQueue[order.orderId], 'OS71');
    }

    
    // constant mapping for transferGasCost
    /**
     * @dev This function should either return a default value != 0 or revert.
     */
    function getTransferGasCost(address token) internal pure returns (uint256) {
        if (token == NATIVE_CURRENCY_SENTINEL) return ETHER_TRANSFER_CALL_COST;
        if (token == 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) return 70000;
        return 60000;
    }
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



// a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)

library SafeMath {
    int256 private constant _INT256_MIN = -2**255;

    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x + y) >= x, 'SM4E');
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        z = sub(x, y, 'SM12');
    }

    function sub(
        uint256 x,
        uint256 y,
        string memory message
    ) internal pure returns (uint256 z) {
        require((z = x - y) <= x, message);
    }

    function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require(y == 0 || (z = x * y) / y == x, 'SM2A');
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, 'SM43');
        return a / b;
    }

    function ceil_div(uint256 a, uint256 b) internal pure returns (uint256 c) {
        c = div(a, b);
        if (a != mul(b, c)) {
            return add(c, 1);
        }
    }

    function toUint32(uint256 n) internal pure returns (uint32) {
        require(n <= type(uint32).max, 'SM50');
        return uint32(n);
    }

    function toUint64(uint256 n) internal pure returns (uint64) {
        require(n <= type(uint64).max, 'SM54');
        return uint64(n);
    }

    function toUint112(uint256 n) internal pure returns (uint112) {
        require(n <= type(uint112).max, 'SM51');
        return uint112(n);
    }

    function toInt256(uint256 unsigned) internal pure returns (int256 signed) {
        require(unsigned <= uint256(type(int256).max), 'SM34');
        signed = int256(unsigned);
    }

    // int256

    function add(int256 a, int256 b) internal pure returns (int256 c) {
        c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a), 'SM4D');
    }

    function sub(int256 a, int256 b) internal pure returns (int256 c) {
        c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a), 'SM11');
    }

    function mul(int256 a, int256 b) internal pure returns (int256 c) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        require(!(a == -1 && b == _INT256_MIN), 'SM29');

        c = a * b;
        require(c / a == b, 'SM29');
    }

    function div(int256 a, int256 b) internal pure returns (int256) {
        require(b != 0, 'SM43');
        require(!(b == -1 && a == _INT256_MIN), 'SM42');

        return a / b;
    }

    function neg_floor_div(int256 a, int256 b) internal pure returns (int256 c) {
        c = div(a, b);
        if ((a < 0 && b > 0) || (a >= 0 && b < 0)) {
            if (a != mul(b, c)) {
                c = sub(c, 1);
            }
        }
    }
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



import '../interfaces/IERC20.sol';
import '../interfaces/IWETH.sol';
import './SafeMath.sol';
import './TransferHelper.sol';


library TokenShares {
    using SafeMath for uint256;
    using TransferHelper for address;

    uint256 private constant PRECISION = 10**18;
    uint256 private constant TOLERANCE = 10**18 + 10**16;
    uint256 private constant TOTAL_SHARES_PRECISION = 10**18;

    event UnwrapFailed(address to, uint256 amount);

    // represents wrapped native currency (WETH or WMATIC)
    address public constant WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; 

    struct Data {
        mapping(address => uint256) totalShares;
    }

    function sharesToAmount(
        Data storage data,
        address token,
        uint256 share,
        uint256 amountLimit,
        address refundTo
    ) external returns (uint256) {
        if (share == 0) {
            return 0;
        }
        if (token == WETH_ADDRESS || isNonRebasing(token)) {
            return share;
        }

        uint256 totalTokenShares = data.totalShares[token];
        require(totalTokenShares >= share, 'TS3A');
        uint256 balance = IERC20(token).balanceOf(address(this));
        uint256 value = balance.mul(share).div(totalTokenShares);
        data.totalShares[token] = totalTokenShares.sub(share);

        if (amountLimit > 0) {
            uint256 amountLimitWithTolerance = amountLimit.mul(TOLERANCE).div(PRECISION);
            if (value > amountLimitWithTolerance) {
                TransferHelper.safeTransfer(token, refundTo, value.sub(amountLimitWithTolerance));
                return amountLimitWithTolerance;
            }
        }

        return value;
    }

    function amountToShares(
        Data storage data,
        address token,
        uint256 amount,
        bool wrap
    ) external returns (uint256) {
        if (amount == 0) {
            return 0;
        }
        if (token == WETH_ADDRESS) {
            if (wrap) {
                require(msg.value >= amount, 'TS03');
                IWETH(token).deposit{ value: amount }();
            } else {
                token.safeTransferFrom(msg.sender, address(this), amount);
            }
            return amount;
        } else if (isNonRebasing(token)) {
            token.safeTransferFrom(msg.sender, address(this), amount);
            return amount;
        } else {
            uint256 balanceBefore = IERC20(token).balanceOf(address(this));
            token.safeTransferFrom(msg.sender, address(this), amount);
            uint256 balanceAfter = IERC20(token).balanceOf(address(this));

            return amountToSharesHelper(data, token, balanceBefore, balanceAfter);
        }
    }

    function amountToSharesWithoutTransfer(
        Data storage data,
        address token,
        uint256 amount,
        bool wrap
    ) external returns (uint256) {
        if (token == WETH_ADDRESS) {
            if (wrap) {
                // require(msg.value >= amount, 'TS03'); // Duplicate check in TwapRelayer.sell
                IWETH(token).deposit{ value: amount }();
            }
            return amount;
        } else if (isNonRebasing(token)) {
            return amount;
        } else {
            uint256 balanceAfter = IERC20(token).balanceOf(address(this));
            uint256 balanceBefore = balanceAfter.sub(amount);
            return amountToSharesHelper(data, token, balanceBefore, balanceAfter);
        }
    }

    function amountToSharesHelper(
        Data storage data,
        address token,
        uint256 balanceBefore,
        uint256 balanceAfter
    ) internal returns (uint256) {
        uint256 totalTokenShares = data.totalShares[token];
        require(balanceBefore > 0 || totalTokenShares == 0, 'TS30');
        require(balanceAfter > balanceBefore, 'TS2C');

        if (balanceBefore > 0) {
            if (totalTokenShares == 0) {
                totalTokenShares = balanceBefore.mul(TOTAL_SHARES_PRECISION);
            }
            uint256 newShares = totalTokenShares.mul(balanceAfter).div(balanceBefore);
            require(balanceAfter < type(uint256).max.div(newShares), 'TS73'); // to prevent overflow at execution
            data.totalShares[token] = newShares;
            return newShares - totalTokenShares;
        } else {
            totalTokenShares = balanceAfter.mul(TOTAL_SHARES_PRECISION);
            require(totalTokenShares < type(uint256).max.div(totalTokenShares), 'TS73'); // to prevent overflow at execution
            data.totalShares[token] = totalTokenShares;
            return totalTokenShares;
        }
    }

    function onUnwrapFailed(address to, uint256 amount) external {
        emit UnwrapFailed(to, amount);
        IWETH(WETH_ADDRESS).deposit{ value: amount }();
        TransferHelper.safeTransfer(WETH_ADDRESS, to, amount);
    }

    
    // constant mapping for nonRebasingToken
    function isNonRebasing(address token) internal pure returns (bool) {
        if (token == 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2) return true;
        if (token == 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) return true;
        if (token == 0xdAC17F958D2ee523a2206206994597C13D831ec7) return true;
        if (token == 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599) return true;
        return false;
    }
}

pragma solidity 0.7.6;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9



// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TH4B');
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TH05');
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'TH0E');
    }

    function safeTransferETH(
        address to,
        uint256 value,
        uint256 gasLimit
    ) internal {
        (bool success, ) = to.call{ value: value, gas: gasLimit }('');
        require(success, 'TH3F');
    }

    function transferETH(
        address to,
        uint256 value,
        uint256 gasLimit
    ) internal returns (bool success) {
        (success, ) = to.call{ value: value, gas: gasLimit }('');
    }
}

pragma solidity 0.7.6;
pragma abicoder v2;

// SPDX-License-Identifier: GPL-3.0-or-later
// Deployed with donations via Gitcoin GR9




import '../interfaces/ITwapPair.sol';
import '../interfaces/IWETH.sol';
import './Orders.sol';

library WithdrawHelper {
    using SafeMath for uint256;

    function _transferToken(
        uint256 balanceBefore,
        address token,
        address to
    ) internal {
        uint256 tokenAmount = IERC20(token).balanceOf(address(this)).sub(balanceBefore);
        TransferHelper.safeTransfer(token, to, tokenAmount);
    }

    // unwraps wrapped native currency
    function _unwrapWeth(
        uint256 ethAmount,
        address weth,
        address to,
        uint256 gasLimit
    ) internal returns (bool) {
        IWETH(weth).withdraw(ethAmount);
        (bool success, ) = to.call{ value: ethAmount, gas: gasLimit }('');
        return success;
    }

    function withdrawAndUnwrap(
        address token0,
        address token1,
        address pair,
        address weth,
        address to,
        uint256 gasLimit
    )
        external
        returns (
            bool,
            uint256,
            uint256,
            uint256
        )
    {
        bool isToken0Weth = token0 == weth;
        address otherToken = isToken0Weth ? token1 : token0;

        uint256 balanceBefore = IERC20(otherToken).balanceOf(address(this));
        (uint256 amount0, uint256 amount1) = ITwapPair(pair).burn(address(this));
        _transferToken(balanceBefore, otherToken, to);

        bool success = _unwrapWeth(isToken0Weth ? amount0 : amount1, weth, to, gasLimit);

        return (success, isToken0Weth ? amount0 : amount1, amount0, amount1);
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {
    "contracts/libraries/ExecutionHelper.sol": {
      "ExecutionHelper": "0xeb244fb424b56ccb96d42bd1983fb0d67037b27e"
    },
    "contracts/libraries/Orders.sol": {
      "Orders": "0x6b225b3797892c6582a06d17bcfe0a96f0b9087c"
    },
    "contracts/libraries/TokenShares.sol": {
      "TokenShares": "0xff407b033077b5cabdef809e953cadbe4b322126"
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_factoryGovernor","type":"address"},{"internalType":"address","name":"_bot","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"bot","type":"address"},{"indexed":false,"internalType":"bool","name":"isBot","type":"bool"}],"name":"BotSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"delay","type":"uint256"}],"name":"DelaySet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"bool","name":"success","type":"bool"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"EthRefund","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"factoryGovernor","type":"address"}],"name":"FactoryGovernorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gasPriceInertia","type":"uint256"}],"name":"GasPriceInertiaSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxGasLimit","type":"uint256"}],"name":"MaxGasLimitSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxGasPriceImpact","type":"uint256"}],"name":"MaxGasPriceImpactSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"bool","name":"isNonRebasing","type":"bool"}],"name":"NonRebasingTokenSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"bool","name":"success","type":"bool"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"gasSpent","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ethRefunded","type":"uint256"}],"name":"OrderExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"owner","type":"address"}],"name":"OwnerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"relayer","type":"address"}],"name":"RelayerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pair","type":"address"},{"indexed":false,"internalType":"uint16","name":"amount","type":"uint16"}],"name":"ToleranceSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"gasCost","type":"uint256"}],"name":"TransferGasCostSet","type":"event"},{"inputs":[],"name":"RELAYER_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"enum Orders.OrderType","name":"orderType","type":"uint8"},{"internalType":"bool","name":"inverted","type":"bool"},{"internalType":"uint256","name":"validAfterTimestamp","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"value0","type":"uint256"},{"internalType":"uint256","name":"value1","type":"uint256"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"minSwapPrice","type":"uint256"},{"internalType":"uint256","name":"maxSwapPrice","type":"uint256"},{"internalType":"bool","name":"swap","type":"bool"},{"internalType":"uint256","name":"priceAccumulator","type":"uint256"},{"internalType":"uint256","name":"amountLimit0","type":"uint256"},{"internalType":"uint256","name":"amountLimit1","type":"uint256"}],"internalType":"struct Orders.Order","name":"order","type":"tuple"}],"name":"_executeBuy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"enum Orders.OrderType","name":"orderType","type":"uint8"},{"internalType":"bool","name":"inverted","type":"bool"},{"internalType":"uint256","name":"validAfterTimestamp","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"value0","type":"uint256"},{"internalType":"uint256","name":"value1","type":"uint256"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"minSwapPrice","type":"uint256"},{"internalType":"uint256","name":"maxSwapPrice","type":"uint256"},{"internalType":"bool","name":"swap","type":"bool"},{"internalType":"uint256","name":"priceAccumulator","type":"uint256"},{"internalType":"uint256","name":"amountLimit0","type":"uint256"},{"internalType":"uint256","name":"amountLimit1","type":"uint256"}],"internalType":"struct Orders.Order","name":"order","type":"tuple"}],"name":"_executeDeposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"enum Orders.OrderType","name":"orderType","type":"uint8"},{"internalType":"bool","name":"inverted","type":"bool"},{"internalType":"uint256","name":"validAfterTimestamp","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"value0","type":"uint256"},{"internalType":"uint256","name":"value1","type":"uint256"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"minSwapPrice","type":"uint256"},{"internalType":"uint256","name":"maxSwapPrice","type":"uint256"},{"internalType":"bool","name":"swap","type":"bool"},{"internalType":"uint256","name":"priceAccumulator","type":"uint256"},{"internalType":"uint256","name":"amountLimit0","type":"uint256"},{"internalType":"uint256","name":"amountLimit1","type":"uint256"}],"internalType":"struct Orders.Order","name":"order","type":"tuple"}],"name":"_executeSell","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"enum Orders.OrderType","name":"orderType","type":"uint8"},{"internalType":"bool","name":"inverted","type":"bool"},{"internalType":"uint256","name":"validAfterTimestamp","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"value0","type":"uint256"},{"internalType":"uint256","name":"value1","type":"uint256"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"minSwapPrice","type":"uint256"},{"internalType":"uint256","name":"maxSwapPrice","type":"uint256"},{"internalType":"bool","name":"swap","type":"bool"},{"internalType":"uint256","name":"priceAccumulator","type":"uint256"},{"internalType":"uint256","name":"amountLimit0","type":"uint256"},{"internalType":"uint256","name":"amountLimit1","type":"uint256"}],"internalType":"struct Orders.Order","name":"order","type":"tuple"}],"name":"_executeWithdraw","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"}],"name":"_refundLiquidity","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"share","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"}],"name":"_refundToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"uint256","name":"share0","type":"uint256"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"share1","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"}],"name":"_refundTokens","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountInMax","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"bool","name":"wrapUnwrap","type":"bool"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint32","name":"submitDeadline","type":"uint32"}],"internalType":"struct Orders.BuyParams","name":"buyParams","type":"tuple"}],"name":"buy","outputs":[{"internalType":"uint256","name":"orderId","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"enum Orders.OrderType","name":"orderType","type":"uint8"},{"internalType":"bool","name":"inverted","type":"bool"},{"internalType":"uint256","name":"validAfterTimestamp","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"value0","type":"uint256"},{"internalType":"uint256","name":"value1","type":"uint256"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"minSwapPrice","type":"uint256"},{"internalType":"uint256","name":"maxSwapPrice","type":"uint256"},{"internalType":"bool","name":"swap","type":"bool"},{"internalType":"uint256","name":"priceAccumulator","type":"uint256"},{"internalType":"uint256","name":"amountLimit0","type":"uint256"},{"internalType":"uint256","name":"amountLimit1","type":"uint256"}],"internalType":"struct Orders.Order","name":"order","type":"tuple"}],"name":"cancelOrder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"delay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"},{"internalType":"uint256","name":"minSwapPrice","type":"uint256"},{"internalType":"uint256","name":"maxSwapPrice","type":"uint256"},{"internalType":"bool","name":"wrap","type":"bool"},{"internalType":"bool","name":"swap","type":"bool"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint32","name":"submitDeadline","type":"uint32"}],"internalType":"struct Orders.DepositParams","name":"depositParams","type":"tuple"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"orderId","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"enum Orders.OrderType","name":"orderType","type":"uint8"},{"internalType":"bool","name":"inverted","type":"bool"},{"internalType":"uint256","name":"validAfterTimestamp","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"value0","type":"uint256"},{"internalType":"uint256","name":"value1","type":"uint256"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"minSwapPrice","type":"uint256"},{"internalType":"uint256","name":"maxSwapPrice","type":"uint256"},{"internalType":"bool","name":"swap","type":"bool"},{"internalType":"uint256","name":"priceAccumulator","type":"uint256"},{"internalType":"uint256","name":"amountLimit0","type":"uint256"},{"internalType":"uint256","name":"amountLimit1","type":"uint256"}],"internalType":"struct Orders.Order[]","name":"_orders","type":"tuple[]"}],"name":"execute","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"factoryGovernor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gasPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gasPriceInertia","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"getBuyDisabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"getDepositDisabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"uint256","name":"validAfterTimestamp","type":"uint256"}],"name":"getOrderStatus","outputs":[{"internalType":"enum Orders.OrderStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"getSellDisabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"getTolerance","outputs":[{"internalType":"uint16","name":"tolerance","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"getTransferGasCost","outputs":[{"internalType":"uint256","name":"gasCost","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"getWithdrawDisabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isBot","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"isNonRebasingToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"orderId","type":"uint256"}],"name":"isOrderCanceled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastProcessedOrderId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxGasLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"maxGasPriceImpact","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"newestOrderId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"relayer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"bool","name":"wrapUnwrap","type":"bool"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint32","name":"submitDeadline","type":"uint32"}],"internalType":"struct Orders.SellParams","name":"sellParams","type":"tuple"}],"name":"relayerSell","outputs":[{"internalType":"uint256","name":"orderId","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"orderId","type":"uint256"},{"internalType":"enum Orders.OrderType","name":"orderType","type":"uint8"},{"internalType":"bool","name":"inverted","type":"bool"},{"internalType":"uint256","name":"validAfterTimestamp","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPrice","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"value0","type":"uint256"},{"internalType":"uint256","name":"value1","type":"uint256"},{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"minSwapPrice","type":"uint256"},{"internalType":"uint256","name":"maxSwapPrice","type":"uint256"},{"internalType":"bool","name":"swap","type":"bool"},{"internalType":"uint256","name":"priceAccumulator","type":"uint256"},{"internalType":"uint256","name":"amountLimit0","type":"uint256"},{"internalType":"uint256","name":"amountLimit1","type":"uint256"}],"internalType":"struct Orders.Order","name":"order","type":"tuple"}],"name":"retryRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"bool","name":"wrapUnwrap","type":"bool"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint32","name":"submitDeadline","type":"uint32"}],"internalType":"struct Orders.SellParams","name":"sellParams","type":"tuple"}],"name":"sell","outputs":[{"internalType":"uint256","name":"orderId","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_bot","type":"address"},{"internalType":"bool","name":"_isBot","type":"bool"}],"name":"setBot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_factoryGovernor","type":"address"}],"name":"setFactoryGovernor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"enum Orders.OrderType[]","name":"orderTypes","type":"uint8[]"},{"internalType":"bool","name":"disabled","type":"bool"}],"name":"setOrderTypesDisabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"}],"name":"syncPair","outputs":[{"internalType":"address","name":"pairAddress","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"token0","type":"address"},{"internalType":"address","name":"token1","type":"address"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"amount0Min","type":"uint256"},{"internalType":"uint256","name":"amount1Min","type":"uint256"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint32","name":"submitDeadline","type":"uint32"}],"internalType":"struct Orders.WithdrawParams","name":"withdrawParams","type":"tuple"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"orderId","type":"uint256"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000f4418d9fe76a788f2868a558dd216549ad2d869b0000000000000000000000003a1d749fa4a9e650fce844ff1c58c5faf7e2a9d1

-----Decoded View---------------
Arg [0] : _factoryGovernor (address): 0xF4418d9fe76A788F2868a558dD216549aD2d869B
Arg [1] : _bot (address): 0x3a1D749fa4a9E650FCe844fF1C58C5faf7e2a9D1

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000f4418d9fe76a788f2868a558dd216549ad2d869b
Arg [1] : 0000000000000000000000003a1d749fa4a9e650fce844ff1c58c5faf7e2a9d1