Trinity is a bonding curve protocol that distributes a token's supply across three independent liquidity pools, each denominated in a different quote asset. The design provides diversified, resilient liquidity with a flat curve and low fees optimized for arb-driven volume.
The protocol is deployed and governed by a multisig. Trading fees are asymmetric: buy-side fees are collected in the quote asset and sent directly to their designated channel, sell-side fees are collected in $TRINITY and burned — making every sell deflationary.
| Allocation | Amount | % | Purpose |
|---|---|---|---|
| TRINITY/USDC Pool | 300,000,000 | 30% | Stable liquidity anchor |
| TRINITY/ETH Pool | 300,000,000 | 30% | Blue chip liquidity |
| TRINITY/CHAOSLP Pool | 300,000,000 | 30% | Community/speculative liquidity |
| Treasury (Multisig) | 100,000,000 | 10% | Team, partnerships, reserves |
Three independent bonding curve contracts, each holding 300M $TRINITY:
┌─────────────────┐
│ MULTISIG │
│ (deployer + │
│ USDC fee sink)│
└───────┬─────────┘
│ deploys + receives USDC fees
┌───────────────┼───────────────┐
▼ ▼ ▼
┌────────────────┐ ┌────────────────┐ ┌──────────────────┐
│ TRINITY / USDC │ │ TRINITY / ETH │ │ TRINITY / CHAOSLP│
│ 300M TRINITY │ │ 300M TRINITY │ │ 300M TRINITY │
│ │ │ │ │ │
│ Buy → Multisig│ │ Buy → Gauge │ │ Buy → Chaos │
│ Sell → BURN │ │ Sell → BURN │ │ Sell → BURN │
└────────────────┘ └────────────────┘ └──────────────────┘
Each pool is fully independent — its own price curve, its own reserve, its own failure domain.
Flat polynomial bonding curve:
price(s) = BASE_PRICE + SLOPE * s^2
Where s = tokens sold from that pool's 300M allocation.
The curve is intentionally flat. Steep curves discourage trading and widen arb bands. A flat curve with low fees creates the conditions for high-frequency arb correction, which is what drives volume and fee revenue in the ArbMe ecosystem.
Buy: User sends quote asset (USDC, ETH, or CHAOSLP) → receives $TRINITY at the current curve price. Price advances along the curve.
Sell: User sends $TRINITY → receives quote asset at the current curve price minus fee. Price retreats along the curve.
Both directions are always available as long as the pool has reserves. This is the core value prop: guaranteed liquidity at a deterministic price.
Each pool is priced independently in its own quote asset:
| Pool | Quote Asset | Price Unit | Character |
|---|---|---|---|
| TRINITY/USDC | USDC (6 decimals) | $ per TRINITY | Stable anchor, most predictable |
| TRINITY/ETH | WETH (18 decimals) | ETH per TRINITY | Floats with ETH — intended |
| TRINITY/CHAOSLP | CHAOSLP (18 decimals) | CHAOSLP per TRINITY | Most speculative, steepest curve |
Cross-pool price alignment happens naturally through arbitrage (see Trading Dynamics below).
Every buy and sell across all three pools incurs a 1% fee. The fee is collected in whatever the user is spending.
User spends a quote asset to buy $TRINITY. The 1% fee goes directly to the designated channel:
User buys with 1000 USDC:
- 10 USDC (1%) → channel
- 990 USDC enters the bonding curve reserve
| Pool | Fee Destination | Purpose |
|---|---|---|
| TRINITY/USDC | Multisig wallet | Operations — payroll, infra, legal, marketing |
| TRINITY/ETH | Gauge contract | Staking rewards — distributed to $TRINITY stakers |
| TRINITY/CHAOSLP | Chaos Rewards multisig | Chaos staking — staked CHAOSLP earns ROI |
User sells $TRINITY for a quote asset. The 1% fee is taken from the $TRINITY being sold and sent directly to the burn address.
User sells 10,000 TRINITY for ETH:
- 100 TRINITY (1%) → 0x000...dead (burned permanently)
- 9,900 TRINITY returned to the curve
- User receives ETH for the 9,900 TRINITY at curve price
Every sell is deflationary. No exceptions. All three pools burn on sells.
BUY (user sends quote asset → gets TRINITY):
┌──────────────────────────────────────────────────────┐
│ 1% fee in quote asset → 100% to channel │
│ USDC pool: → Multisig (operations) │
│ ETH pool: → Gauge (staking rewards) │
│ CHAOSLP pool: → Chaos Rewards (staked) │
└──────────────────────────────────────────────────────┘
SELL (user sends TRINITY → gets quote asset):
┌──────────────────────────────────────────────────────┐
│ 1% fee in $TRINITY → 0xdead (BURNED) │
└──────────────────────────────────────────────────────┘
Every fee has a clear, direct destination. No reserves, no buybacks, no intermediary contracts.
Every sell on every pool burns $TRINITY:
function sell(uint256 trinityAmount) external nonReentrant {
uint256 burnAmount = (trinityAmount * FEE_BPS) / 10000; // 1%
uint256 sellAmount = trinityAmount - burnAmount;
// Burn the fee
trinity.transfer(DEAD_ADDRESS, burnAmount);
totalBurned += burnAmount;
// Execute the sell on the curve with the remaining amount
uint256 quoteOut = _calculateSell(sellAmount);
totalSold -= sellAmount;
// Pay the user in quote asset
_sendQuoteAsset(msg.sender, quoteOut);
}
When tokens are burned on sell, they leave the circulating supply but the curve's totalSold only decreases by the amount returned (not the burned amount). This means:
totalSold impliesBurns are driven by sell volume. Assuming sells are ~50% of total volume:
$50K daily total volume ($25K sells/day across all pools):
| TRINITY Price | Daily Burn | Monthly Burn | Annual Burn | % of Supply/Year |
|---|---|---|---|---|
| $0.001 | 250,000 | 7,500,000 | 91,250,000 | 9.1% |
| $0.005 | 50,000 | 1,500,000 | 18,250,000 | 1.8% |
| $0.01 | 25,000 | 750,000 | 9,125,000 | 0.9% |
$500K daily total volume ($250K sells/day):
| TRINITY Price | Daily Burn | Monthly Burn | Annual Burn | % of Supply/Year |
|---|---|---|---|---|
| $0.001 | 2,500,000 | 75,000,000 | 912,500,000 | 91.3% |
| $0.005 | 500,000 | 15,000,000 | 182,500,000 | 18.3% |
| $0.01 | 250,000 | 7,500,000 | 91,250,000 | 9.1% |
Burns decelerate naturally as price rises — each dollar of sell volume burns fewer tokens at higher prices. The system finds equilibrium.
The ArbMe ecosystem thesis: trading pairs are information surfaces, arb corrects mispricing, and fees compound as structural value. High fees suppress the arb that makes the system work. Low fees on a flat curve create the conditions for high-frequency arb correction.
| Fee Rate | Arb Band | Effect |
|---|---|---|
| 3% | ~6% divergence before arb triggers | Wide price gaps, infrequent correction, low volume |
| 1% | ~2% divergence before arb triggers | Tight prices, frequent correction, high volume |
At 1%, arb triggers 3x more often than at 3%. Each arb trade:
The bet: 1% at 10x volume beats 3% at 1x volume. Lower friction → more trades → more total revenue.
Because each pool prices TRINITY independently, price discrepancies will arise. Arbitrageurs correct these:
Example:
USDC pool: TRINITY = $0.0102
ETH pool: TRINITY = $0.0098 (ETH dropped, making this pool cheaper)
Spread: ~4% — exceeds 2% arb threshold
Arber:
1. Buy TRINITY on ETH pool at $0.0098 (pays 1% buy fee in ETH)
2. Sell TRINITY on USDC pool at $0.0102 (pays 1% sell fee in TRINITY → burned)
3. Nets ~$0.0004/token minus ~2% total fees minus gas
Result: ETH pool price rises, USDC pool price falls, prices converge
Every arb trade is productive:
Assuming $50K daily volume, ~50% buys ($25K buys/day), split equally across pools:
| Metric | Daily | Monthly | Annually |
|---|---|---|---|
| Total Buy Volume | $25,000 | $750,000 | $9,125,000 |
| Total Buy Fees (1%) | $250 | $7,500 | $91,250 |
Per-channel breakdown:
| Channel | Daily | Monthly | Annually |
|---|---|---|---|
| USDC → Ops (multisig) | ~$83 | ~$2,500 | ~$30,400 |
| ETH → Gauge (stakers) | ~$83 | ~$2,500 | ~$30,400 |
| CHAOSLP → Chaos staking | ~$83 | ~$2,500 | ~$30,400 |
At $500K daily volume (10x), multiply all figures by 10:
Volume is the lever, not fee rate. The flat curve and low fees are designed to maximize volume.
100% of ETH pool buy fees are directed to a gauge contract:
Buy cycle (all pools):
Buy volume ──► 1% fee to channel ──► Ops / Stakers / Chaos growth
│
Ecosystem grows ◄─┘
│
More users/volume ◄─┘
Sell/Burn cycle (all pools):
Sell volume ──► 1% TRINITY burned ──► Reduced supply
▲ │
└──── Higher price per token ◄─────────┘
Arb cycle (cross-pool):
Price divergence ──► Arber buys cheap pool (fees to channel)
▲ │
│ Arber sells expensive pool (burns TRINITY)
│ │
└──── Prices converge, repeat on next divergence
All contracts are deployed from and owned by a multisig (e.g., Safe). The multisig:
| Parameter | Mutable? | Rationale |
|---|---|---|
| Curve formula (BASE_PRICE, SLOPE) | No | Users need price predictability |
| Fee rate (1%) | No | Changing fees changes the economic contract |
| Fee routing (channels + burn) | No | Hardcoded destinations prevent rug |
| Gauge contract address | Yes (multisig, timelock) | May need migration |
| Chaos Rewards multisig | Yes (multisig, timelock) | May need migration |
| Pause (emergency) | Yes (multisig) | Circuit breaker only |
1. Deploy $TRINITY ERC-20 (1B supply minted to multisig)
2. Deploy TrinityGauge contract (ETH staking rewards)
3. Deploy TrinityBondingCurve (USDC pool)
4. Deploy TrinityBondingCurve (ETH pool)
5. Deploy TrinityBondingCurve (CHAOSLP pool)
6. Multisig approves + deposits 300M TRINITY to each curve
7. Multisig retains 100M TRINITY as treasury
8. Trading opens
Once the bonding curves have bootstrapped sufficient liquidity and price discovery, the protocol could "graduate" to Uniswap V3/V4:
This is optional and would require a multisig-initiated transaction.
| Risk | Severity | Mitigation |
|---|---|---|
| Low volume → insufficient fees | Medium | 1% is low enough to encourage volume; arb-driven volume compounds |
| Arb drain on volatile pools | Low | 2% round-trip cost for arbers is low but not free; each arb trade burns TRINITY |
| CHAOSLP goes to zero | Low impact | That curve dies, 2/3 of liquidity unaffected |
| ETH flash crash | Medium | ETH curve becomes cheap, arbers equalize, staking rewards drop temporarily |
| Whale dumps 100M treasury | High | Consider vesting schedule or timelock on treasury allocation |
| Curve over-collateralization drift | Low | Burns make curves more solvent over time — monitor but not a problem |
| Risk | Severity | Mitigation |
|---|---|---|
| Curve math precision errors | High | Use fixed-point math library (PRBMath or ABDKMath) |
| Reentrancy on sell | High | CEI pattern, ReentrancyGuard on all external calls |
| Fee rounding exploitation | Low | Round in protocol's favor, minimum trade sizes |
| Bonding curve reserve insolvency | Critical | Invariant: reserve always covers all outstanding sells. Test exhaustively. |
| Sandwich / MEV attacks | Medium | Slippage parameters on buy/sell; 1% fee makes sandwiching costly |
| Risk | Severity | Mitigation |
|---|---|---|
| Multisig key compromise | Critical | Use Safe with 3/5 or higher threshold |
| Multisig collusion (rug) | High | No withdraw on curve reserves. Channel fees are the only extraction. |
| Stale multisig (lost keys) | Medium | Ensure key rotation plan, consider social recovery |
Trinity is three independent bonding curves with the simplest possible fee model:
No reserves. No buybacks. No intermediaries. Every fee has one job.
The flat curve and 1% fee create a ~2% arb band across pools, enabling high-frequency cross-pool arbitrage that drives volume, burns supply, and funds operations. This aligns with the ArbMe ecosystem thesis: trading surfaces generate information corrections (arb), which generate fees, which compound as structural value.
The result: a token with guaranteed bonding curve liquidity, sustainable ops funding from USDC fees, staking yield from ETH fees, Chaos ecosystem growth from CHAOSLP fees, and natural deflation from sell burns — all driven by trading activity alone.