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

Process Flow:

1. User sends trading token (B3/ETH) to contract
2. Contract calculates tokens based on curve
3. 5% fee deducted and sent to recipient
4. Tokens minted and sent to buyer
5. Curve state updated

Code Example:

typescript
// Get a quote first
const quote = await token.getAmountOfTokensToBuy(
  parseEther("100") // 100 trading tokens
);
console.log(`Will receive: ${formatEther(quote)} tokens`);

// Execute purchase with slippage protection  
const minTokens = quote * 0.95n; // 5% slippage
await token.buy(parseEther("100"), minTokens);

Important Notes:

• Set minTokensOut to protect against front-running
• Use 0 for minTokensOut only in low-activity periods
• Transaction reverts if slippage exceeds tolerance

Target Overflow:

• If purchase would exceed target, excess is refunded
• Example: Target is 10 trading tokens, raised is 9.5 tokens
• User sends 1 token → 0.5 tokens used, 0.5 tokens refunded

Insufficient Gas:

• Recommended gas limit: 200,000
• Complex calculations may require more

Zero Amount:

• Transactions with 0 trading tokens will revert

Selling Tokens

Process Flow:

1. User approves token spending
2. User calls sell with token amount
3. Contract calculates trading token amount based on curve
4. 5% fee deducted from proceeds
5. Trading token sent to seller, tokens burned
6. Curve state updated (price decreases)

Code Example:

typescript
// Check balance and get quote
const balance = await token.balanceOf(userAddress);
const sellAmount = balance / 2n; // Sell half

const quote = await token.getAmountOfTradingTokensToSell(
  sellAmount
);
console.log(`Will receive: ${formatEther(quote)} trading tokens`);

// Execute sale with slippage protection
const minTradingTokenOut = quote * 0.95n; // 5% slippage
await token.sell(sellAmount, minTradingTokenOut);

Important Notes:

• Requires token approval before selling
• Price impact can be significant for large sells
• Cannot sell more than circulating supply

Understanding Sell Impact:

Selling reduces the curve's raised amount, causing price to drop:

Actual impact depends on aggressiveness factor

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 target
async 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 tokens
Current: 99.5 trading tokens
User sends: 2 trading tokens

Result:
- 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
);

Listening in SDK:

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

Listening in SDK:

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 setup
class 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)}%`);
    });
  }
}

// Usage
const monitor = new BondingMonitor(token);
await monitor.start();

Bonding Phase Strategies

For Token Creators

For Traders

Post-Bonding Transition

Next Steps