Contract 0x0edc96c6070fef121cb4a1af50fc8e02fe6a8486

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

pragma solidity 0.7.6;
pragma abicoder v2;

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 MaxGasLimitSet(uint256 maxGasLimit);
    event GasPriceInertiaSet(uint256 gasPriceInertia);
    event MaxGasPriceImpactSet(uint256 maxGasPriceImpact);
    event TransferGasCostSet(address token, uint256 gasCost);

    event DepositEnqueued(uint256 indexed orderId, uint32 validAfterTimestamp, uint256 gasPrice);
    event WithdrawEnqueued(uint256 indexed orderId, uint32 validAfterTimestamp, uint256 gasPrice);
    event SellEnqueued(uint256 indexed orderId, uint32 validAfterTimestamp, uint256 gasPrice);
    event BuyEnqueued(uint256 indexed orderId, uint32 validAfterTimestamp, uint256 gasPrice);

    event OrderDisabled(address pair, Orders.OrderType orderType, bool disabled);

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

    uint8 private constant DEPOSIT_TYPE = 1;
    uint8 private constant WITHDRAW_TYPE = 2;
    uint8 private constant BUY_TYPE = 3;
    uint8 private constant BUY_INVERTED_TYPE = 4;
    uint8 private constant SELL_TYPE = 5;
    uint8 private constant SELL_INVERTED_TYPE = 6;

    uint8 private constant UNWRAP_NOT_FAILED = 0;
    uint8 private constant KEEP_NOT_FAILED = 1;
    uint8 private constant UNWRAP_FAILED = 2;
    uint8 private constant KEEP_FAILED = 3;

    uint256 private constant ETHER_TRANSFER_COST = 2600 + 1504; // EIP-2929 acct access cost + Gnosis Safe receive ETH cost
    uint256 private constant BUFFER_COST = 10000;
    uint256 private constant ORDER_EXECUTED_EVENT_COST = 3700;
    uint256 private constant EXECUTE_PREPARATION_COST = 55000; // dequeue + getPair in execute

    uint256 public constant ETHER_TRANSFER_CALL_COST = 10000;
    uint256 public constant PAIR_TRANSFER_COST = 55000;
    uint256 public constant REFUND_BASE_COST = 2 * 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

    struct PairInfo {
        address pair;
        address token0;
        address token1;
    }

    struct Data {
        uint32 delay;
        uint256 newestOrderId;
        uint256 lastProcessedOrderId;
        mapping(uint256 => StoredOrder) orderQueue;
        address factory;
        uint256 maxGasLimit;
        uint256 gasPrice;
        uint256 gasPriceInertia;
        uint256 maxGasPriceImpact;
        mapping(uint32 => PairInfo) pairs;
        mapping(address => uint256) transferGasCosts;
        mapping(uint256 => bool) canceled;
        // Bit on specific positions indicates whether order type is disabled (1) or enabled (0) on specific pair
        mapping(address => uint8) orderDisabled;
    }

    struct StoredOrder {
        // slot 0
        uint8 orderType;
        uint32 validAfterTimestamp;
        uint8 unwrapAndFailure;
        uint32 timestamp;
        uint32 gasLimit;
        uint32 gasPrice;
        uint112 liquidity;
        // slot 1
        uint112 value0;
        uint112 value1;
        uint32 pairId;
        // slot2
        address to;
        uint32 minSwapPrice;
        uint32 maxSwapPrice;
        bool swap;
        // slot3
        uint256 priceAccumulator;
        // slot4
        uint112 amountLimit0;
        uint112 amountLimit1;
    }

    struct DepositOrder {
        uint32 pairId;
        uint256 share0;
        uint256 share1;
        uint256 minSwapPrice;
        uint256 maxSwapPrice;
        bool unwrap;
        bool swap;
        address to;
        uint256 gasPrice;
        uint256 gasLimit;
        uint32 validAfterTimestamp;
        uint256 priceAccumulator;
        uint32 timestamp;
    }

    struct WithdrawOrder {
        uint32 pairId;
        uint256 liquidity;
        uint256 amount0Min;
        uint256 amount1Min;
        bool unwrap;
        address to;
        uint256 gasPrice;
        uint256 gasLimit;
        uint32 validAfterTimestamp;
    }

    struct SellOrder {
        uint32 pairId;
        bool inverse;
        uint256 shareIn;
        uint256 amountOutMin;
        bool unwrap;
        address to;
        uint256 gasPrice;
        uint256 gasLimit;
        uint32 validAfterTimestamp;
        uint256 priceAccumulator;
        uint32 timestamp;
    }

    struct BuyOrder {
        uint32 pairId;
        bool inverse;
        uint256 shareInMax;
        uint256 amountOut;
        bool unwrap;
        address to;
        uint256 gasPrice;
        uint256 gasLimit;
        uint32 validAfterTimestamp;
        uint256 priceAccumulator;
        uint32 timestamp;
    }

    function decodeType(uint256 internalType) internal pure returns (OrderType orderType) {
        if (internalType == DEPOSIT_TYPE) {
            orderType = OrderType.Deposit;
        } else if (internalType == WITHDRAW_TYPE) {
            orderType = OrderType.Withdraw;
        } else if (internalType == BUY_TYPE) {
            orderType = OrderType.Buy;
        } else if (internalType == BUY_INVERTED_TYPE) {
            orderType = OrderType.Buy;
        } else if (internalType == SELL_TYPE) {
            orderType = OrderType.Sell;
        } else if (internalType == SELL_INVERTED_TYPE) {
            orderType = OrderType.Sell;
        } else {
            orderType = OrderType.Empty;
        }
    }

    function getOrder(Data storage data, uint256 orderId)
        internal
        view
        returns (OrderType orderType, uint32 validAfterTimestamp)
    {
        StoredOrder storage order = data.orderQueue[orderId];
        validAfterTimestamp = order.validAfterTimestamp;
        orderType = decodeType(order.orderType);
    }

    function getOrderStatus(Data storage data, uint256 orderId) internal view returns (OrderStatus orderStatus) {
        if (orderId > data.newestOrderId) {
            return OrderStatus.NonExistent;
        }
        if (data.canceled[orderId]) {
            return OrderStatus.Canceled;
        }
        if (isRefundFailed(data, orderId)) {
            return OrderStatus.ExecutedFailed;
        }
        (OrderType orderType, uint32 validAfterTimestamp) = getOrder(data, orderId);
        if (orderType == OrderType.Empty) {
            return OrderStatus.ExecutedSucceeded;
        }
        if (validAfterTimestamp >= block.timestamp) {
            return OrderStatus.EnqueuedWaiting;
        }
        return OrderStatus.EnqueuedReady;
    }

    function getPair(
        Data storage data,
        address tokenA,
        address tokenB
    )
        internal
        returns (
            address pair,
            uint32 pairId,
            bool inverted
        )
    {
        inverted = tokenA > tokenB;
        (address token0, address token1) = inverted ? (tokenB, tokenA) : (tokenA, tokenB);
        pair = ITwapFactory(data.factory).getPair(token0, token1);
        require(pair != address(0), 'OS17');
        pairId = uint32(bytes4(keccak256(abi.encodePacked(pair))));
        if (data.pairs[pairId].pair == address(0)) {
            data.pairs[pairId] = PairInfo(pair, token0, token1);
        }
    }

    function getPairInfo(Data storage data, uint32 pairId)
        internal
        view
        returns (
            address pair,
            address token0,
            address token1
        )
    {
        PairInfo storage info = data.pairs[pairId];
        pair = info.pair;
        token0 = info.token0;
        token1 = info.token1;
    }

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

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

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

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

    function getDepositOrder(Data storage data, uint256 index)
        public
        view
        returns (
            DepositOrder memory order,
            uint256 amountLimit0,
            uint256 amountLimit1
        )
    {
        StoredOrder memory stored = data.orderQueue[index];
        require(stored.orderType == DEPOSIT_TYPE, 'OS32');
        order.pairId = stored.pairId;
        order.share0 = stored.value0;
        order.share1 = stored.value1;
        order.minSwapPrice = float32ToUint(stored.minSwapPrice);
        order.maxSwapPrice = float32ToUint(stored.maxSwapPrice);
        order.unwrap = getUnwrap(stored.unwrapAndFailure);
        order.swap = stored.swap;
        order.to = stored.to;
        order.gasPrice = uint32ToGasPrice(stored.gasPrice);
        order.gasLimit = stored.gasLimit;
        order.validAfterTimestamp = stored.validAfterTimestamp;
        order.priceAccumulator = stored.priceAccumulator;
        order.timestamp = stored.timestamp;

        amountLimit0 = stored.amountLimit0;
        amountLimit1 = stored.amountLimit1;
    }

    function getWithdrawOrder(Data storage data, uint256 index) public view returns (WithdrawOrder memory order) {
        StoredOrder memory stored = data.orderQueue[index];
        require(stored.orderType == WITHDRAW_TYPE, 'OS32');
        order.pairId = stored.pairId;
        order.liquidity = stored.liquidity;
        order.amount0Min = stored.value0;
        order.amount1Min = stored.value1;
        order.unwrap = getUnwrap(stored.unwrapAndFailure);
        order.to = stored.to;
        order.gasPrice = uint32ToGasPrice(stored.gasPrice);
        order.gasLimit = stored.gasLimit;
        order.validAfterTimestamp = stored.validAfterTimestamp;
    }

    function getSellOrder(Data storage data, uint256 index)
        public
        view
        returns (SellOrder memory order, uint256 amountLimit)
    {
        StoredOrder memory stored = data.orderQueue[index];
        require(stored.orderType == SELL_TYPE || stored.orderType == SELL_INVERTED_TYPE, 'OS32');
        order.pairId = stored.pairId;
        order.inverse = stored.orderType == SELL_INVERTED_TYPE;
        order.shareIn = stored.value0;
        order.amountOutMin = stored.value1;
        order.unwrap = getUnwrap(stored.unwrapAndFailure);
        order.to = stored.to;
        order.gasPrice = uint32ToGasPrice(stored.gasPrice);
        order.gasLimit = stored.gasLimit;
        order.validAfterTimestamp = stored.validAfterTimestamp;
        order.priceAccumulator = stored.priceAccumulator;
        order.timestamp = stored.timestamp;

        amountLimit = stored.amountLimit0;
    }

    function getBuyOrder(Data storage data, uint256 index)
        public
        view
        returns (BuyOrder memory order, uint256 amountLimit)
    {
        StoredOrder memory stored = data.orderQueue[index];
        require(stored.orderType == BUY_TYPE || stored.orderType == BUY_INVERTED_TYPE, 'OS32');
        order.pairId = stored.pairId;
        order.inverse = stored.orderType == BUY_INVERTED_TYPE;
        order.shareInMax = stored.value0;
        order.amountOut = stored.value1;
        order.unwrap = getUnwrap(stored.unwrapAndFailure);
        order.to = stored.to;
        order.gasPrice = uint32ToGasPrice(stored.gasPrice);
        order.gasLimit = stored.gasLimit;
        order.validAfterTimestamp = stored.validAfterTimestamp;
        order.timestamp = stored.timestamp;
        order.priceAccumulator = stored.priceAccumulator;

        amountLimit = stored.amountLimit0;
    }

    function getFailedOrderType(Data storage data, uint256 orderId)
        internal
        view
        returns (OrderType orderType, uint32 validAfterTimestamp)
    {
        require(isRefundFailed(data, orderId), 'OS21');
        (orderType, validAfterTimestamp) = getOrder(data, orderId);
    }

    function getUnwrap(uint8 unwrapAndFailure) private pure returns (bool) {
        return unwrapAndFailure == UNWRAP_FAILED || unwrapAndFailure == UNWRAP_NOT_FAILED;
    }

    function getUnwrapAndFailure(bool unwrap) private pure returns (uint8) {
        return unwrap ? UNWRAP_NOT_FAILED : KEEP_NOT_FAILED;
    }

    function timestampToUint32(uint256 timestamp) private pure returns (uint32 timestamp32) {
        if (timestamp == type(uint256).max) {
            return type(uint32).max;
        }
        timestamp32 = timestamp.toUint32();
    }

    function gasPriceToUint32(uint256 gasPrice) private pure returns (uint32 gasPrice32) {
        require((gasPrice / 1e6) * 1e6 == gasPrice, 'OS3C');
        gasPrice32 = (gasPrice / 1e6).toUint32();
    }

    function uint32ToGasPrice(uint32 gasPrice32) public pure returns (uint256 gasPrice) {
        gasPrice = uint256(gasPrice32) * 1e6;
    }

    function uintToFloat32(uint256 number) internal pure returns (uint32 float32) {
        // Number is encoded on 4 bytes. 3 bytes for mantissa and 1 for exponent.
        // If the number fits in the mantissa we set the exponent to zero and return.
        if (number < 1 << 24) {
            return uint32(number << 8);
        }
        // We find the exponent by counting the number of trailing zeroes.
        // Simultaneously we remove those zeroes from the number.
        uint32 exponent;
        for (; exponent < 256 - 24; ++exponent) {
            // Last bit is one.
            if (number & 1 == 1) {
                break;
            }
            number = number >> 1;
        }
        // The number must fit in the mantissa.
        require(number < 1 << 24, 'OS1A');
        // Set the first three bytes to the number and the fourth to the exponent.
        float32 = uint32(number << 8) | exponent;
    }

    function float32ToUint(uint32 float32) internal pure returns (uint256 number) {
        // Number is encoded on 4 bytes. 3 bytes for mantissa and 1 for exponent.
        // We get the exponent by extracting the last byte.
        uint256 exponent = float32 & 0xFF;
        // Sanity check. Only triggered for values not encoded with uintToFloat32.
        require(exponent <= 256 - 24, 'OS1B');
        // We get the mantissa by extracting the first three bytes and removing the fourth.
        uint256 mantissa = (float32 & 0xFFFFFF00) >> 8;
        // We add exponent number zeroes after the mantissa.
        number = mantissa << exponent;
    }

    function setOrderDisabled(
        Data storage data,
        address pair,
        Orders.OrderType orderType,
        bool disabled
    ) external {
        require(orderType != Orders.OrderType.Empty, 'OS32');
        uint8 currentSettings = data.orderDisabled[pair];

        // zeros with 1 bit set at position specified by orderType
        uint8 mask = 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 | mask;
        } 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 & (mask ^ 0xff);
        }
        require(currentSettings != data.orderDisabled[pair], 'OS01');
        data.orderDisabled[pair] = currentSettings;

        emit OrderDisabled(pair, orderType, disabled);
    }

    function enqueueDepositOrder(
        Data storage data,
        DepositOrder memory depositOrder,
        uint256 amountIn0,
        uint256 amountIn1
    ) internal {
        ++data.newestOrderId;
        emit DepositEnqueued(data.newestOrderId, depositOrder.validAfterTimestamp, depositOrder.gasPrice);
        data.orderQueue[data.newestOrderId] = StoredOrder(
            DEPOSIT_TYPE,
            depositOrder.validAfterTimestamp,
            getUnwrapAndFailure(depositOrder.unwrap),
            depositOrder.timestamp,
            depositOrder.gasLimit.toUint32(),
            gasPriceToUint32(depositOrder.gasPrice),
            0, // liquidity
            depositOrder.share0.toUint112(),
            depositOrder.share1.toUint112(),
            depositOrder.pairId,
            depositOrder.to,
            uintToFloat32(depositOrder.minSwapPrice),
            uintToFloat32(depositOrder.maxSwapPrice),
            depositOrder.swap,
            depositOrder.priceAccumulator,
            amountIn0.toUint112(),
            amountIn1.toUint112()
        );
    }

    function enqueueWithdrawOrder(Data storage data, WithdrawOrder memory withdrawOrder) internal {
        ++data.newestOrderId;
        emit WithdrawEnqueued(data.newestOrderId, withdrawOrder.validAfterTimestamp, withdrawOrder.gasPrice);
        data.orderQueue[data.newestOrderId] = StoredOrder(
            WITHDRAW_TYPE,
            withdrawOrder.validAfterTimestamp,
            getUnwrapAndFailure(withdrawOrder.unwrap),
            0, // timestamp
            withdrawOrder.gasLimit.toUint32(),
            gasPriceToUint32(withdrawOrder.gasPrice),
            withdrawOrder.liquidity.toUint112(),
            withdrawOrder.amount0Min.toUint112(),
            withdrawOrder.amount1Min.toUint112(),
            withdrawOrder.pairId,
            withdrawOrder.to,
            0, // minSwapPrice
            0, // maxSwapPrice
            false, // swap
            0, // priceAccumulator
            0, // amountLimit0
            0 // amountLimit1
        );
    }

    function enqueueSellOrder(
        Data storage data,
        SellOrder memory sellOrder,
        uint256 amountIn
    ) internal {
        ++data.newestOrderId;
        emit SellEnqueued(data.newestOrderId, sellOrder.validAfterTimestamp, sellOrder.gasPrice);
        data.orderQueue[data.newestOrderId] = StoredOrder(
            sellOrder.inverse ? SELL_INVERTED_TYPE : SELL_TYPE,
            sellOrder.validAfterTimestamp,
            getUnwrapAndFailure(sellOrder.unwrap),
            sellOrder.timestamp,
            sellOrder.gasLimit.toUint32(),
            gasPriceToUint32(sellOrder.gasPrice),
            0, // liquidity
            sellOrder.shareIn.toUint112(),
            sellOrder.amountOutMin.toUint112(),
            sellOrder.pairId,
            sellOrder.to,
            0, // minSwapPrice
            0, // maxSwapPrice
            false, // swap
            sellOrder.priceAccumulator,
            amountIn.toUint112(),
            0 // amountLimit1
        );
    }

    function enqueueBuyOrder(
        Data storage data,
        BuyOrder memory buyOrder,
        uint256 amountInMax
    ) internal {
        ++data.newestOrderId;
        emit BuyEnqueued(data.newestOrderId, buyOrder.validAfterTimestamp, buyOrder.gasPrice);
        data.orderQueue[data.newestOrderId] = StoredOrder(
            buyOrder.inverse ? BUY_INVERTED_TYPE : BUY_TYPE,
            buyOrder.validAfterTimestamp,
            getUnwrapAndFailure(buyOrder.unwrap),
            buyOrder.timestamp,
            buyOrder.gasLimit.toUint32(),
            gasPriceToUint32(buyOrder.gasPrice),
            0, // liquidity
            buyOrder.shareInMax.toUint112(),
            buyOrder.amountOut.toUint112(),
            buyOrder.pairId,
            buyOrder.to,
            0, // minSwapPrice
            0, // maxSwapPrice
            false, // swap
            buyOrder.priceAccumulator,
            amountInMax.toUint112(),
            0 // amountLimit1
        );
    }

    function isRefundFailed(Data storage data, uint256 index) internal view returns (bool) {
        uint8 unwrapAndFailure = data.orderQueue[index].unwrapAndFailure;
        return unwrapAndFailure == UNWRAP_FAILED || unwrapAndFailure == KEEP_FAILED;
    }

    function markRefundFailed(Data storage data) internal {
        StoredOrder storage stored = data.orderQueue[data.lastProcessedOrderId];
        stored.unwrapAndFailure = stored.unwrapAndFailure == UNWRAP_NOT_FAILED ? UNWRAP_FAILED : KEEP_FAILED;
    }

    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 = data.transferGasCosts[depositParams.token0];
            uint256 token1TransferCost = data.transferGasCosts[depositParams.token1];
            require(token0TransferCost != 0 && token1TransferCost != 0, 'OS0F');
            checkOrderParams(
                data,
                depositParams.to,
                depositParams.gasLimit,
                depositParams.submitDeadline,
                ORDER_BASE_COST.add(token0TransferCost).add(token1TransferCost)
            );
        }
        require(depositParams.amount0 != 0 || depositParams.amount1 != 0, 'OS25');
        (address pairAddress, uint32 pairId, bool inverted) = getPair(data, 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) {
                    value = msg.value.sub(depositParams.amount0, 'OS1E');
                } else if (depositParams.token1 == tokenShares.weth) {
                    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, uint32 timestamp) = ITwapOracle(ITwapPair(pairAddress).oracle()).getPriceInfo();
        enqueueDepositOrder(
            data,
            DepositOrder(
                pairId,
                shares0,
                shares1,
                depositParams.minSwapPrice,
                depositParams.maxSwapPrice,
                depositParams.wrap,
                depositParams.swap,
                depositParams.to,
                data.gasPrice,
                depositParams.gasLimit,
                timestamp + data.delay, // validAfterTimestamp
                priceAccumulator,
                timestamp
            ),
            inverted ? depositParams.amount1 : depositParams.amount0,
            inverted ? depositParams.amount0 : depositParams.amount1
        );
    }

    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, uint32 pairId, bool inverted) = getPair(data, withdrawParams.token0, withdrawParams.token1);
        require(!getWithdrawDisabled(data, pair), 'OS0A');
        checkOrderParams(
            data,
            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);
        enqueueWithdrawOrder(
            data,
            WithdrawOrder(
                pairId,
                withdrawParams.liquidity,
                inverted ? withdrawParams.amount1Min : withdrawParams.amount0Min,
                inverted ? withdrawParams.amount0Min : withdrawParams.amount1Min,
                withdrawParams.unwrap,
                withdrawParams.to,
                data.gasPrice,
                withdrawParams.gasLimit,
                timestampToUint32(block.timestamp) + data.delay
            )
        );
    }

    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 = data.transferGasCosts[sellParams.tokenIn];
        require(tokenTransferCost != 0, 'OS0F');
        checkOrderParams(
            data,
            sellParams.to,
            sellParams.gasLimit,
            sellParams.submitDeadline,
            ORDER_BASE_COST.add(tokenTransferCost)
        );
        require(sellParams.amountIn != 0, 'OS24');
        (address pairAddress, uint32 pairId, bool inverted) = getPair(data, sellParams.tokenIn, sellParams.tokenOut);
        require(!getSellDisabled(data, pairAddress), 'OS13');
        uint256 value = msg.value;

        // allocate gas refund
        if (sellParams.tokenIn == tokenShares.weth && sellParams.wrapUnwrap) {
            value = msg.value.sub(sellParams.amountIn, 'OS1E');
        }

        allocateGasRefund(data, value, sellParams.gasLimit);

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

        (uint256 priceAccumulator, uint32 timestamp) = ITwapOracle(ITwapPair(pairAddress).oracle()).getPriceInfo();
        enqueueSellOrder(
            data,
            SellOrder(
                pairId,
                inverted,
                shares,
                sellParams.amountOutMin,
                sellParams.wrapUnwrap,
                sellParams.to,
                data.gasPrice,
                sellParams.gasLimit,
                timestamp + data.delay,
                priceAccumulator,
                timestamp
            ),
            sellParams.amountIn
        );
    }

    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 = data.transferGasCosts[buyParams.tokenIn];
        require(tokenTransferCost != 0, 'OS0F');
        checkOrderParams(
            data,
            buyParams.to,
            buyParams.gasLimit,
            buyParams.submitDeadline,
            ORDER_BASE_COST.add(tokenTransferCost)
        );
        require(buyParams.amountOut != 0, 'OS23');
        (address pairAddress, uint32 pairId, bool inverted) = getPair(data, buyParams.tokenIn, buyParams.tokenOut);
        require(!getBuyDisabled(data, pairAddress), 'OS49');
        uint256 value = msg.value;

        // allocate gas refund
        if (buyParams.tokenIn == tokenShares.weth && 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, uint32 timestamp) = ITwapOracle(ITwapPair(pairAddress).oracle()).getPriceInfo();
        enqueueBuyOrder(
            data,
            BuyOrder(
                pairId,
                inverted,
                shares,
                buyParams.amountOut,
                buyParams.wrapUnwrap,
                buyParams.to,
                data.gasPrice,
                buyParams.gasLimit,
                timestamp + data.delay,
                priceAccumulator,
                timestamp
            ),
            buyParams.amountInMax
        );
    }

    function checkOrderParams(
        Data storage data,
        address to,
        uint256 gasLimit,
        uint32 submitDeadline,
        uint256 minGasLimit
    ) private view {
        require(submitDeadline >= block.timestamp, 'OS04');
        require(gasLimit <= data.maxGasLimit, '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), data.transferGasCosts[address(0)]);
        }
    }

    function updateGasPrice(Data storage data, uint256 gasUsed) external {
        uint256 scale = Math.min(gasUsed, data.maxGasPriceImpact);
        uint256 updated = data.gasPrice.mul(data.gasPriceInertia.sub(scale)).add(tx.gasprice.mul(scale)).div(
            data.gasPriceInertia
        );
        // we lower the precision for gas savings in order queue
        data.gasPrice = updated - (updated % 1e6);
    }

    function setMaxGasLimit(Data storage data, uint256 _maxGasLimit) external {
        require(_maxGasLimit != data.maxGasLimit, 'OS01');
        require(_maxGasLimit <= 10000000, 'OS2B');
        data.maxGasLimit = _maxGasLimit;
        emit MaxGasLimitSet(_maxGasLimit);
    }

    function setGasPriceInertia(Data storage data, uint256 _gasPriceInertia) external {
        require(_gasPriceInertia != data.gasPriceInertia, 'OS01');
        require(_gasPriceInertia >= 1, 'OS35');
        data.gasPriceInertia = _gasPriceInertia;
        emit GasPriceInertiaSet(_gasPriceInertia);
    }

    function setMaxGasPriceImpact(Data storage data, uint256 _maxGasPriceImpact) external {
        require(_maxGasPriceImpact != data.maxGasPriceImpact, 'OS01');
        require(_maxGasPriceImpact <= data.gasPriceInertia, 'OS33');
        data.maxGasPriceImpact = _maxGasPriceImpact;
        emit MaxGasPriceImpactSet(_maxGasPriceImpact);
    }

    function setTransferGasCost(
        Data storage data,
        address token,
        uint256 gasCost
    ) external {
        require(gasCost != data.transferGasCosts[token], 'OS01');
        data.transferGasCosts[token] = gasCost;
        emit TransferGasCostSet(token, gasCost);
    }

    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 getNextOrder(Data storage data) internal view returns (OrderType orderType, uint256 validAfterTimestamp) {
        return getOrder(data, data.lastProcessedOrderId + 1);
    }

    function dequeueCanceledOrder(Data storage data) internal {
        ++data.lastProcessedOrderId;
    }

    function dequeueDepositOrder(Data storage data)
        external
        returns (
            DepositOrder memory order,
            uint256 amountLimit0,
            uint256 amountLimit1
        )
    {
        ++data.lastProcessedOrderId;
        (order, amountLimit0, amountLimit1) = getDepositOrder(data, data.lastProcessedOrderId);
    }

    function dequeueWithdrawOrder(Data storage data) external returns (WithdrawOrder memory order) {
        ++data.lastProcessedOrderId;
        order = getWithdrawOrder(data, data.lastProcessedOrderId);
    }

    function dequeueSellOrder(Data storage data) external returns (SellOrder memory order, uint256 amountLimit) {
        ++data.lastProcessedOrderId;
        (order, amountLimit) = getSellOrder(data, data.lastProcessedOrderId);
    }

    function dequeueBuyOrder(Data storage data) external returns (BuyOrder memory order, uint256 amountLimit) {
        ++data.lastProcessedOrderId;
        (order, amountLimit) = getBuyOrder(data, data.lastProcessedOrderId);
    }

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

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

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

pragma solidity 0.7.6;

// 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;
        }
    }
}

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

pragma solidity 0.7.6;

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;
}

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

pragma solidity 0.7.6;

// 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 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);
            }
        }
    }
}

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

pragma solidity 0.7.6;

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, uint32 priceTimestamp);

    function getSpotPrice() external view returns (uint256);

    function getAveragePrice(uint256 priceAccumulator, uint32 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);
}

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

pragma solidity 0.7.6;

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;

    event UnwrapFailed(address to, uint256 amount);

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

    function sharesToAmount(
        Data storage data,
        address token,
        uint256 share,
        uint256 amountLimit,
        address refundTo
    ) external returns (uint256) {
        if (share == 0) {
            return 0;
        }
        if (token == data.weth) {
            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 == data.weth) {
            if (wrap) {
                require(msg.value >= amount, 'TS03');
                IWETH(token).deposit{ value: amount }();
            } else {
                token.safeTransferFrom(msg.sender, address(this), amount);
            }
            return amount;
        } else {
            uint256 balanceBefore = IERC20(token).balanceOf(address(this));
            uint256 totalTokenShares = data.totalShares[token];
            require(balanceBefore > 0 || totalTokenShares == 0, 'TS30');
            if (totalTokenShares == 0) {
                totalTokenShares = balanceBefore;
            }
            token.safeTransferFrom(msg.sender, address(this), amount);
            uint256 balanceAfter = IERC20(token).balanceOf(address(this));
            require(balanceAfter > balanceBefore, 'TS2C');
            if (balanceBefore > 0) {
                uint256 newShares = totalTokenShares.mul(balanceAfter).div(balanceBefore);
                data.totalShares[token] = newShares;
                return newShares - totalTokenShares;
            } else {
                data.totalShares[token] = balanceAfter;
                return balanceAfter;
            }
        }
    }

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

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

pragma solidity 0.7.6;

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);
}

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

pragma solidity 0.7.6;

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);
}

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

pragma solidity 0.7.6;

interface IWETH {
    function deposit() external payable;

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

    function withdraw(uint256) external;
}

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

pragma solidity 0.7.6;

// 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 }('');
    }
}

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

pragma solidity 0.7.6;

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);
}

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

pragma solidity 0.7.6;

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

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

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

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"orderId","type":"uint256"},{"indexed":false,"internalType":"uint32","name":"validAfterTimestamp","type":"uint32"},{"indexed":false,"internalType":"uint256","name":"gasPrice","type":"uint256"}],"name":"BuyEnqueued","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"orderId","type":"uint256"},{"indexed":false,"internalType":"uint32","name":"validAfterTimestamp","type":"uint32"},{"indexed":false,"internalType":"uint256","name":"gasPrice","type":"uint256"}],"name":"DepositEnqueued","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":"pair","type":"address"},{"indexed":false,"internalType":"enum Orders.OrderType","name":"orderType","type":"uint8"},{"indexed":false,"internalType":"bool","name":"disabled","type":"bool"}],"name":"OrderDisabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"RefundFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"orderId","type":"uint256"},{"indexed":false,"internalType":"uint32","name":"validAfterTimestamp","type":"uint32"},{"indexed":false,"internalType":"uint256","name":"gasPrice","type":"uint256"}],"name":"SellEnqueued","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"orderId","type":"uint256"},{"indexed":false,"internalType":"uint32","name":"validAfterTimestamp","type":"uint32"},{"indexed":false,"internalType":"uint256","name":"gasPrice","type":"uint256"}],"name":"WithdrawEnqueued","type":"event"},{"inputs":[],"name":"ETHER_TRANSFER_CALL_COST","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ORDER_BASE_COST","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAIR_TRANSFER_COST","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REFUND_BASE_COST","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"gasPrice32","type":"uint32"}],"name":"uint32ToGasPrice","outputs":[{"internalType":"uint256","name":"gasPrice","type":"uint256"}],"stateMutability":"pure","type":"function"}]

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