Bonding Curves

Bonding curves define how the price of an asset changes based on supply and demand. In the Intuition Protocol, they allow vaults to dynamically price semantic assets like atoms and triples.

A bonding curve is a pricing mechanism — it determines how much ETH a user pays (or gets back) when depositing to or redeeming from a vault. This lets projects:

• Incentivize early participation with cheaper entry prices.
• Control supply with rising costs as more tokens are minted.
• Align economics with data value or staking behavior.

Intuition uses bonding curves in the EthMultiVault system to handle deposits and redemptions for both atoms (individual semantic claims) and triples (subject–predicate–object sets).

Real-World Use Cases

Use Case	How Bonding Curves Help
Data Markets	Pay to mint assertions on-chain; rising cost controls spam.
Staking Derivatives	Price increases with TVL, modeling yield or scarcity.
Protocol Governance	Curves can align incentives for governance participation.
Custom Economies	Plug in your own math logic via custom curves.

Design Philosophy

Bonding curves in Intuition Protocol are modular by design:

• Registry-based routing: Vaults remain clean and upgrade-safe.
• Symmetrical math API: All curves implement the same interface.
• Upgradeable curves: Developers can ship custom curves anytime — no need to upgrade the vault.

In upcoming versions (V2), we'll simplify things even further by removing suffixes like depositAtomCurve, replacing them with a unified API keyed by curveId.

How Bonding Curves Fit into the Protocol

Here's the basic architecture:

User / dApp
   │
   ▼
EthMultiVault
   ├─ Standard paths (Linear math inline)
   └─ Curve-specific paths
        │
        ▼
BondingCurveRegistry ──→ BaseCurve (Linear, OffsetProgressive, custom...)

• EthMultiVault handles deposits/redemptions.
• If a non-linear curve is specified, it routes to the BondingCurveRegistry.
• The registry proxies math to the appropriate curve contract using a curveId.

Curve Types

Linear Curve

(curveId = 1)

A simple, pro-rata pricing model where every deposit gets the same rate:

price = totalAssets / totalShares;

This is the default math embedded directly into EthMultiVault, but we include a separate LinearCurve contract for compatibility and future flexibility.

tip

Great for simple, predictable token issuance.

Offset Progressive Curve

(curveId = 4)

A more dynamic curve where price increases linearly based on total supply:

P(s) = m ∗ (s + offset)

Mint cost is the area under the curve, meaning early deposits are cheaper:

Cost = (m/2) ∗ [(s₂ + offset)² − (s₁ + offset)²]

Redemption returns are also curve-aware:

Return = (m/2) ∗ [2 ∗ (s + offset) ∗ r − r²]

Where:

- **s** = current shares
- **r** = shares being redeemed

tip

Ideal for data markets and staking derivatives — you can reward early supporters and make each additional share more expensive.

Interactive Demo

Try out different bonding curve types and see how they affect pricing:

Bonding Curve Interactive Demo

Parameters

Curve TypeLinear CurveOffset Progressive Curve

Current Supply: 100

Purchase Amount (ETH): 10

Results

Current Price (ETH per share):1.0000 ETH

Purchase Cost:10.0000 ETH

Shares Received:10.0000

New Price (ETH per share):0.9091 ETH

Price Impact:-9.09%

Linear Curve Note: Initial deposits are 1:1 (ETH deposited = shares received). Subsequent deposits use the conversion formula: shares = (assets × totalShares) / totalAssets.

Code Examples

Deposit Using a Curve

Deposit ETH into a vault with the Offset Progressive curve:

EthMultiVault.depositAtomCurve{value: amountETH}(
    msg.sender,   // receiver of shares
    atomId,       // which atom to deposit into
    4             // curveId for OffsetProgressive
);

Preview Deposit in Frontend

Estimate how many shares a user would get before committing ETH:

uint256 shares = vault.previewDepositCurve(amountETH, atomId, 4);

You can also check the current price:

uint256 price = registry.currentPrice(totalShares, 4);

Register a New Curve (Admin Only)

If you've written your own curve, you can add it like this:

uint256 curveId = registry.addBondingCurve(address(myCustomCurve));
vault.setBondingCurveConfig(address(registry), curveId); // optional

You only need to implement the BaseCurve interface to plug in.

Share Display and User Experience

Understanding Share Values

Intuition displays share values in a user-friendly format to make ownership easier to understand. The Portal frontend shows one "Share" as 1/100,000th of the 1 ETH-equivalent raw value recorded in smart contracts.

Why this matters:

• Simpler numbers: Users see whole numbers instead of lengthy decimals
• Familiar concept: Similar to how Bitcoin (Satoshis) and Ethereum (Wei) work
• Clear ownership: Easier to understand your position size

Example:

• Smart contract: 1,000,000 raw units
• Portal display: 10 shares
• Each share = 100,000 raw units

No Impact on Positions

info

Important: This is purely a display change. Your actual positions and the underlying smart contracts remain unchanged.

Summary

• Bonding curves are a flexible pricing tool for atoms and triples.
• Intuition supports multiple curve types, each with their own pricing logic.
• You can preview, extend, or customize bonding behavior with minimal friction.
• The system is secure, upgrade-safe, and open to new economic designs.
• Share display is optimized for user experience while preserving contract integrity.

---

This section will be expanded with detailed mathematical formulas, implementation guides, and real-world examples.