Integrate bagggr

Mainnet only. The program is upgradeable by the bagggr admin; the IDL above is the deployed version (constant-product curve, fee-on-transfer pair assets, buy-back-and-burn slice), September 2026.

Live config (readable from the config PDA, layout below):

One Market account per token, at PDA(["market", mint]). List them all with getProgramAccounts on the program, filtered on the 8-byte account discriminator at offset 0; the account is 384 bytes.

Market discriminator  [219, 190, 213, 55, 0, 227, 198, 154]   dataSize 384
Config discriminator  [155, 12, 170, 224, 30, 250, 204, 130]

PDAs (program 9GMVRdY66xm3SZQEvedDso14Ekwg2iEkWEJo1z1YqZfG)
  market        ["market",  mint]
  market_signer ["signer",  mint]     authority of the vaults; system-owned, no data
  config        ["config"]

New launches also emit a MarketCreated event (see Events), so a log subscription on the program catches a token the second it exists. Name, symbol and the metadata URI (a JSON with the image) are standard Metaplex metadata on the mint.

Market layout (little-endian, offsets from the start of the account data, 8-byte discriminator included):

Config layout: admin (8), treasury (40), curve_fee_bps u16 (72), tax_bps u16 (74), protocol_share_bps u16 (76), pusher_cap_bps u16 (78), price_multiple u16 (80), supply_total u64 (82), supply_for_sale u64 (90), launch_fee_lamports u64 (98), raydium_program (106), raydium_amm_config (138), raydium_create_pool_fee (170), markets_created u64 (202), pusher (210), converter_program (242), bump u8 (274), burn_share_bps u16 (275). You need treasury (for the fee account) and curve_fee_bps.

Units everywhere: token base units (6 decimals) and quote base units (the pair asset's own decimals, 9 for SOL). Spot prices from the program are quote base units per whole token, scaled by 1e9. All arithmetic is integer; buyers round up, sellers round down. Replicate it exactly and your quote is the fill.

Which curve. If bit 127 of p0 is set the market is a constant product with virtual reserves: v0 = p0 & ~(1 << 127) (quote base units) and vt0 = p1 (token base units). Every launch since the September 2026 upgrade is this shape. If the bit is clear the market is a straight line with p0 and p1 the scaled prices at s = 0 and s = S (the first markets, including the two listed today).

// constant product (s, Δ, S, vt0 in token base units; v0, quote in quote base units)
raised(s)          = floor(v0 · s / (vt0 − s))                   quote the curve holds after s sold
cost(s, Δ)         = max(1, raised(s + Δ) − raised(s))            buy Δ from s   (Δ ≤ S − s)
proceeds(s, Δ)     = raised(s) − raised(s − Δ)                    sell Δ at s    (Δ ≤ s)
spot(s)            = v0 · vt0 · 1e6 / (vt0 − s)²                  quote base units per whole token

// straight line (p0, p1 scaled by 1e9 per whole token; DENOM = 1e6 · 1e9)
price(s)           = p0 + (p1 − p0) · s / S
cost(s, Δ)         = ceil( (p0·Δ + (p1 − p0)·(floor(s·Δ / S) + floor(Δ² / 2S))) / DENOM )
proceeds(s, Δ)     = floor( (p0·Δ + (p1 − p0)·(floor(s·Δ / S) − floor(Δ² / 2S))) / DENOM )

// both
fee(q)             = ceil(q · curve_fee_bps / 10000)              1% today
buyer pays         = cost + fee(cost)          ≤ max_quote_in
seller receives    = proceeds − fee(proceeds)  ≥ min_quote_out

The transfer tax. The token program withholds 1.5% of every transfer of the token, on any venue. On a buy the curve sends Δ and the buyer's account receives Δ − ceil(Δ · 150 / 10000), i.e. 98.5%. On a sell the seller sends token_amount, the curve receives 98.5% of it and pays for that net amount. Quote the user on what lands in their wallet.

Pair assets with a transfer fee of their own (a Token-2022 quote mint such as ZCAT): the program grosses the buyer's transfers up so the curve and the treasury receive cost and fee net, and checks the vault actually received it. Size max_quote_in on the grossed-up total (Token-2022's inverse fee calculation). Plain SPL pairs and wrapped SOL need nothing extra.

Worked example, a fresh SOL-paired launch with a 40 SOL graduation target (G = 40,000,000,000 lamports, S = 8e14, T = 1e15):

Tokens for a quote amount: cost is monotone in Δ, so binary-search Δ in [0, S − s] for the largest cost ≤ amount (subtract the fee first: amount_net = floor(amount · 10000 / 10100) is a safe start, then check cost + fee(cost) ≤ amount). Market cap = spot × current supply of the mint (supply falls as the buy-back burns tokens). Progress = reserve / graduation_reserve.

buy(token_amount: u64, max_quote_in: u64)
data = [102, 6, 61, 18, 1, 218, 235, 234] ++ u64 LE token_amount ++ u64 LE max_quote_in

Buys token_amount base units from the curve, or whatever is left if less (a bigger order is cut to the remainder, not rejected), for at most max_quote_in quote base units including the fee. Selling out sets phase = Complete.

Wrapped SOL. A SOL-paired market has quote_mint = So11111111111111111111111111111111111111112. The reference transaction: SetComputeUnitLimit(300,000); CreateIdempotent ATA(buyer, WSOL); SystemProgram.transfer(buyer → that ATA, max_quote_in); SyncNative; CreateIdempotent ATA(treasury, WSOL); buy; CloseAccount(WSOL ATA → buyer), which also refunds whatever the fill did not use. A buy runs in about 60,000 compute units.

With @coral-xyz/anchor and the IDL, the PDAs and buyer_token resolve themselves: pass buyer, mint, quoteMint, tokenVault, quoteVault, buyerQuote, treasuryQuote, tokenProgram, quoteTokenProgram.

sell(token_amount: u64, min_quote_out: u64)
data = [51, 230, 133, 164, 1, 127, 131, 173] ++ u64 LE token_amount ++ u64 LE min_quote_out

Sends token_amount base units to the curve (98.5% arrive) and pays proceeds minus the fee, at least min_quote_out. Rejected when the market is not in phase Curve or the amount exceeds tokens_sold.

Errors you will meet: 6007 CurveClosed (phase is not Curve: sold out or graduated), 6009 SlippageExceeded (buy), 6010 SlippageBelowMin (sell), 6011 SellExceedsSold, 6017 BadTokenAccount (wrong owner or mint on a quote account), 6025 WrongTokenProgram (the token side must be Token-2022), 6035 ShortReceived (a fee-on-transfer pair delivered less than cost).

Anchor events, base64 after Program data: in the transaction log, first 8 bytes the discriminator, then the fields little-endian. Trade carries the post-trade state, so one log subscription is a complete price and volume feed.

Trade          [24, 254, 218, 152, 253, 43, 18, 81]
  market pubkey · trader pubkey · side u8 (0 buy, 1 sell) · tokens u64 · quote u64 · fee u64 · tokens_sold u64 · reserve u64
  buy:  tokens = what the curve sold (the wallet gets 98.5%), quote = cost before the fee
  sell: tokens = what arrived at the curve after the tax, quote = what the seller received after the fee

MarketCreated  [88, 184, 130, 231, 226, 84, 6, 58]
  market · mint · quote_mint · creator · graduation_reserve u64 · p0 u128 · p1 u128

Graduated      [51, 241, 66, 50, 140, 245, 156, 192]
  market · pool · quote_seeded u64 · tokens_seeded u64 · lp_burned u64

When tokens_sold reaches supply_for_sale the phase becomes Complete and the curve stops. Anyone may then call graduate; bagggr's keeper does within a minute. It creates a Raydium CPMM pool with the whole reserve and the 200,000,000 held-back tokens at the curve's final price, and burns the LP. The market's pool field and the Graduated event give you the pool; from then on route the token like any Raydium CPMM pair (Jupiter indexes it). The 1.5% transfer tax keeps applying on every transfer, including pool swaps, so a graduated buy also lands 98.5%.

Optional, for charts and history; everything above needs only an RPC. Base URL https://bagggr.com, JSON, no key. Please cache: the site refreshes market state every 10 s and candles every 20 s.

Two public markets are live on the curve today. Both are straight-line markets (launched before the constant-product upgrade); ask us for a fresh SOL-paired launch to test the constant-product shape.

Compare your numbers with the token page (https://bagggr.com/token/<mint>) and with /api/markets: the site runs the same integer math against the same account, so a quote that differs by more than a base unit means a unit mismatch. Every market the program has ever created is in the getProgramAccounts result, including test launches the site hides.