Launch on any curve. Graduate at its price.
Pina Bonding Curve runs self-serve token launchpads on Solana. One configuration fixes the curve, the supply, and the fees. Every token launched under it sells along that curve, then graduates into a Pina AMM pool at exactly the price it reached.
CurveqeE6jzkyHQMcWaGENzd7jrd8m9R1u4dZ17GnSa9Try a launch
1 billion tokens, raising 85 SOL
- Raised
- 42.5 of 85 SOL
- Sold
- 582.4M tokens
- Price
- 0.19 SOL per 1M
- 1 SOL buys
- 2.6M tokens after a 50% fee
Fill the curve to 85 SOL to complete the launch, then graduate it.
A launchpad you write, not one you rent
Anyone can run a launchpad by writing one configuration: the price curve, the supply, the fees, the creator's terms, and how launches graduate.
Curves of any shape
A curve is up to 16 segments of concentrated liquidity. One segment is the classic pump-style curve; more segments approximate any rising price schedule.
Read more →A launchpad is one account
Configurations are immutable and self-serve. Create one for your app, game, or community and share its address. There is no admin, allowlist, or pause switch.
Read more →Fair by construction
Each launch mints a fixed supply and revokes the mint authority in the same instruction. An opening fee that decays over the first seconds taxes sniping bots instead of buyers.
Read more →Graduation nobody can front-run
Launches graduate into a Pina AMM tier that only this program can create pools in, at the curve's final price. LP not paid to the creator or partner is burned.
Read more →Revenue for creators and partners
Trading and migration fees split between the token's creator and the launchpad's partner, a creator allocation vests on a schedule, and the graduated pool can keep paying a creator fee.
Read more →Exact and cheap
Integer math with 256-bit intermediates rounds every step in the curve's favour, and a buy costs about 8,400 compute units including both token transfers.
Read more →
From launch to pool in three states
Trading
Buys and sells move the price along the curve. The trading fee opens high and falls to the end rate.
Completed
The buy that reaches the migration price completes the launch and pays only for what the curve used. Trading stops.
Graduated
Anyone can graduate it. The raised SOL and reserved tokens open a Pina AMM pool at the curve's final price, and unsold tokens burn.
- per buy, both transfers included
- 8,400CU
- segments a curve can use
- 16
- account per launchpad
- 1
- admins, allowlists, or pause switches
- 0
The end-to-end suite runs every instruction against the compiled program and fails if a buy exceeds 10,000 compute units. See the measurements.
A client for your stack
Rust, TypeScript, Dart, and on-chain CPI clients are generated from the program's IDL, so they always match it. The pina-curve CLI designs curves offline and runs launches from the terminal.
@pina-rs/bonding-curvenpmTypeScript client for @solana/kit
pina_bonding_curve_clientcrates.ioRust client: builders, decoders, PDAs, events
pina_bonding_curve_cpicrates.iono_std client for cross-program calls
pina_bonding_curvepub.devDart and Flutter client for solana_kit
pina_bonding_curve_clicrates.ioThe pina-curve tool: design curves, run launches
import { fetchLaunch, getBuyInstruction } from "@pina-rs/bonding-curve";
import { createSolanaRpc } from "@solana/kit";
const rpc = createSolanaRpc("https://api.devnet.solana.com");
const { data: launch } = await fetchLaunch(rpc, launchAddress);
const instruction = getBuyInstruction({
trader: wallet,
config: launch.config,
launch: launchAddress,
traderBase: walletBaseToken,
traderQuote: walletQuoteToken,
baseVault: launch.baseVault,
quoteVault: launch.quoteVault,
baseTokenProgram,
quoteTokenProgram,
quoteAmountIn: 1_000_000_000n,
minimumBaseOut: 33_000_000_000_000n,
});TypeScript guide →use pina_bonding_curve_client::instructions::{Buy, BuyInstructionData};
let data = BuyInstructionData::new(|data| {
data.quote_amount_in.set(1_000_000_000); // the most to spend, fee included
data.minimum_base_out.set(minimum_base_out);
})?;
let instruction = Buy::new(
trader,
state.config,
launch,
trader_base, // credited with base
trader_quote, // debited for quote
state.base_vault,
state.quote_vault,
base_token_program,
quote_token_program,
)
.instruction(data);Rust client guide →final instruction = getBuyInstruction(
programAddress: pinaBondingCurveProgramAddress,
trader: wallet.address,
config: launch.config,
launch: launchAddress,
traderBase: walletBase,
traderQuote: walletQuote,
baseVault: launch.baseVault,
quoteVault: launch.quoteVault,
baseTokenProgram: baseTokenProgram,
quoteTokenProgram: quoteTokenProgram,
quoteAmountIn: quoteAmountIn,
minimumBaseOut: minimumBaseOut,
);Dart guide →Buy {
trader: self.trader,
config: self.config,
launch: self.launch,
trader_base: self.trader_base,
trader_quote: self.trader_quote,
base_vault: self.base_vault,
quote_vault: self.quote_vault,
base_token_program: self.base_token_program,
quote_token_program: self.quote_token_program,
ix: BuyIx {
quote_amount_in,
minimum_base_out,
},
}
.invoke_signed(&curve, &[seeds.to_signer().as_signer()])?;CPI guide →cargo install pina_bonding_curve_cli
# Design a curve that raises 85 SOL while the price rises about 18x.
pina-curve design segment --from-price 0.000028 --to-price 0.000497 --quote 85000000000
# Launch a token, buy it, and graduate it once it completes.
pina-curve -u devnet launch create --config <CONFIG>
pina-curve -u devnet buy --base-mint <MINT> --quote-amount 1000000000
pina-curve -u devnet graduate --base-mint <MINT>CLI guide →Every launch ends in a real pool
Graduation creates a Pina AMM pool in a tier only this program can open pools in, so nobody can create it first. Someone who bought the last token on the curve sees the same price on the pool a block later.
Read the details
- Running a launchpadEvery term of a configuration, with presets to start from.
- Designing curvesThe segment model, its exact formulas, and a worked example.
- FeesThe decaying trading fee, the creator and partner split, and the migration fee.
- GraduationCompletion, price continuity, and where every token goes.
- InstructionsData, accounts, errors, and events for all nine instructions.
- SecurityThe threat model and the invariants the program enforces.