token-bonding-curves

Token Bonding Curves

Concept

A bonding curve is a mathematical function that defines the price of a token as a function of its supply. As supply increases, price increases along the curve. Tokens are minted on buy and burned on sell, with a reserve backing the curve.

price = f(supply)
cost_to_buy(n) = integral(f, supply, supply + n)
proceeds_from_sell(n) = integral(f, supply - n, supply)

Curve Types

Linear Bonding Curve Implementation

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract LinearBondingCurve is ERC20, ReentrancyGuard {
    uint256 public immutable slope;      // price increase per token (in wei per token)
    uint256 public immutable basePrice;  // starting price (in wei per token)
    uint256 public reserveBalance;

    constructor(uint256 _slope, uint256 _basePrice)
        ERC20("BondingToken", "BOND")
    {
        slope = _slope;
        basePrice = _basePrice;
    }

    /// @notice Price at a given supply level
    function priceAtSupply(uint256 supply) public view returns (uint256) {
        return basePrice + (slope * supply / 1e18);
    }

    /// @notice Cost to buy `amount` tokens at current supply
    /// @dev Integral of linear function: base*amount + slope*(s1^2 - s0^2) / (2 * 1e18)
    function getBuyCost(uint256 amount) public view returns (uint256) {
        uint256 s0 = totalSupply();
        uint256 s1 = s0 + amount;
        uint256 baseCost = basePrice * amount / 1e18;
        uint256 slopeCost = slope * (s1 * s1 - s0 * s0) / (2 * 1e36);
        return baseCost + slopeCost;
    }

    /// @notice Proceeds from selling `amount` tokens at current supply
    function getSellProceeds(uint256 amount) public view returns (uint256) {
        uint256 s0 = totalSupply();
        require(amount <= s0, "exceeds supply");
        uint256 s1 = s0 - amount;
        uint256 baseCost = basePrice * amount / 1e18;
        uint256 slopeCost = slope * (s0 * s0 - s1 * s1) / (2 * 1e36);
        return baseCost + slopeCost;
    }

    function buy(uint256 minTokens) external payable nonReentrant {
        uint256 cost = getBuyCost(minTokens);
        require(msg.value >= cost, "insufficient payment");

        reserveBalance += cost;
        _mint(msg.sender, minTokens);

        uint256 refund = msg.value - cost;
        if (refund > 0) {
            (bool ok, ) = msg.sender.call{value: refund}("");
            require(ok, "refund failed");
        }

        emit Buy(msg.sender, minTokens, cost);
    }

    function sell(uint256 amount) external nonReentrant {
        require(balanceOf(msg.sender) >= amount, "insufficient balance");

        uint256 proceeds = getSellProceeds(amount);
        require(proceeds <= reserveBalance, "insufficient reserve");

        reserveBalance -= proceeds;
        _burn(msg.sender, amount);

        (bool ok, ) = msg.sender.call{value: proceeds}("");
        require(ok, "transfer failed");

        emit Sell(msg.sender, amount, proceeds);
    }

    event Buy(address indexed buyer, uint256 amount, uint256 cost);
    event Sell(address indexed seller, uint256 amount, uint256 proceeds);

    receive() external payable {}
}