Bonding Phase

What is the Bonding Phase?

The bonding phase is the initial trading period where tokens are bought and sold directly from a smart contract using an algorithmic pricing curve. Think of it as a decentralized pre-sale with automatic market making.

mermaid
stateDiagram-v2
    [*] --> Created: Token Deployed
    Created --> Bonding: Automatic
    Bonding --> Bonding: Buy/Sell Trades
    Bonding --> MigrationReady: Target Reached
    MigrationReady --> DEX: migrateToDex()
    DEX --> [*]: Fully Decentralized

    note right of Bonding
        Direct contract trading
        Algorithmic pricing
        5% trading fee
        Accumulates liquidity
    end note

    note right of DEX
        Uniswap v4 trading
        Market-driven price
        Standard LP fees
        No admin control
    end note

How Bonding Works

The Bonding Curve Mechanism

During bonding, the contract acts as the sole market maker:

1. No Order Book: Prices determined algorithmically
2. Instant Liquidity: Always able to buy or sell
3. Path Independence: Price depends only on supply, not history
4. Automatic Pricing: No manual price setting needed

Trading Operations

Buying Tokens

typescript
// Get a quote firstconst quote = await token.getAmountOfTokensToBuy(  parseEther("100") // 100 trading tokens);console.log(`Will receive: ${formatEther(quote)} tokens`);// Execute purchase with slippage protectionconst minTokens = quote * 0.95n; // 5% slippageawait token.buy(parseEther("100"), minTokens);

Selling Tokens

typescript
// Check balance and get quoteconst balance = await token.balanceOf(userAddress);const sellAmount = balance / 2n; // Sell halfconst quote = await token.getAmountOfTradingTokensToSell(  sellAmount);console.log(`Will receive: ${formatEther(quote)} trading tokens`);// Execute sale with slippage protectionconst minTradingTokenOut = quote * 0.95n; // 5% slippageawait token.sell(sellAmount, minTradingTokenOut);

Fee Structure

How Fees Work

mermaid
graph LR
    A[User Trade] -->|100%| B[Contract]
    B -->|95%| C[Curve/User]
    B -->|5%| D[Fee Recipient]

    style A fill:#e1f5fe
    style D fill:#c8e6c9

typescript
// User sends 1 trading token// Fee: 0.05 trading token// Curve receives: 0.95 trading token// Tokens minted based on 0.95 trading token

typescript
// Tokens worth 1 trading token on curve// Fee: 0.05 trading token// User receives: 0.95 trading tokens// Curve drops by 1 trading token

Fee Economics

Target Mechanics

Understanding the Target

The target is the amount of trading token that must be accumulated before migration:

Approaching the Target

typescript
// Monitor progress toward targetasync function trackProgress(token: BondkitToken) {  const progress = await token.getBondingProgress();  if (progress.progress < 0.5) {    console.log("🌱 Early stage - best prices available");  } else if (progress.progress < 0.8) {    console.log("🚀 Momentum building - consider buying");  } else if (progress.progress < 1.0) {    console.log("🔥 Almost there - migration imminent");  } else {    console.log("✅ Target reached - ready to migrate!");  }  const remaining = progress.threshold - progress.raised;  console.log(`Need ${formatEther(remaining)} more trading token`);}

Overflow Handling

When a purchase would exceed the target:

1. Partial Fill: Only the amount needed is accepted
2. Automatic Refund: Excess returned in same transaction
3. Fair Completion: No one can overpay at the end

Example Scenario:

text
Target: 100 trading tokensCurrent: 99.5 trading tokensUser sends: 2 trading tokensResult:- 0.5 trading tokens accepted (reaches exactly 100)- 1.5 trading tokens refunded- User gets tokens for 0.5 trading tokens- Migration now available

Events & Monitoring

Contract Events

solidity
event BondingCurveBuy(    address indexed payer,    address indexed recipient,    uint256 tradingTokenIn,    uint256 tokensOut,    uint256 fee,    uint256 totalRaisedBonding);

typescript
token.onBuy((event) => {  console.log({    buyer: event.payer,    ethSpent: formatEther(event.tradingTokenIn),    tokensReceived: formatEther(event.tokensOut),    feePaid: formatEther(event.fee),    totalRaised: formatEther(event.totalRaisedBonding)  });});

solidity
event BondingCurveSell(    address indexed seller,    uint256 tokensIn,    uint256 tradingTokenOut,    uint256 fee,    uint256 totalRaisedBonding);

typescript
token.onSell((event) => {  console.log({    seller: event.seller,    tokensSold: formatEther(event.tokensIn),    ethReceived: formatEther(event.tradingTokenOut),    feePaid: formatEther(event.fee),    totalRaised: formatEther(event.totalRaisedBonding)  });});

Real-Time Monitoring

typescript
// Complete monitoring setupclass BondingMonitor {  constructor(private token: BondkitToken) {}  async start() {    // Initial state    const progress = await this.token.getBondingProgress();    console.log(`Starting at ${(progress.progress * 100).toFixed(2)}%`);    // Monitor buys    this.token.onBuy(async (event) => {      const newProgress = await this.token.getBondingProgress();      console.log(`BUY: ${formatEther(event.tokensOut)} tokens`);      console.log(`Progress: ${(newProgress.progress * 100).toFixed(2)}%`);      if (newProgress.progress >= 1.0) {        console.log("🎆 TARGET REACHED! Migration available.");      }    });    // Monitor sells    this.token.onSell(async (event) => {      const newProgress = await this.token.getBondingProgress();      console.log(`SELL: ${formatEther(event.tokensIn)} tokens`);      console.log(`Progress: ${(newProgress.progress * 100).toFixed(2)}%`);    });  }}// Usageconst monitor = new BondingMonitor(token);await monitor.start();

Bonding Phase Strategies

For Token Creators

For Traders

Post-Bonding Transition

Next Steps