Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract CurveErrorCodes
• interface ICurve
•    - function validateDelta(uint128 delta)
•    - function validateSpotPrice(uint128 ne ...
•    - function getBuyInfo(
•    - function getSellInfo(
• library FixedPointMathLib
•    - function fmul(
•    - function fdiv(
•    - function fpow(
•    - function sqrt(uint256 x)
•    - function min(uint256 x, uint256 y)
•    - function max(uint256 x, uint256 y)
•  contract LinearCurve is ICurve, Cu ... *
•    - function validateDelta(
•    - function validateSpotPrice(
•    - function getBuyInfo(
•    - function getSellInfo(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-05-27
*/

// File: contracts/bonding-curves/CurveErrorCodes.sol


// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.0;

contract CurveErrorCodes {
    enum Error {
        OK, // No error
        INVALID_NUMITEMS, // The numItem value is 0
        SPOT_PRICE_OVERFLOW // The updated spot price doesn't fit into 128 bits
    }
}

// File: contracts/bonding-curves/ICurve.sol

pragma solidity ^0.8.0;

interface ICurve {
    /**
        @notice Validates if a delta value is valid for the curve. The criteria for
        validity can be different for each type of curve, for instance ExponentialCurve
        requires delta to be greater than 1.
        @param delta The delta value to be validated
        @return valid True if delta is valid, false otherwise
     */
    function validateDelta(uint128 delta) external pure returns (bool valid);

    /**
        @notice Validates if a new spot price is valid for the curve. Spot price is generally assumed to be the immediate sell price of 1 NFT to the pool, in units of the pool's paired token.
        @param newSpotPrice The new spot price to be set
        @return valid True if the new spot price is valid, false otherwise
     */
    function validateSpotPrice(uint128 newSpotPrice)
        external
        view
        returns (bool valid);

    /**
        @notice Given the current state of the pair and the trade, computes how much the user
        should pay to purchase an NFT from the pair, the new spot price, and other values.
        @param spotPrice The current selling spot price of the pair, in tokens
        @param delta The delta parameter of the pair, what it means depends on the curve
        @param numItems The number of NFTs the user is buying from the pair
        @param feeMultiplier Determines how much fee the LP takes from this trade, 18 decimals
        @param protocolFeeMultiplier Determines how much fee the protocol takes from this trade, 18 decimals
        @return error Any math calculation errors, only Error.OK means the returned values are valid
        @return newSpotPrice The updated selling spot price, in tokens
        @return newDelta The updated delta, used to parameterize the bonding curve
        @return inputValue The amount that the user should pay, in tokens
        @return protocolFee The amount of fee to send to the protocol, in tokens
     */
    function getBuyInfo(
        uint128 spotPrice,
        uint128 delta,
        uint256 numItems,
        uint256 feeMultiplier,
        uint256 protocolFeeMultiplier
    )
        external
        view
        returns (
            CurveErrorCodes.Error error,
            uint128 newSpotPrice,
            uint128 newDelta,
            uint256 inputValue,
            uint256 protocolFee
        );

    /**
        @notice Given the current state of the pair and the trade, computes how much the user
        should receive when selling NFTs to the pair, the new spot price, and other values.
        @param spotPrice The current selling spot price of the pair, in tokens
        @param delta The delta parameter of the pair, what it means depends on the curve
        @param numItems The number of NFTs the user is selling to the pair
        @param feeMultiplier Determines how much fee the LP takes from this trade, 18 decimals
        @param protocolFeeMultiplier Determines how much fee the protocol takes from this trade, 18 decimals
        @return error Any math calculation errors, only Error.OK means the returned values are valid
        @return newSpotPrice The updated selling spot price, in tokens
        @return newDelta The updated delta, used to parameterize the bonding curve
        @return outputValue The amount that the user should receive, in tokens
        @return protocolFee The amount of fee to send to the protocol, in tokens
     */
    function getSellInfo(
        uint128 spotPrice,
        uint128 delta,
        uint256 numItems,
        uint256 feeMultiplier,
        uint256 protocolFeeMultiplier
    )
        external
        view
        returns (
            CurveErrorCodes.Error error,
            uint128 newSpotPrice,
            uint128 newDelta,
            uint256 outputValue,
            uint256 protocolFee
        );
}

// File: contracts/imports/FixedPointMathLib.sol

pragma solidity >=0.8.0;

/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Modified from Dappsys V2 (https://github.com/dapp-org/dappsys-v2/blob/main/src/math.sol)
/// and ABDK (https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol)
library FixedPointMathLib {
    /*///////////////////////////////////////////////////////////////
                            COMMON BASE UNITS
    //////////////////////////////////////////////////////////////*/

    uint256 internal constant YAD = 1e8;
    uint256 internal constant WAD = 1e18;
    uint256 internal constant RAY = 1e27;
    uint256 internal constant RAD = 1e45;

    /*///////////////////////////////////////////////////////////////
                         FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function fmul(
        uint256 x,
        uint256 y,
        uint256 baseUnit
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * y in z for now.
            z := mul(x, y)

            // Equivalent to require(x == 0 || (x * y) / x == y)
            if iszero(or(iszero(x), eq(div(z, x), y))) {
                revert(0, 0)
            }

            // If baseUnit is zero this will return zero instead of reverting.
            z := div(z, baseUnit)
        }
    }

    function fdiv(
        uint256 x,
        uint256 y,
        uint256 baseUnit
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * baseUnit in z for now.
            z := mul(x, baseUnit)

            if or(
                // Revert if y is zero to ensure we don't divide by zero below.
                iszero(y),
                // Equivalent to require(x == 0 || (x * baseUnit) / x == baseUnit)
                iszero(or(iszero(x), eq(div(z, x), baseUnit)))
            ) {
                revert(0, 0)
            }

            // We ensure y is not zero above, so there is never division by zero here.
            z := div(z, y)
        }
    }

    function fpow(
        uint256 x,
        uint256 n,
        uint256 baseUnit
    ) internal pure returns (uint256 z) {
        assembly {
            switch x
            case 0 {
                switch n
                case 0 {
                    z := baseUnit
                }
                default {
                    z := 0
                }
            }
            default {
                switch mod(n, 2)
                case 0 {
                    z := baseUnit
                }
                default {
                    z := x
                }
                let half := div(baseUnit, 2)
                for {
                    n := div(n, 2)
                } n {
                    n := div(n, 2)
                } {
                    let xx := mul(x, x)
                    if iszero(eq(div(xx, x), x)) {
                        revert(0, 0)
                    }
                    let xxRound := add(xx, half)
                    if lt(xxRound, xx) {
                        revert(0, 0)
                    }
                    x := div(xxRound, baseUnit)
                    if mod(n, 2) {
                        let zx := mul(z, x)
                        if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) {
                            revert(0, 0)
                        }
                        let zxRound := add(zx, half)
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }
                        z := div(zxRound, baseUnit)
                    }
                }
            }
        }
    }

    /*///////////////////////////////////////////////////////////////
                        GENERAL NUMBER UTILITIES
    //////////////////////////////////////////////////////////////*/

    function sqrt(uint256 x) internal pure returns (uint256 result) {
        if (x == 0) return 0;

        result = 1;

        uint256 xAux = x;

        if (xAux >= 0x100000000000000000000000000000000) {
            xAux >>= 128;
            result <<= 64;
        }

        if (xAux >= 0x10000000000000000) {
            xAux >>= 64;
            result <<= 32;
        }

        if (xAux >= 0x100000000) {
            xAux >>= 32;
            result <<= 16;
        }

        if (xAux >= 0x10000) {
            xAux >>= 16;
            result <<= 8;
        }

        if (xAux >= 0x100) {
            xAux >>= 8;
            result <<= 4;
        }

        if (xAux >= 0x10) {
            xAux >>= 4;
            result <<= 2;
        }

        if (xAux >= 0x8) result <<= 1;

        unchecked {
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;

            uint256 roundedDownResult = x / result;

            if (result > roundedDownResult) result = roundedDownResult;
        }
    }

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

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

// File: contracts/bonding-curves/LinearCurve.sol

pragma solidity ^0.8.0;



/*
    @author 0xmons and boredGenius
    @notice Bonding curve logic for a linear curve, where each buy/sell changes spot price by adding/substracting delta
*/
contract LinearCurve is ICurve, CurveErrorCodes {
    using FixedPointMathLib for uint256;

    /**
        @dev See {ICurve-validateDelta}
     */
    function validateDelta(
        uint128 /*delta*/
    ) external pure override returns (bool valid) {
        // For a linear curve, all values of delta are valid
        return true;
    }

    /**
        @dev See {ICurve-validateSpotPrice}
     */
    function validateSpotPrice(
        uint128 /* newSpotPrice */
    ) external pure override returns (bool) {
        // For a linear curve, all values of spot price are valid
        return true;
    }

    /**
        @dev See {ICurve-getBuyInfo}
     */
    function getBuyInfo(
        uint128 spotPrice,
        uint128 delta,
        uint256 numItems,
        uint256 feeMultiplier,
        uint256 protocolFeeMultiplier
    )
        external
        pure
        override
        returns (
            Error error,
            uint128 newSpotPrice,
            uint128 newDelta,
            uint256 inputValue,
            uint256 protocolFee
        )
    {
        // We only calculate changes for buying 1 or more NFTs
        if (numItems == 0) {
            return (Error.INVALID_NUMITEMS, 0, 0, 0, 0);
        }

        // For a linear curve, the spot price increases by delta for each item bought
        uint256 newSpotPrice_ = spotPrice + delta * numItems;
        if (newSpotPrice_ > type(uint128).max) {
            return (Error.SPOT_PRICE_OVERFLOW, 0, 0, 0, 0);
        }
        newSpotPrice = uint128(newSpotPrice_);

        // Spot price is assumed to be the instant sell price. To avoid arbitraging LPs, we adjust the buy price upwards.
        // If spot price for buy and sell were the same, then someone could buy 1 NFT and then sell for immediate profit.
        // EX: Let S be spot price. Then buying 1 NFT costs S ETH, now new spot price is (S+delta).
        // The same person could then sell for (S+delta) ETH, netting them delta ETH profit.
        // If spot price for buy and sell differ by delta, then buying costs (S+delta) ETH.
        // The new spot price would become (S+delta), so selling would also yield (S+delta) ETH.
        uint256 buySpotPrice = spotPrice + delta;

        // If we buy n items, then the total cost is equal to:
        // (buy spot price) + (buy spot price + 1*delta) + (buy spot price + 2*delta) + ... + (buy spot price + (n-1)*delta)
        // This is equal to n*(buy spot price) + (delta)*(n*(n-1))/2
        // because we have n instances of buy spot price, and then we sum up from delta to (n-1)*delta
        inputValue =
            numItems *
            buySpotPrice +
            (numItems * (numItems - 1) * delta) /
            2;

        // Account for the protocol fee, a flat percentage of the buy amount
        protocolFee = inputValue.fmul(
            protocolFeeMultiplier,
            FixedPointMathLib.WAD
        );

        // Account for the trade fee, only for Trade pools
        inputValue += inputValue.fmul(feeMultiplier, FixedPointMathLib.WAD);

        // Add the protocol fee to the required input amount
        inputValue += protocolFee;

        // Keep delta the same
        newDelta = delta;

        // If we got all the way here, no math error happened
        error = Error.OK;
    }

    /**
        @dev See {ICurve-getSellInfo}
     */
    function getSellInfo(
        uint128 spotPrice,
        uint128 delta,
        uint256 numItems,
        uint256 feeMultiplier,
        uint256 protocolFeeMultiplier
    )
        external
        pure
        override
        returns (
            Error error,
            uint128 newSpotPrice,
            uint128 newDelta,
            uint256 outputValue,
            uint256 protocolFee
        )
    {
        // We only calculate changes for selling 1 or more NFTs
        if (numItems == 0) {
            return (Error.INVALID_NUMITEMS, 0, 0, 0, 0);
        }

        // We first calculate the change in spot price after selling all of the items
        uint256 totalPriceDecrease = delta * numItems;

        // If the current spot price is less than the total amount that the spot price should change by...
        if (spotPrice < totalPriceDecrease) {
            // Then we set the new spot price to be 0. (Spot price is never negative)
            newSpotPrice = 0;

            // We calculate how many items we can sell into the linear curve until the spot price reaches 0, rounding up
            uint256 numItemsTillZeroPrice = spotPrice / delta + 1;
            numItems = numItemsTillZeroPrice;
        }
        // Otherwise, the current spot price is greater than or equal to the total amount that the spot price changes
        // Thus we don't need to calculate the maximum number of items until we reach zero spot price, so we don't modify numItems
        else {
            // The new spot price is just the change between spot price and the total price change
            newSpotPrice = spotPrice - uint128(totalPriceDecrease);
        }

        // If we sell n items, then the total sale amount is:
        // (spot price) + (spot price - 1*delta) + (spot price - 2*delta) + ... + (spot price - (n-1)*delta)
        // This is equal to n*(spot price) - (delta)*(n*(n-1))/2
        outputValue =
            numItems *
            spotPrice -
            (numItems * (numItems - 1) * delta) /
            2;

        // Account for the protocol fee, a flat percentage of the sell amount
        protocolFee = outputValue.fmul(
            protocolFeeMultiplier,
            FixedPointMathLib.WAD
        );

        // Account for the trade fee, only for Trade pools
        outputValue -= outputValue.fmul(feeMultiplier, FixedPointMathLib.WAD);

        // Subtract the protocol fee from the output amount to the seller
        outputValue -= protocolFee;

        // Keep delta the same
        newDelta = delta;

        // If we reached here, no math errors
        error = Error.OK;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint128","name":"spotPrice","type":"uint128"},{"internalType":"uint128","name":"delta","type":"uint128"},{"internalType":"uint256","name":"numItems","type":"uint256"},{"internalType":"uint256","name":"feeMultiplier","type":"uint256"},{"internalType":"uint256","name":"protocolFeeMultiplier","type":"uint256"}],"name":"getBuyInfo","outputs":[{"internalType":"enum CurveErrorCodes.Error","name":"error","type":"uint8"},{"internalType":"uint128","name":"newSpotPrice","type":"uint128"},{"internalType":"uint128","name":"newDelta","type":"uint128"},{"internalType":"uint256","name":"inputValue","type":"uint256"},{"internalType":"uint256","name":"protocolFee","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint128","name":"spotPrice","type":"uint128"},{"internalType":"uint128","name":"delta","type":"uint128"},{"internalType":"uint256","name":"numItems","type":"uint256"},{"internalType":"uint256","name":"feeMultiplier","type":"uint256"},{"internalType":"uint256","name":"protocolFeeMultiplier","type":"uint256"}],"name":"getSellInfo","outputs":[{"internalType":"enum CurveErrorCodes.Error","name":"error","type":"uint8"},{"internalType":"uint128","name":"newSpotPrice","type":"uint128"},{"internalType":"uint128","name":"newDelta","type":"uint128"},{"internalType":"uint256","name":"outputValue","type":"uint256"},{"internalType":"uint256","name":"protocolFee","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint128","name":"","type":"uint128"}],"name":"validateDelta","outputs":[{"internalType":"bool","name":"valid","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint128","name":"","type":"uint128"}],"name":"validateSpotPrice","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"}]

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

10218:6153:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13678:2690;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;10376:194;;;;;;:::i;:::-;-1:-1:-1;10558:4:0;;10376:194;;;;1731:14:1;;1724:22;1706:41;;1694:2;1679:18;10376:194:0;1566:187:1;10911:2702:0;;;;;;:::i;:::-;;:::i;13678:2690::-;13939:11;13965:20;14000:16;14031:19;14065;14181:8;14193:1;14181:13;14177:89;;-1:-1:-1;14219:22:0;;-1:-1:-1;14243:1:0;;-1:-1:-1;14243:1:0;;-1:-1:-1;14243:1:0;;-1:-1:-1;14243:1:0;14211:43;;14177:89;14365:26;14394:16;14402:8;-1:-1:-1;;;;;14394:16:0;;;:::i;:::-;14365:45;;14547:18;14535:9;-1:-1:-1;;;;;14535:30:0;;14531:852;;;14684:1;;-1:-1:-1;14684:1:0;14856:17;14868:5;14856:9;:17;:::i;:::-;:21;;14876:1;14856:21;:::i;:::-;-1:-1:-1;;;;;14824:53:0;;-1:-1:-1;14531:852:0;;-1:-1:-1;14531:852:0;;15332:39;15352:18;15332:9;:39;:::i;:::-;15317:54;;14531:852;15761:1;-1:-1:-1;;;;;15711:33:0;;15723:12;15734:1;15723:8;:12;:::i;:::-;15711:25;;:8;:25;:::i;:::-;:33;;;;:::i;:::-;15710:52;;;;:::i;:::-;15661:33;-1:-1:-1;;;;;15661:33:0;;:8;:33;:::i;:::-;:101;;;;:::i;:::-;15634:128;-1:-1:-1;15868:99:0;15634:128;15899:21;4998:4;15868:16;:99::i;:::-;15854:113;-1:-1:-1;16055:54:0;:11;16072:13;4998:4;16055:16;:54::i;:::-;16040:69;;;;:::i;:::-;;-1:-1:-1;16197:26:0;16212:11;16040:69;16197:26;:::i;:::-;;;16279:5;16268:16;;16352:8;16344:16;;14101:2267;13678:2690;;;;;;;;;;;;:::o;10911:2702::-;11171:11;11197:20;11232:16;11263:18;11296:19;11411:8;11423:1;11411:13;11407:89;;-1:-1:-1;11449:22:0;;-1:-1:-1;11473:1:0;;-1:-1:-1;11473:1:0;;-1:-1:-1;11473:1:0;;-1:-1:-1;11473:1:0;11441:43;;11407:89;11595:21;11631:16;11639:8;-1:-1:-1;;;;;11631:16:0;;;:::i;:::-;11619:28;;-1:-1:-1;;;;;11619:28:0;;;:::i;:::-;11595:52;-1:-1:-1;;;;;;11662:33:0;;11658:112;;;11720:25;11747:1;11750;11753;11756;11712:46;;;;;;;;;;;;;11658:112;11803:13;-1:-1:-1;11803:13:0;12462:20;12485:17;12497:5;12485:9;:17;:::i;:::-;-1:-1:-1;;;;;12462:40:0;;;13008:1;12986:5;-1:-1:-1;;;;;12958:33:0;12981:1;12970:8;:12;;;;:::i;:::-;12958:25;;:8;:25;:::i;:::-;:33;;;;:::i;:::-;12957:52;;;;:::i;:::-;12905:36;12929:12;12905:8;:36;:::i;:::-;:104;;;;:::i;:::-;12879:130;-1:-1:-1;13114:98:0;12879:130;13144:21;4998:4;13114:15;:98::i;:::-;13100:112;-1:-1:-1;13299:53:0;:10;13315:13;4998:4;13299:15;:53::i;:::-;13285:67;;;;:::i;:::-;;-1:-1:-1;13427:25:0;13441:11;13285:67;13427:25;:::i;:::-;13597:8;;10911:2702;;-1:-1:-1;13427:25:0;-1:-1:-1;10911:2702:0;;-1:-1:-1;10911:2702:0;;-1:-1:-1;;;;;;10911:2702:0:o;5289:519::-;5493:9;;;5597;;5611;;;5608:16;;5594:31;5584:89;;5656:1;5653;5646:12;5584:89;5774:16;;5289:519;-1:-1:-1;;5289:519:0:o;14:188:1:-;82:20;;-1:-1:-1;;;;;131:46:1;;121:57;;111:85;;192:1;189;182:12;111:85;14:188;;;:::o;207:466::-;302:6;310;318;326;334;387:3;375:9;366:7;362:23;358:33;355:53;;;404:1;401;394:12;355:53;427:29;446:9;427:29;:::i;:::-;417:39;;475:38;509:2;498:9;494:18;475:38;:::i;:::-;207:466;;465:48;;-1:-1:-1;;;;560:2:1;545:18;;532:32;;611:2;596:18;;583:32;;662:3;647:19;;;634:33;;-1:-1:-1;207:466:1:o;678:692::-;929:3;914:19;;963:1;952:13;;942:144;;1008:10;1003:3;999:20;996:1;989:31;1043:4;1040:1;1033:15;1071:4;1068:1;1061:15;942:144;1095:25;;;-1:-1:-1;;;;;1209:15:1;;;1204:2;1189:18;;1182:43;1261:15;;;;1256:2;1241:18;;1234:43;1308:2;1293:18;;1286:34;1351:3;1336:19;1329:35;678:692;:::o;1375:186::-;1434:6;1487:2;1475:9;1466:7;1462:23;1458:32;1455:52;;;1503:1;1500;1493:12;1455:52;1526:29;1545:9;1526:29;:::i;:::-;1516:39;1375:186;-1:-1:-1;;;1375:186:1:o;1758:127::-;1819:10;1814:3;1810:20;1807:1;1800:31;1850:4;1847:1;1840:15;1874:4;1871:1;1864:15;1890:168;1930:7;1996:1;1992;1988:6;1984:14;1981:1;1978:21;1973:1;1966:9;1959:17;1955:45;1952:71;;;2003:18;;:::i;:::-;-1:-1:-1;2043:9:1;;1890:168::o;2063:127::-;2124:10;2119:3;2115:20;2112:1;2105:31;2155:4;2152:1;2145:15;2179:4;2176:1;2169:15;2195:216;2235:1;-1:-1:-1;;;;;2322:2:1;2319:1;2315:10;2344:3;2334:37;;2351:18;;:::i;:::-;2389:10;;2385:20;;;;;2195:216;-1:-1:-1;;2195:216:1:o;2416:253::-;2456:3;-1:-1:-1;;;;;2545:2:1;2542:1;2538:10;2575:2;2572:1;2568:10;2606:3;2602:2;2598:12;2593:3;2590:21;2587:47;;;2614:18;;:::i;:::-;2650:13;;2416:253;-1:-1:-1;;;;2416:253:1:o;2674:246::-;2714:4;-1:-1:-1;;;;;2827:10:1;;;;2797;;2849:12;;;2846:38;;;2864:18;;:::i;:::-;2901:13;;2674:246;-1:-1:-1;;;2674:246:1:o;2925:125::-;2965:4;2993:1;2990;2987:8;2984:34;;;2998:18;;:::i;:::-;-1:-1:-1;3035:9:1;;2925:125::o;3055:120::-;3095:1;3121;3111:35;;3126:18;;:::i;:::-;-1:-1:-1;3160:9:1;;3055:120::o;3180:128::-;3220:3;3251:1;3247:6;3244:1;3241:13;3238:39;;;3257:18;;:::i;:::-;-1:-1:-1;3293:9:1;;3180:128::o

ipfs://51c4e894b7720637ab405ad59690ac2e1a618eefd409106fde34ab0a6312f8d5