Contract 0x1b80e501e397dbf8b7d86d06bd42679d61cac756 2

Txn Hash Method
Block
From
To
Value [Txn Fee]
0x9ecb6998d0a5474affe6f7eed1aaefeefce8cd0bff9b810b74ed5c114d01de7cApprove239560312022-12-22 8:12:3647 days 9 hrs ago0x43b44b52de1b26b90b3abaa5b405946e4801925e IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.0012543264 26.94
0x70406f2d6b7efbc6c7033f91ccff9abb68bf6b4a066f6f9e401e9cc7e835f2d8Swap Base Token ...235930012022-12-13 19:06:2155 days 22 hrs ago0x983cd18ed6d501e6e01285f2a06df0767fb7297f IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.002929787 26.5
0x2f6510672ad02245dbedfd67e2357e2e6876653b288d6535e6354ba95d2cfef7Swap Quote Token...235929162022-12-13 19:03:2755 days 22 hrs ago0x983cd18ed6d501e6e01285f2a06df0767fb7297f IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.003055609 26.5
0x3dc3b8c6a7caf60104673b67fd158ed7c82f655aa0df20e5c267404942317411Swap Base Token ...235920122022-12-13 18:32:4755 days 23 hrs ago0x983cd18ed6d501e6e01285f2a06df0767fb7297f IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.002931059 26.5
0x118338800ca290baf25f403a45c6e079cfb0cc21761749c3f46728bf869971ddApprove235830242022-12-13 13:22:5856 days 4 hrs ago0x64ea0fa30efed0d53900fcd4fb10c6c47262f0d9 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.000808972825 27.8227
0xde5aaf0c4c82ab3a63362b330cd730a67750e44ec6688248c5659bcb3a3d7c83Approve235751092022-12-13 8:52:2656 days 8 hrs ago0xb34ee365b63b317da18bbfb1f30acfd55cebd9de IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00076789716 26.41
0x0e9c3c209d9f0b0467ee782d8bfae9990194ffb61692186be6574670b94c3fd8Remove Liquidity235749322022-12-13 8:46:1556 days 9 hrs ago0xb34ee365b63b317da18bbfb1f30acfd55cebd9de IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.003506016772 26.3254
0x470a5a2b3be7d9be756a3dbc70c07ff4d87acbba6858d876a7eb896f6ab16da4Remove Liquidity235735652022-12-13 7:59:3656 days 9 hrs ago0xa68df4275f54b17aff43d3c3cefcc8dfef1c690c IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00398242 26.5
0xc0d1ed592507d5870c21471b511f56364efd723784c1ae84e6870150b3611206Remove Liquidity235729382022-12-13 7:38:2156 days 10 hrs ago0x887c3599c4826f7b3cde82003b894430f27d5b92 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00387483 26.5
0x8f98d1e6ea0d19c7d58d4643cfa761de28cc33a486e5a573b3cf02cf29fcceabRemove Liquidity235719392022-12-13 7:04:4656 days 10 hrs ago0x0342bf051724c2697362a3b947e170b4bea63299 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.004081442746 27.913026577
0x0cd570dc5095c774568c6e2b24ce5270426267dcbdb2d81417acbcf4a4bdbe21Remove Liquidity235712612022-12-13 6:41:3256 days 11 hrs ago0x5897eabd827d38a5a8042051b9210bf6802e89d6 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.0039072826
0xea2d9927d5db9921a5bc750b04b443c558ed73d69dd51ffaba6cc968d71149a7Approve235711762022-12-13 6:38:3756 days 11 hrs ago0x5897eabd827d38a5a8042051b9210bf6802e89d6 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00078505227
0x603fcfdc5e4e614f93bbf6db4adb94c2f50324548d763bb1957b96ac4b60acd4Approve235707462022-12-13 6:23:5656 days 11 hrs ago0xc28f85d6a2cd2252dac06f3db42a17033c4e7791 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00079959 27.5
0xda3cfba660ede21984849bd73699d61fe5d00249d90af29d14d85abedf52dfb2Remove Liquidity235705812022-12-13 6:18:2256 days 11 hrs ago0x197dfea49c88554dbdaacbc0dbf7af425e150e79 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00432798 26.5
0x0c25b55600473eb37224bd8cea29b5ac15b722aae141cf8af3feb96455acba2fRemove Liquidity235705222022-12-13 6:16:2056 days 11 hrs ago0xc28f85d6a2cd2252dac06f3db42a17033c4e7791 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00387483 26.5
0x6dffea04281d3f897f15338da20642db76d2ae08c469fb27e797d8938f4c6de7Remove Liquidity235699512022-12-13 5:56:4556 days 11 hrs ago0x2da11a9bc34af5db2e11c3320298da98edf2f1c6 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00487134 27
0xfddd586f1540bcbb1b3fb0b0b1e0bc177eb1d36c4944d2d7d273eb1def32385eSwap Base Token ...235696342022-12-13 5:45:4656 days 12 hrs ago0x50258a2ae0b3065754936828cd7814731c6fc008 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.002432092 26
0x99315d0f6e2c3e4aad1d463bc996006d2967e44bea49b3ed5110dfc1ebdc654fRemove Liquidity235689482022-12-13 5:22:0756 days 12 hrs ago0x0740655604a8d15dafd78d4dfb335f4e8016b369 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.004532398764 27.080438104
0x74df662288913cda5333af0f57a51332de803ebd4f32f99144172c9ddacfa543Remove Liquidity235688752022-12-13 5:19:4156 days 12 hrs ago0x50258a2ae0b3065754936828cd7814731c6fc008 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.0047958918 29.365
0xafa6ff067647b6f69cfe3f3325b8b09a7139a4a1c9e88c1b7625ab963db832e4Swap Base Token ...235687892022-12-13 5:16:4256 days 12 hrs ago0x4c795584971c23d443490cd8941698ff840999bc IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.002875132 26
0x80e1447e5f2f2ac01d07ccec7931575916e7d1ac35a675890c5a4776e4f59989Swap Base Token ...235687232022-12-13 5:14:2256 days 12 hrs ago0x4c795584971c23d443490cd8941698ff840999bc IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.000703638 26
0xdd30b39ca576c63a764d47d216d94621371c74da4a6d5ddb647c48a10703f7c7Remove Liquidity235686602022-12-13 5:12:1656 days 12 hrs ago0xd00dd00d1befb7da65a4a133f13a26f8f99d17d8 IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.004435252 26.5
0xe0d1d38d8546917ff9dfc1f569271a6b8d0982db17e4492a249f0aee54aa35caSwap Quote Token...235686542022-12-13 5:12:0356 days 12 hrs ago0x4c795584971c23d443490cd8941698ff840999bc IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.000704132 26
0xfac60359e6c25f748a8e7e837547e3325b6fc4592f0976a35d4a7081212d0305Swap Base Token ...235686312022-12-13 5:11:1156 days 12 hrs ago0x4c795584971c23d443490cd8941698ff840999bc IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00091403 26
0x72dae3f58b75c988b25fe8e6b421627bbe127e235ae1fb3efc1612a0af26da12Swap Quote Token...235685962022-12-13 5:10:0156 days 12 hrs ago0x4c795584971c23d443490cd8941698ff840999bc IN  0x1b80e501e397dbf8b7d86d06bd42679d61cac7560 AVAX0.00168701 26
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0xe54aa8fe81d83bce2587f55ae31de7243817a0a49901b7e4eee4e62fa140814a131607372022-04-08 17:39:28305 days 10 mins ago 0x8b3d780db8842593d8b61632a2f76c4d4f31d7c3  Contract Creation0 AVAX
[ Download CSV Export 
Loading

Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x4ae1da57f2d6b2e9a23d07e264aa2b3bbcaed19a

Contract Name:
Exchange

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 100000 runs

Other Settings:
default evmVersion
File 1 of 10 : Exchange.sol
//SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.4;

import "../libraries/MathLib.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "../interfaces/IExchangeFactory.sol";

/**
 * @title Exchange contract for Elastic Swap representing a single ERC20 pair of tokens to be swapped.
 * @author Elastic DAO
 * @notice This contract provides all of the needed functionality for a liquidity provider to supply/withdraw ERC20
 * tokens and traders to swap tokens for one another.
 */
contract Exchange is ERC20, ReentrancyGuard {
    using MathLib for uint256;
    using SafeERC20 for IERC20;

    address public immutable baseToken; // address of ERC20 base token (elastic or fixed supply)
    address public immutable quoteToken; // address of ERC20 quote token (WETH or a stable coin w/ fixed supply)
    address public immutable exchangeFactoryAddress;

    uint256 public constant TOTAL_LIQUIDITY_FEE = 50; // fee provided to liquidity providers + DAO in basis points
    uint256 public constant MINIMUM_LIQUIDITY = 1e3;

    MathLib.InternalBalances public internalBalances;

    event AddLiquidity(
        address indexed liquidityProvider,
        uint256 baseTokenQtyAdded,
        uint256 quoteTokenQtyAdded
    );
    event RemoveLiquidity(
        address indexed liquidityProvider,
        uint256 baseTokenQtyRemoved,
        uint256 quoteTokenQtyRemoved
    );
    event Swap(
        address indexed sender,
        uint256 baseTokenQtyIn,
        uint256 quoteTokenQtyIn,
        uint256 baseTokenQtyOut,
        uint256 quoteTokenQtyOut
    );

    /**
     * @dev Called to check timestamps from users for expiration of their calls.
     */
    modifier isNotExpired(uint256 _expirationTimeStamp) {
        require(_expirationTimeStamp >= block.timestamp, "Exchange: EXPIRED");
        _;
    }

    /**
     * @notice called by the exchange factory to create a new erc20 token swap pair (do not call this directly!)
     * @param _name The human readable name of this pair (also used for the liquidity token name)
     * @param _symbol Shortened symbol for trading pair (also used for the liquidity token symbol)
     * @param _baseToken address of the ERC20 base token in the pair. This token can have a fixed or elastic supply
     * @param _quoteToken address of the ERC20 quote token in the pair. This token is assumed to have a fixed supply.
     * @param _exchangeFactoryAddress address of the exchange factory
     */
    constructor(
        string memory _name,
        string memory _symbol,
        address _baseToken,
        address _quoteToken,
        address _exchangeFactoryAddress
    ) ERC20(_name, _symbol) {
        baseToken = _baseToken;
        quoteToken = _quoteToken;
        exchangeFactoryAddress = _exchangeFactoryAddress;
    }

    /**
     * @notice primary entry point for a liquidity provider to add new liquidity (base and quote tokens) to the exchange
     * and receive liquidity tokens in return.
     * Requires approvals to be granted to this exchange for both base and quote tokens.
     * @param _baseTokenQtyDesired qty of baseTokens that you would like to add to the exchange
     * @param _quoteTokenQtyDesired qty of quoteTokens that you would like to add to the exchange
     * @param _baseTokenQtyMin minimum acceptable qty of baseTokens that will be added (or transaction will revert)
     * @param _quoteTokenQtyMin minimum acceptable qty of quoteTokens that will be added (or transaction will revert)
     * @param _liquidityTokenRecipient address for the exchange to issue the resulting liquidity tokens from
     * this transaction to
     * @param _expirationTimestamp timestamp that this transaction must occur before (or transaction will revert)
     */
    function addLiquidity(
        uint256 _baseTokenQtyDesired,
        uint256 _quoteTokenQtyDesired,
        uint256 _baseTokenQtyMin,
        uint256 _quoteTokenQtyMin,
        address _liquidityTokenRecipient,
        uint256 _expirationTimestamp
    ) external nonReentrant() isNotExpired(_expirationTimestamp) {
        uint256 totalSupply = this.totalSupply();
        MathLib.TokenQtys memory tokenQtys =
            MathLib.calculateAddLiquidityQuantities(
                _baseTokenQtyDesired,
                _quoteTokenQtyDesired,
                _baseTokenQtyMin,
                _quoteTokenQtyMin,
                IERC20(baseToken).balanceOf(address(this)),
                totalSupply,
                internalBalances
            );

        internalBalances.kLast =
            internalBalances.baseTokenReserveQty *
            internalBalances.quoteTokenReserveQty;

        if (tokenQtys.liquidityTokenFeeQty != 0) {
            // mint liquidity tokens to fee address for k growth.
            _mint(
                IExchangeFactory(exchangeFactoryAddress).feeAddress(),
                tokenQtys.liquidityTokenFeeQty
            );
        }

        bool isExchangeEmpty = totalSupply == 0;
        if (isExchangeEmpty) {
            // check if this the first LP provider, if so, we need to lock some minimum dust liquidity.
            require(
                tokenQtys.liquidityTokenQty > MINIMUM_LIQUIDITY,
                "Exchange: INITIAL_DEPOSIT_MIN"
            );
            unchecked {
                tokenQtys.liquidityTokenQty -= MINIMUM_LIQUIDITY;
            }
            _mint(address(this), MINIMUM_LIQUIDITY); // mint to this address, total supply will never be 0 again
        }

        _mint(_liquidityTokenRecipient, tokenQtys.liquidityTokenQty); // mint liquidity tokens to recipient

        if (tokenQtys.baseTokenQty != 0) {
            // transfer base tokens to Exchange
            IERC20(baseToken).safeTransferFrom(
                msg.sender,
                address(this),
                tokenQtys.baseTokenQty
            );

            if (isExchangeEmpty) {
                require(
                    IERC20(baseToken).balanceOf(address(this)) ==
                        tokenQtys.baseTokenQty,
                    "Exchange: FEE_ON_TRANSFER_NOT_SUPPORTED"
                );
            }
        }

        if (tokenQtys.quoteTokenQty != 0) {
            // transfer quote tokens to Exchange
            IERC20(quoteToken).safeTransferFrom(
                msg.sender,
                address(this),
                tokenQtys.quoteTokenQty
            );
        }

        emit AddLiquidity(
            msg.sender,
            tokenQtys.baseTokenQty,
            tokenQtys.quoteTokenQty
        );
    }

    /**
     * @notice called by a liquidity provider to redeem liquidity tokens from the exchange and receive back
     * base and quote tokens. Required approvals to be granted to this exchange for the liquidity token
     * @param _liquidityTokenQty qty of liquidity tokens that you would like to redeem
     * @param _baseTokenQtyMin minimum acceptable qty of base tokens to receive back (or transaction will revert)
     * @param _quoteTokenQtyMin minimum acceptable qty of quote tokens to receive back (or transaction will revert)
     * @param _tokenRecipient address for the exchange to issue the resulting base and
     * quote tokens from this transaction to
     * @param _expirationTimestamp timestamp that this transaction must occur before (or transaction will revert)
     */
    function removeLiquidity(
        uint256 _liquidityTokenQty,
        uint256 _baseTokenQtyMin,
        uint256 _quoteTokenQtyMin,
        address _tokenRecipient,
        uint256 _expirationTimestamp
    ) external nonReentrant() isNotExpired(_expirationTimestamp) {
        require(this.totalSupply() != 0, "Exchange: INSUFFICIENT_LIQUIDITY");
        require(
            _baseTokenQtyMin != 0 && _quoteTokenQtyMin != 0,
            "Exchange: MINS_MUST_BE_GREATER_THAN_ZERO"
        );

        uint256 baseTokenReserveQty =
            IERC20(baseToken).balanceOf(address(this));
        uint256 quoteTokenReserveQty =
            IERC20(quoteToken).balanceOf(address(this));

        uint256 totalSupplyOfLiquidityTokens = this.totalSupply();
        // calculate any DAO fees here.
        uint256 liquidityTokenFeeQty =
            MathLib.calculateLiquidityTokenFees(
                totalSupplyOfLiquidityTokens,
                internalBalances
            );

        // we need to factor this quantity in to any total supply before redemption
        totalSupplyOfLiquidityTokens += liquidityTokenFeeQty;

        uint256 baseTokenQtyToReturn =
            (_liquidityTokenQty * baseTokenReserveQty) /
                totalSupplyOfLiquidityTokens;
        uint256 quoteTokenQtyToReturn =
            (_liquidityTokenQty * quoteTokenReserveQty) /
                totalSupplyOfLiquidityTokens;

        require(
            baseTokenQtyToReturn >= _baseTokenQtyMin,
            "Exchange: INSUFFICIENT_BASE_QTY"
        );

        require(
            quoteTokenQtyToReturn >= _quoteTokenQtyMin,
            "Exchange: INSUFFICIENT_QUOTE_QTY"
        );

        // this ensures that we are removing the equivalent amount of decay
        // when this person exits.
        {
            //scoping to avoid stack too deep errors
            uint256 internalBaseTokenReserveQty =
                internalBalances.baseTokenReserveQty;
            uint256 baseTokenQtyToRemoveFromInternalAccounting =
                (_liquidityTokenQty * internalBaseTokenReserveQty) /
                    totalSupplyOfLiquidityTokens;

            internalBalances.baseTokenReserveQty = internalBaseTokenReserveQty =
                internalBaseTokenReserveQty -
                baseTokenQtyToRemoveFromInternalAccounting;

            // We should ensure no possible overflow here.
            uint256 internalQuoteTokenReserveQty =
                internalBalances.quoteTokenReserveQty;
            if (quoteTokenQtyToReturn > internalQuoteTokenReserveQty) {
                internalBalances
                    .quoteTokenReserveQty = internalQuoteTokenReserveQty = 0;
            } else {
                internalBalances
                    .quoteTokenReserveQty = internalQuoteTokenReserveQty =
                    internalQuoteTokenReserveQty -
                    quoteTokenQtyToReturn;
            }

            internalBalances.kLast =
                internalBaseTokenReserveQty *
                internalQuoteTokenReserveQty;
        }

        if (liquidityTokenFeeQty != 0) {
            _mint(
                IExchangeFactory(exchangeFactoryAddress).feeAddress(),
                liquidityTokenFeeQty
            );
        }

        _burn(msg.sender, _liquidityTokenQty);
        IERC20(baseToken).safeTransfer(_tokenRecipient, baseTokenQtyToReturn);
        IERC20(quoteToken).safeTransfer(_tokenRecipient, quoteTokenQtyToReturn);
        emit RemoveLiquidity(
            msg.sender,
            baseTokenQtyToReturn,
            quoteTokenQtyToReturn
        );
    }

    /**
     * @notice swaps base tokens for a minimum amount of quote tokens.  Fees are included in all transactions.
     * The exchange must be granted approvals for the base token by the caller.
     * @param _baseTokenQty qty of base tokens to swap
     * @param _minQuoteTokenQty minimum qty of quote tokens to receive in exchange for
     * your base tokens (or the transaction will revert)
     * @param _expirationTimestamp timestamp that this transaction must occur before (or transaction will revert)
     */
    function swapBaseTokenForQuoteToken(
        uint256 _baseTokenQty,
        uint256 _minQuoteTokenQty,
        uint256 _expirationTimestamp
    ) external nonReentrant() isNotExpired(_expirationTimestamp) {
        require(
            _baseTokenQty != 0 && _minQuoteTokenQty != 0,
            "Exchange: INSUFFICIENT_TOKEN_QTY"
        );

        uint256 quoteTokenQty =
            MathLib.calculateQuoteTokenQty(
                _baseTokenQty,
                _minQuoteTokenQty,
                TOTAL_LIQUIDITY_FEE,
                internalBalances
            );

        IERC20(baseToken).safeTransferFrom(
            msg.sender,
            address(this),
            _baseTokenQty
        );

        IERC20(quoteToken).safeTransfer(msg.sender, quoteTokenQty);
        emit Swap(msg.sender, _baseTokenQty, 0, 0, quoteTokenQty);
    }

    /**
     * @notice swaps quote tokens for a minimum amount of base tokens.  Fees are included in all transactions.
     * The exchange must be granted approvals for the quote token by the caller.
     * @param _quoteTokenQty qty of quote tokens to swap
     * @param _minBaseTokenQty minimum qty of base tokens to receive in exchange for
     * your quote tokens (or the transaction will revert)
     * @param _expirationTimestamp timestamp that this transaction must occur before (or transaction will revert)
     */
    function swapQuoteTokenForBaseToken(
        uint256 _quoteTokenQty,
        uint256 _minBaseTokenQty,
        uint256 _expirationTimestamp
    ) external nonReentrant() isNotExpired(_expirationTimestamp) {
        require(
            _quoteTokenQty != 0 && _minBaseTokenQty != 0,
            "Exchange: INSUFFICIENT_TOKEN_QTY"
        );

        uint256 baseTokenQty =
            MathLib.calculateBaseTokenQty(
                _quoteTokenQty,
                _minBaseTokenQty,
                IERC20(baseToken).balanceOf(address(this)),
                TOTAL_LIQUIDITY_FEE,
                internalBalances
            );

        IERC20(quoteToken).safeTransferFrom(
            msg.sender,
            address(this),
            _quoteTokenQty
        );

        IERC20(baseToken).safeTransfer(msg.sender, baseTokenQty);
        emit Swap(msg.sender, 0, _quoteTokenQty, baseTokenQty, 0);
    }
}

File 2 of 10 : MathLib.sol
//SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.4;

/**
 * @title MathLib
 * @author ElasticDAO
 */
library MathLib {
    struct InternalBalances {
        // x*y=k - we track these internally to compare to actual balances of the ERC20's
        // in order to calculate the "decay" or the amount of balances that are not
        // participating in the pricing curve and adding additional liquidity to swap.
        uint256 baseTokenReserveQty; // x
        uint256 quoteTokenReserveQty; // y
        uint256 kLast; // as of the last add / rem liquidity event
    }

    // aids in avoiding stack too deep errors.
    struct TokenQtys {
        uint256 baseTokenQty;
        uint256 quoteTokenQty;
        uint256 liquidityTokenQty;
        uint256 liquidityTokenFeeQty;
    }

    uint256 public constant BASIS_POINTS = 10000;
    uint256 public constant WAD = 1e18; // represent a decimal with 18 digits of precision

    /**
     * @dev divides two float values, required since solidity does not handle
     * floating point values.
     *
     * inspiration: https://github.com/dapphub/ds-math/blob/master/src/math.sol
     *
     * NOTE: this rounds to the nearest integer (up or down). For example .666666 would end up
     * rounding to .66667.
     *
     * @return uint256 wad value (decimal with 18 digits of precision)
     */
    function wDiv(uint256 a, uint256 b) public pure returns (uint256) {
        return ((a * WAD) + (b / 2)) / b;
    }

    /**
     * @dev rounds a integer (a) to the nearest n places.
     * IE roundToNearest(123, 10) would round to the nearest 10th place (120).
     */
    function roundToNearest(uint256 a, uint256 n)
        public
        pure
        returns (uint256)
    {
        return ((a + (n / 2)) / n) * n;
    }

    /**
     * @dev multiplies two float values, required since solidity does not handle
     * floating point values
     *
     * inspiration: https://github.com/dapphub/ds-math/blob/master/src/math.sol
     *
     * @return uint256 wad value (decimal with 18 digits of precision)
     */
    function wMul(uint256 a, uint256 b) public pure returns (uint256) {
        return ((a * b) + (WAD / 2)) / WAD;
    }

    /**
     * @dev calculates an absolute diff between two integers. Basically the solidity
     * equivalent of Math.abs(a-b);
     */
    function diff(uint256 a, uint256 b) public pure returns (uint256) {
        if (a >= b) {
            return a - b;
        }
        return b - a;
    }

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

    /**
     * @dev defines the amount of decay needed in order for us to require a user to handle the
     * decay prior to a double asset entry as the equivalent of 1 unit of quote token
     */
    function isSufficientDecayPresent(
        uint256 _baseTokenReserveQty,
        InternalBalances memory _internalBalances
    ) public pure returns (bool) {
        return (wDiv(
            diff(_baseTokenReserveQty, _internalBalances.baseTokenReserveQty) *
                WAD,
            wDiv(
                _internalBalances.baseTokenReserveQty,
                _internalBalances.quoteTokenReserveQty
            )
        ) >= WAD); // the amount of base token (a) decay is greater than 1 unit of quote token (token b)
    }

    /**
     * @dev used to calculate the qty of token a liquidity provider
     * must add in order to maintain the current reserve ratios
     * @param _tokenAQty base or quote token qty to be supplied by the liquidity provider
     * @param _tokenAReserveQty current reserve qty of the base or quote token (same token as tokenA)
     * @param _tokenBReserveQty current reserve qty of the other base or quote token (not tokenA)
     */
    function calculateQty(
        uint256 _tokenAQty,
        uint256 _tokenAReserveQty,
        uint256 _tokenBReserveQty
    ) public pure returns (uint256 tokenBQty) {
        require(_tokenAQty != 0, "MathLib: INSUFFICIENT_QTY");
        require(
            _tokenAReserveQty != 0 && _tokenBReserveQty != 0,
            "MathLib: INSUFFICIENT_LIQUIDITY"
        );
        tokenBQty = (_tokenAQty * _tokenBReserveQty) / _tokenAReserveQty;
    }

    /**
     * @dev used to calculate the qty of token a trader will receive (less fees)
     * given the qty of token A they are providing
     * @param _tokenASwapQty base or quote token qty to be swapped by the trader
     * @param _tokenAReserveQty current reserve qty of the base or quote token (same token as tokenA)
     * @param _tokenBReserveQty current reserve qty of the other base or quote token (not tokenA)
     * @param _liquidityFeeInBasisPoints fee to liquidity providers represented in basis points
     */
    function calculateQtyToReturnAfterFees(
        uint256 _tokenASwapQty,
        uint256 _tokenAReserveQty,
        uint256 _tokenBReserveQty,
        uint256 _liquidityFeeInBasisPoints
    ) public pure returns (uint256 qtyToReturn) {
        uint256 tokenASwapQtyLessFee =
            _tokenASwapQty * (BASIS_POINTS - _liquidityFeeInBasisPoints);
        qtyToReturn =
            (tokenASwapQtyLessFee * _tokenBReserveQty) /
            ((_tokenAReserveQty * BASIS_POINTS) + tokenASwapQtyLessFee);
    }

    /**
     * @dev used to calculate the qty of liquidity tokens (deltaRo) we will be issued to a supplier
     * of a single asset entry when base token decay is present.
     * @param _baseTokenReserveBalance the total balance (external) of base tokens in our pool (Alpha)
     * @param _totalSupplyOfLiquidityTokens the total supply of our exchange's liquidity tokens (aka Ro)
     * @param _tokenQtyAToAdd the amount of tokens being added by the caller to remove the current decay
     * @param _internalTokenAReserveQty the internal balance (X or Y) of token A as a result of this transaction
     * @param _omega - ratio of internal balances of baseToken and quoteToken: baseToken/quoteToken
     * @return liquidityTokenQty qty of liquidity tokens to be issued in exchange
     */
    function calculateLiquidityTokenQtyForSingleAssetEntryWithBaseTokenDecay(
        uint256 _baseTokenReserveBalance,
        uint256 _totalSupplyOfLiquidityTokens,
        uint256 _tokenQtyAToAdd,
        uint256 _internalTokenAReserveQty,
        uint256 _omega
    ) public pure returns (uint256 liquidityTokenQty) {
        /**
        
        (is the formula in the terms of quoteToken)
                    ΔY 
            = ---------------------                                                    
                Alpha/Omega + Y'


         */
        uint256 wRatio = wDiv(_baseTokenReserveBalance, _omega);
        uint256 denominator = wRatio + _internalTokenAReserveQty;
        uint256 wGamma = wDiv(_tokenQtyAToAdd, denominator);

        liquidityTokenQty =
            wDiv(
                wMul(_totalSupplyOfLiquidityTokens * WAD, wGamma),
                WAD - wGamma
            ) /
            WAD;
    }

    /**
     * @dev used to calculate the qty of liquidity tokens (deltaRo) we will be issued to a supplier
     * of a single asset entry when quote decay is present.
     * @param _baseTokenReserveBalance the total balance (external) of base tokens in our pool (Alpha)
     * @param _totalSupplyOfLiquidityTokens the total supply of our exchange's liquidity tokens (aka Ro)
     * @param _tokenQtyAToAdd the amount of tokens being added by the caller to remove the current decay
     * @param _internalTokenAReserveQty the internal balance (X or Y) of token A as a result of this transaction
     * @return liquidityTokenQty qty of liquidity tokens to be issued in exchange
     */
    function calculateLiquidityTokenQtyForSingleAssetEntryWithQuoteTokenDecay(
        uint256 _baseTokenReserveBalance,
        uint256 _totalSupplyOfLiquidityTokens,
        uint256 _tokenQtyAToAdd,
        uint256 _internalTokenAReserveQty
    ) public pure returns (uint256 liquidityTokenQty) {
        /**
        
               ΔX
        = -------------------  / (denominator may be Alpha' instead of X)
           X + (Alpha + ΔX)

        */

        uint256 denominator =
            _internalTokenAReserveQty +
                _baseTokenReserveBalance +
                _tokenQtyAToAdd;
        uint256 wGamma = wDiv(_tokenQtyAToAdd, denominator);

        liquidityTokenQty =
            wDiv(
                wMul(_totalSupplyOfLiquidityTokens * WAD, wGamma),
                WAD - wGamma
            ) /
            WAD;
    }

    /**
     * @dev used to calculate the qty of liquidity tokens (deltaRo) we will be issued to a supplier
     * of a single asset entry when decay is present.
     * @param _totalSupplyOfLiquidityTokens the total supply of our exchange's liquidity tokens (aka Ro)
     * @param _quoteTokenQty the amount of quote token the user it adding to the pool (deltaB or deltaY)
     * @param _quoteTokenReserveBalance the total balance (external) of quote tokens in our pool (Beta)
     *
     * @return liquidityTokenQty qty of liquidity tokens to be issued in exchange
     */
    function calculateLiquidityTokenQtyForDoubleAssetEntry(
        uint256 _totalSupplyOfLiquidityTokens,
        uint256 _quoteTokenQty,
        uint256 _quoteTokenReserveBalance
    ) public pure returns (uint256 liquidityTokenQty) {
        liquidityTokenQty =
            (_quoteTokenQty * _totalSupplyOfLiquidityTokens) /
            _quoteTokenReserveBalance;
    }

    /**
     * @dev used to calculate the qty of quote token required and liquidity tokens (deltaRo) to be issued
     * in order to add liquidity and remove base token decay.
     * @param _quoteTokenQtyDesired the amount of quote token the user wants to contribute
     * @param _baseTokenReserveQty the external base token reserve qty prior to this transaction
     * @param _totalSupplyOfLiquidityTokens the total supply of our exchange's liquidity tokens (aka Ro)
     * @param _internalBalances internal balances struct from our exchange's internal accounting
     *
     *
     * @return quoteTokenQty qty of quote token the user must supply
     * @return liquidityTokenQty qty of liquidity tokens to be issued in exchange
     */
    function calculateAddQuoteTokenLiquidityQuantities(
        uint256 _quoteTokenQtyDesired,
        uint256 _baseTokenReserveQty,
        uint256 _totalSupplyOfLiquidityTokens,
        InternalBalances storage _internalBalances
    ) public returns (uint256 quoteTokenQty, uint256 liquidityTokenQty) {
        uint256 baseTokenDecay =
            _baseTokenReserveQty - _internalBalances.baseTokenReserveQty;

        // determine max amount of quote token that can be added to offset the current decay
        uint256 wInternalBaseTokenToQuoteTokenRatio =
            wDiv(
                _internalBalances.baseTokenReserveQty,
                _internalBalances.quoteTokenReserveQty
            );

        // alphaDecay / omega (A/B)
        uint256 maxQuoteTokenQty =
            wDiv(baseTokenDecay, wInternalBaseTokenToQuoteTokenRatio);

        if (_quoteTokenQtyDesired > maxQuoteTokenQty) {
            quoteTokenQty = maxQuoteTokenQty;
        } else {
            quoteTokenQty = _quoteTokenQtyDesired;
        }

        uint256 baseTokenQtyDecayChange =
            roundToNearest(
                (quoteTokenQty * wInternalBaseTokenToQuoteTokenRatio),
                WAD
            ) / WAD;

        require(
            baseTokenQtyDecayChange != 0,
            "MathLib: INSUFFICIENT_CHANGE_IN_DECAY"
        );
        //x += alphaDecayChange
        //y += deltaBeta
        _internalBalances.baseTokenReserveQty += baseTokenQtyDecayChange;
        _internalBalances.quoteTokenReserveQty += quoteTokenQty;

        // calculate the number of liquidity tokens to return to user using
        liquidityTokenQty = calculateLiquidityTokenQtyForSingleAssetEntryWithBaseTokenDecay(
            _baseTokenReserveQty,
            _totalSupplyOfLiquidityTokens,
            quoteTokenQty,
            _internalBalances.quoteTokenReserveQty,
            wInternalBaseTokenToQuoteTokenRatio
        );
        return (quoteTokenQty, liquidityTokenQty);
    }

    /**
     * @dev used to calculate the qty of base tokens required and liquidity tokens (deltaRo) to be issued
     * in order to add liquidity and remove base token decay.
     * @param _baseTokenQtyDesired the amount of base token the user wants to contribute
     * @param _baseTokenQtyMin the minimum amount of base token the user wants to contribute (allows for slippage)
     * @param _baseTokenReserveQty the external base token reserve qty prior to this transaction
     * @param _totalSupplyOfLiquidityTokens the total supply of our exchange's liquidity tokens (aka Ro)
     * @param _internalBalances internal balances struct from our exchange's internal accounting
     *
     * @return baseTokenQty qty of base token the user must supply
     * @return liquidityTokenQty qty of liquidity tokens to be issued in exchange
     */
    function calculateAddBaseTokenLiquidityQuantities(
        uint256 _baseTokenQtyDesired,
        uint256 _baseTokenQtyMin,
        uint256 _baseTokenReserveQty,
        uint256 _totalSupplyOfLiquidityTokens,
        InternalBalances memory _internalBalances
    ) public pure returns (uint256 baseTokenQty, uint256 liquidityTokenQty) {
        uint256 maxBaseTokenQty =
            _internalBalances.baseTokenReserveQty - _baseTokenReserveQty;
        require(
            _baseTokenQtyMin <= maxBaseTokenQty,
            "MathLib: INSUFFICIENT_DECAY"
        );

        if (_baseTokenQtyDesired > maxBaseTokenQty) {
            baseTokenQty = maxBaseTokenQty;
        } else {
            baseTokenQty = _baseTokenQtyDesired;
        }

        // determine the quote token qty decay change quoted on our current ratios
        uint256 wInternalQuoteToBaseTokenRatio =
            wDiv(
                _internalBalances.quoteTokenReserveQty,
                _internalBalances.baseTokenReserveQty
            );

        // NOTE we need this function to use the same
        // rounding scheme as wDiv in order to avoid a case
        // in which a user is trying to resolve decay in which
        // quoteTokenQtyDecayChange ends up being 0 and we are stuck in
        // a bad state.
        uint256 quoteTokenQtyDecayChange =
            roundToNearest(
                (baseTokenQty * wInternalQuoteToBaseTokenRatio),
                MathLib.WAD
            ) / WAD;

        require(
            quoteTokenQtyDecayChange != 0,
            "MathLib: INSUFFICIENT_CHANGE_IN_DECAY"
        );

        // we can now calculate the total amount of quote token decay
        uint256 quoteTokenDecay =
            (maxBaseTokenQty * wInternalQuoteToBaseTokenRatio) / WAD;

        // this may be redundant quoted on the above math, but will check to ensure the decay wasn't so small
        // that it was <1 and rounded down to 0 saving the caller some gas
        // also could fix a potential revert due to div by zero.
        require(quoteTokenDecay != 0, "MathLib: NO_QUOTE_DECAY");

        // we are not changing anything about our internal accounting here. We are simply adding tokens
        // to make our internal account "right"...or rather getting the external balances to match our internal
        // quoteTokenReserveQty += quoteTokenQtyDecayChange;
        // baseTokenReserveQty += baseTokenQty;

        // calculate the number of liquidity tokens to return to user using:
        liquidityTokenQty = calculateLiquidityTokenQtyForSingleAssetEntryWithQuoteTokenDecay(
            _baseTokenReserveQty,
            _totalSupplyOfLiquidityTokens,
            baseTokenQty,
            _internalBalances.baseTokenReserveQty
        );
    }

    /**
     * @dev used to calculate the qty of tokens a user will need to contribute and be issued in order to add liquidity
     * @param _baseTokenQtyDesired the amount of base token the user wants to contribute
     * @param _quoteTokenQtyDesired the amount of quote token the user wants to contribute
     * @param _baseTokenQtyMin the minimum amount of base token the user wants to contribute (allows for slippage)
     * @param _quoteTokenQtyMin the minimum amount of quote token the user wants to contribute (allows for slippage)
     * @param _baseTokenReserveQty the external base token reserve qty prior to this transaction
     * @param _totalSupplyOfLiquidityTokens the total supply of our exchange's liquidity tokens (aka Ro)
     * @param _internalBalances internal balances struct from our exchange's internal accounting
     *
     * @return tokenQtys qty of tokens needed to complete transaction
     */
    function calculateAddLiquidityQuantities(
        uint256 _baseTokenQtyDesired,
        uint256 _quoteTokenQtyDesired,
        uint256 _baseTokenQtyMin,
        uint256 _quoteTokenQtyMin,
        uint256 _baseTokenReserveQty,
        uint256 _totalSupplyOfLiquidityTokens,
        InternalBalances storage _internalBalances
    ) public returns (TokenQtys memory tokenQtys) {
        if (_totalSupplyOfLiquidityTokens != 0) {
            // we have outstanding liquidity tokens present and an existing price curve

            tokenQtys.liquidityTokenFeeQty = calculateLiquidityTokenFees(
                _totalSupplyOfLiquidityTokens,
                _internalBalances
            );

            // we need to take this amount (that will be minted) into account for below calculations
            _totalSupplyOfLiquidityTokens += tokenQtys.liquidityTokenFeeQty;

            // confirm that we have no beta or alpha decay present
            // if we do, we need to resolve that first
            if (
                isSufficientDecayPresent(
                    _baseTokenReserveQty,
                    _internalBalances
                )
            ) {
                // decay is present and needs to be dealt with by the caller.

                uint256 baseTokenQtyFromDecay;
                uint256 quoteTokenQtyFromDecay;
                uint256 liquidityTokenQtyFromDecay;

                if (
                    _baseTokenReserveQty > _internalBalances.baseTokenReserveQty
                ) {
                    // we have more base token than expected (base token decay) due to rebase up
                    // we first need to handle this situation by requiring this user
                    // to add quote tokens
                    (
                        quoteTokenQtyFromDecay,
                        liquidityTokenQtyFromDecay
                    ) = calculateAddQuoteTokenLiquidityQuantities(
                        _quoteTokenQtyDesired,
                        _baseTokenReserveQty,
                        _totalSupplyOfLiquidityTokens,
                        _internalBalances
                    );
                } else {
                    // we have less base token than expected (quote token decay) due to a rebase down
                    // we first need to handle this by adding base tokens to offset this.
                    (
                        baseTokenQtyFromDecay,
                        liquidityTokenQtyFromDecay
                    ) = calculateAddBaseTokenLiquidityQuantities(
                        _baseTokenQtyDesired,
                        0, // there is no minimum for this particular call since we may use base tokens later.
                        _baseTokenReserveQty,
                        _totalSupplyOfLiquidityTokens,
                        _internalBalances
                    );
                }

                if (
                    quoteTokenQtyFromDecay < _quoteTokenQtyDesired &&
                    baseTokenQtyFromDecay < _baseTokenQtyDesired
                ) {
                    // the user still has qty that they desire to contribute to the exchange for liquidity
                    (
                        tokenQtys.baseTokenQty,
                        tokenQtys.quoteTokenQty,
                        tokenQtys.liquidityTokenQty
                    ) = calculateAddTokenPairLiquidityQuantities(
                        _baseTokenQtyDesired - baseTokenQtyFromDecay, // safe from underflow quoted on above IF
                        _quoteTokenQtyDesired - quoteTokenQtyFromDecay, // safe from underflow quoted on above IF
                        0, // we will check minimums below
                        0, // we will check minimums below
                        _totalSupplyOfLiquidityTokens +
                            liquidityTokenQtyFromDecay,
                        _internalBalances // NOTE: these balances have already been updated when we did the decay math.
                    );
                }
                tokenQtys.baseTokenQty += baseTokenQtyFromDecay;
                tokenQtys.quoteTokenQty += quoteTokenQtyFromDecay;
                tokenQtys.liquidityTokenQty += liquidityTokenQtyFromDecay;

                require(
                    tokenQtys.baseTokenQty >= _baseTokenQtyMin,
                    "MathLib: INSUFFICIENT_BASE_QTY"
                );

                require(
                    tokenQtys.quoteTokenQty >= _quoteTokenQtyMin,
                    "MathLib: INSUFFICIENT_QUOTE_QTY"
                );
            } else {
                // the user is just doing a simple double asset entry / providing both base and quote.
                (
                    tokenQtys.baseTokenQty,
                    tokenQtys.quoteTokenQty,
                    tokenQtys.liquidityTokenQty
                ) = calculateAddTokenPairLiquidityQuantities(
                    _baseTokenQtyDesired,
                    _quoteTokenQtyDesired,
                    _baseTokenQtyMin,
                    _quoteTokenQtyMin,
                    _totalSupplyOfLiquidityTokens,
                    _internalBalances
                );
            }
        } else {
            // this user will set the initial pricing curve
            require(
                _baseTokenQtyDesired != 0,
                "MathLib: INSUFFICIENT_BASE_QTY_DESIRED"
            );
            require(
                _quoteTokenQtyDesired != 0,
                "MathLib: INSUFFICIENT_QUOTE_QTY_DESIRED"
            );

            tokenQtys.baseTokenQty = _baseTokenQtyDesired;
            tokenQtys.quoteTokenQty = _quoteTokenQtyDesired;
            tokenQtys.liquidityTokenQty = sqrt(
                _baseTokenQtyDesired * _quoteTokenQtyDesired
            );

            _internalBalances.baseTokenReserveQty += tokenQtys.baseTokenQty;
            _internalBalances.quoteTokenReserveQty += tokenQtys.quoteTokenQty;
        }
    }

    /**
     * @dev calculates the qty of base and quote tokens required and liquidity tokens (deltaRo) to be issued
     * in order to add liquidity when no decay is present.
     * @param _baseTokenQtyDesired the amount of base token the user wants to contribute
     * @param _quoteTokenQtyDesired the amount of quote token the user wants to contribute
     * @param _baseTokenQtyMin the minimum amount of base token the user wants to contribute (allows for slippage)
     * @param _quoteTokenQtyMin the minimum amount of quote token the user wants to contribute (allows for slippage)
     * @param _totalSupplyOfLiquidityTokens the total supply of our exchange's liquidity tokens (aka Ro)
     * @param _internalBalances internal balances struct from our exchange's internal accounting
     *
     * @return baseTokenQty qty of base token the user must supply
     * @return quoteTokenQty qty of quote token the user must supply
     * @return liquidityTokenQty qty of liquidity tokens to be issued in exchange
     */
    function calculateAddTokenPairLiquidityQuantities(
        uint256 _baseTokenQtyDesired,
        uint256 _quoteTokenQtyDesired,
        uint256 _baseTokenQtyMin,
        uint256 _quoteTokenQtyMin,
        uint256 _totalSupplyOfLiquidityTokens,
        InternalBalances storage _internalBalances
    )
        public
        returns (
            uint256 baseTokenQty,
            uint256 quoteTokenQty,
            uint256 liquidityTokenQty
        )
    {
        uint256 requiredQuoteTokenQty =
            calculateQty(
                _baseTokenQtyDesired,
                _internalBalances.baseTokenReserveQty,
                _internalBalances.quoteTokenReserveQty
            );

        if (requiredQuoteTokenQty <= _quoteTokenQtyDesired) {
            // user has to provide less than their desired amount
            require(
                requiredQuoteTokenQty >= _quoteTokenQtyMin,
                "MathLib: INSUFFICIENT_QUOTE_QTY"
            );
            baseTokenQty = _baseTokenQtyDesired;
            quoteTokenQty = requiredQuoteTokenQty;
        } else {
            // we need to check the opposite way.
            uint256 requiredBaseTokenQty =
                calculateQty(
                    _quoteTokenQtyDesired,
                    _internalBalances.quoteTokenReserveQty,
                    _internalBalances.baseTokenReserveQty
                );

            require(
                requiredBaseTokenQty >= _baseTokenQtyMin,
                "MathLib: INSUFFICIENT_BASE_QTY"
            );
            baseTokenQty = requiredBaseTokenQty;
            quoteTokenQty = _quoteTokenQtyDesired;
        }

        liquidityTokenQty = calculateLiquidityTokenQtyForDoubleAssetEntry(
            _totalSupplyOfLiquidityTokens,
            quoteTokenQty,
            _internalBalances.quoteTokenReserveQty
        );

        _internalBalances.baseTokenReserveQty += baseTokenQty;
        _internalBalances.quoteTokenReserveQty += quoteTokenQty;
    }

    /**
     * @dev calculates the qty of base tokens a user will receive for swapping their quote tokens (less fees)
     * @param _quoteTokenQty the amount of quote tokens the user wants to swap
     * @param _baseTokenQtyMin the minimum about of base tokens they are willing to receive in return (slippage)
     * @param _baseTokenReserveQty the external base token reserve qty prior to this transaction
     * @param _liquidityFeeInBasisPoints the current total liquidity fee represented as an integer of basis points
     * @param _internalBalances internal balances struct from our exchange's internal accounting
     *
     * @return baseTokenQty qty of base token the user will receive back
     */
    function calculateBaseTokenQty(
        uint256 _quoteTokenQty,
        uint256 _baseTokenQtyMin,
        uint256 _baseTokenReserveQty,
        uint256 _liquidityFeeInBasisPoints,
        InternalBalances storage _internalBalances
    ) public returns (uint256 baseTokenQty) {
        require(
            _baseTokenReserveQty != 0 &&
                _internalBalances.baseTokenReserveQty != 0,
            "MathLib: INSUFFICIENT_BASE_TOKEN_QTY"
        );

        // check to see if we have experience quote token decay / a rebase down event
        if (_baseTokenReserveQty < _internalBalances.baseTokenReserveQty) {
            // we have less reserves than our current price curve will expect, we need to adjust the curve
            uint256 wPricingRatio =
                wDiv(
                    _internalBalances.baseTokenReserveQty,
                    _internalBalances.quoteTokenReserveQty
                ); // omega

            uint256 impliedQuoteTokenQty =
                wDiv(_baseTokenReserveQty, wPricingRatio); // no need to divide by WAD, wPricingRatio is already a WAD.

            baseTokenQty = calculateQtyToReturnAfterFees(
                _quoteTokenQty,
                impliedQuoteTokenQty,
                _baseTokenReserveQty, // use the actual balance here since we adjusted the quote token to match ratio!
                _liquidityFeeInBasisPoints
            );
        } else {
            // we have the same or more reserves, no need to alter the curve.
            baseTokenQty = calculateQtyToReturnAfterFees(
                _quoteTokenQty,
                _internalBalances.quoteTokenReserveQty,
                _internalBalances.baseTokenReserveQty,
                _liquidityFeeInBasisPoints
            );
        }

        require(
            baseTokenQty >= _baseTokenQtyMin,
            "MathLib: INSUFFICIENT_BASE_TOKEN_QTY"
        );

        _internalBalances.baseTokenReserveQty -= baseTokenQty;
        _internalBalances.quoteTokenReserveQty += _quoteTokenQty;
    }

    /**
     * @dev calculates the qty of quote tokens a user will receive for swapping their base tokens (less fees)
     * @param _baseTokenQty the amount of bases tokens the user wants to swap
     * @param _quoteTokenQtyMin the minimum about of quote tokens they are willing to receive in return (slippage)
     * @param _liquidityFeeInBasisPoints the current total liquidity fee represented as an integer of basis points
     * @param _internalBalances internal balances struct from our exchange's internal accounting
     *
     * @return quoteTokenQty qty of quote token the user will receive back
     */
    function calculateQuoteTokenQty(
        uint256 _baseTokenQty,
        uint256 _quoteTokenQtyMin,
        uint256 _liquidityFeeInBasisPoints,
        InternalBalances storage _internalBalances
    ) public returns (uint256 quoteTokenQty) {
        require(
            _baseTokenQty != 0 && _quoteTokenQtyMin != 0,
            "MathLib: INSUFFICIENT_TOKEN_QTY"
        );

        quoteTokenQty = calculateQtyToReturnAfterFees(
            _baseTokenQty,
            _internalBalances.baseTokenReserveQty,
            _internalBalances.quoteTokenReserveQty,
            _liquidityFeeInBasisPoints
        );

        require(
            quoteTokenQty >= _quoteTokenQtyMin,
            "MathLib: INSUFFICIENT_QUOTE_TOKEN_QTY"
        );

        _internalBalances.baseTokenReserveQty += _baseTokenQty;
        _internalBalances.quoteTokenReserveQty -= quoteTokenQty;
    }

    /**
     * @dev calculates the qty of liquidity tokens that should be sent to the DAO due to the growth in K from trading.
     * 50BPS is the total fee, 25 goes to the LPs, 5 BP to the DAO, and 20 BP to staking rewards and liquidity incentives
     * @param _totalSupplyOfLiquidityTokens the total supply of our exchange's liquidity tokens (aka Ro)
     * @param _internalBalances internal balances struct from our exchange's internal accounting
     *
     * @return liquidityTokenFeeQty qty of tokens to be minted to the fee address for the growth in K
     */
    function calculateLiquidityTokenFees(
        uint256 _totalSupplyOfLiquidityTokens,
        InternalBalances memory _internalBalances
    ) public pure returns (uint256 liquidityTokenFeeQty) {
        uint256 rootK =
            sqrt(
                _internalBalances.baseTokenReserveQty *
                    _internalBalances.quoteTokenReserveQty
            );
        uint256 rootKLast = sqrt(_internalBalances.kLast);
        if (rootK > rootKLast) {
            uint256 numerator =
                _totalSupplyOfLiquidityTokens * (rootK - rootKLast);
            uint256 denominator = rootK * 2;
            liquidityTokenFeeQty = numerator / denominator;
        }
    }
}

File 3 of 10 : ERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, _allowances[owner][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = _allowances[owner][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Spend `amount` form the allowance of `owner` toward `spender`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

File 4 of 10 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

File 5 of 10 : SafeERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

File 6 of 10 : ReentrancyGuard.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

File 7 of 10 : IExchangeFactory.sol
//SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.4;

interface IExchangeFactory {
    function feeAddress() external view returns (address);
}

File 8 of 10 : IERC20Metadata.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

File 9 of 10 : Context.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

File 10 of 10 : Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 100000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  },
  "libraries": {
    "src/libraries/MathLib.sol": {
      "MathLib": "0xe3c08c95aa81474f44bee23f8c45d470ddad37be"
    }
  }
}

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_baseToken","type":"address"},{"internalType":"address","name":"_quoteToken","type":"address"},{"internalType":"address","name":"_exchangeFactoryAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"liquidityProvider","type":"address"},{"indexed":false,"internalType":"uint256","name":"baseTokenQtyAdded","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quoteTokenQtyAdded","type":"uint256"}],"name":"AddLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"liquidityProvider","type":"address"},{"indexed":false,"internalType":"uint256","name":"baseTokenQtyRemoved","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quoteTokenQtyRemoved","type":"uint256"}],"name":"RemoveLiquidity","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"baseTokenQtyIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quoteTokenQtyIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"baseTokenQtyOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"quoteTokenQtyOut","type":"uint256"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MINIMUM_LIQUIDITY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_LIQUIDITY_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_baseTokenQtyDesired","type":"uint256"},{"internalType":"uint256","name":"_quoteTokenQtyDesired","type":"uint256"},{"internalType":"uint256","name":"_baseTokenQtyMin","type":"uint256"},{"internalType":"uint256","name":"_quoteTokenQtyMin","type":"uint256"},{"internalType":"address","name":"_liquidityTokenRecipient","type":"address"},{"internalType":"uint256","name":"_expirationTimestamp","type":"uint256"}],"name":"addLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"exchangeFactoryAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"internalBalances","outputs":[{"internalType":"uint256","name":"baseTokenReserveQty","type":"uint256"},{"internalType":"uint256","name":"quoteTokenReserveQty","type":"uint256"},{"internalType":"uint256","name":"kLast","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quoteToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_liquidityTokenQty","type":"uint256"},{"internalType":"uint256","name":"_baseTokenQtyMin","type":"uint256"},{"internalType":"uint256","name":"_quoteTokenQtyMin","type":"uint256"},{"internalType":"address","name":"_tokenRecipient","type":"address"},{"internalType":"uint256","name":"_expirationTimestamp","type":"uint256"}],"name":"removeLiquidity","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_baseTokenQty","type":"uint256"},{"internalType":"uint256","name":"_minQuoteTokenQty","type":"uint256"},{"internalType":"uint256","name":"_expirationTimestamp","type":"uint256"}],"name":"swapBaseTokenForQuoteToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_quoteTokenQty","type":"uint256"},{"internalType":"uint256","name":"_minBaseTokenQty","type":"uint256"},{"internalType":"uint256","name":"_expirationTimestamp","type":"uint256"}],"name":"swapQuoteTokenForBaseToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.