The Launchpad for Builders.

Call the Bond program's launch instruction, not LaunchLab's initialize_v2. One instruction creates the token, its Raydium LaunchLab curve under the PlatformConfig of the creator-fee tier you pick, its Launch account in the Bond program and the optional dev buy.

The token is a Bond token from its first slot. It is listed on bond.rip. Its creator claims that token's creator fees at bond.rip/creator. It uses Bond's standard curve: 1 billion supply, 793.1 million sold on the curve, graduation at 85 SOL raised on SOL pairs (the same value in USD on other quotes). Its liquidity is locked when it graduates to Raydium CPMM.

The IDL is the compact file Bond's app builds its own transactions from: each instruction has its discriminator, its accounts in order (w marks a writable account, s a signer, fixed programs carry their address) and its arguments.

In this order, Borsh-encoded after the 8-byte discriminator (strings as a u32 length then the bytes, integers little-endian).

Two signatures: the creator and a new mint keypair. Another wallet may pay the transaction fee, but the creator still signs and pays the rent. LaunchLab creates the mint (SPL Token, 6 decimals), so the address must be fresh.

Any address works: the program does not check it. Bond's app uses an address ending in "bond" when it has one ready, which is only cosmetic, and a "bond" address you grind yourself works the same.

Launch tools can also take one of Bond's pooled "bond" addresses through the partner API, with a Bearer key from Bond (ask us on X). POST /api/partner/v1/reserve holds an address for 3 minutes, POST /api/partner/v1/sign adds the mint's signature to your launch transaction (Normal mode; Bond never broadcasts it), and GET /api/partner/v1/status shows the pool and your quota.

PDA ["a", b] is the program address of those seeds: strings as UTF-8, addresses as their 32 bytes, the tier as one byte. Bond PDAs are under the Bond program, LaunchLab PDAs under LaunchLab.

Put the launch first. Buys follow in separate transactions of the same bundle, so in the same slot, or after the launch instruction in the same transaction when the size allows. With the lookup table a launch alone takes about 950 to 1 100 of the 1 232 bytes, so a buy rarely fits beside it.

Buys go straight to Raydium LaunchLab (buy_exact_in or buy_exact_out): the Bond program is not in the buy path. Every account of a buy is known before the launch lands, so buys can be built and signed in advance. The pool is the LaunchLab PDA ["pool", mint, quote_mint].

Important: the LaunchLab pool creator of a Bond token is Bond's collector, not the creator's wallet. The creator fee vault of a buy is therefore derived from the collector, and the platform config is the tier's. A buy built with the creator's wallet or another config fails.

The launch carries 31 accounts: compile it as a v0 transaction with Bond's lookup table, and size its priority fee or tip so it lands before your buys. A buy that runs first fails, because the pool does not exist yet.

With @solana/kit, in Normal mode. This exact code is tested against the instruction Bond's app builds.

import { AccountRole, address, getAddressEncoder, getProgramDerivedAddress,
  getU16Encoder, getU32Encoder, getU64Encoder, type Address } from "@solana/kit";

const BOND = address("FuLFQxK2mSwArxUsdw3VyPnwdJZ6ytvBzYx4dkAVTbaS");
const LAUNCHLAB = address("LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj");
const METADATA = address("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
const ATA = address("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
const TOKEN = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");

const A = (a: Address) => getAddressEncoder().encode(a);
const pda = async (program: Address, ...seeds: (string | Uint8Array)[]) =>
  (await getProgramDerivedAddress({ programAddress: program, seeds }))[0];
const ata = (owner: Address, mint: Address, tokenProgram: Address) =>
  pda(ATA, A(owner), A(tokenProgram), A(mint));
const str = (s: string) => {
  const b = new TextEncoder().encode(s);
  return [...getU32Encoder().encode(b.length), ...b];
};

type IdlAccount = { name: string; address?: string; w?: number; s?: number };

export async function bondLaunchIx(p: {
  creator: Address; mint: Address; // both sign the transaction
  quote: Address; quoteTokenProgram: Address; globalConfig: Address;
  tier: number; name: string; symbol: string; uri: string;
  devShareBps: number; maxQuoteIn: bigint;
}) {
  const idl = await (await fetch("https://bond.rip/api/idl")).json();
  const def = idl.instructions.find((i: { name: string }) => i.name === "launch");
  const t = Uint8Array.of(p.tier);
  const collector = await pda(BOND, "collector");
  const platformConfig = await pda(LAUNCHLAB, "platform_config", A(await pda(BOND, "tier", t)));
  const pool = await pda(LAUNCHLAB, "pool", A(p.mint), A(p.quote));
  const vault = await pda(BOND, "vault", A(p.mint));
  const accounts: Record<string, Address> = {
    creator: p.creator,
    mint: p.mint,
    config: await pda(BOND, "config"),
    quote_config: await pda(BOND, "quote", A(p.quote)),
    tier_state: await pda(BOND, "tier_state", t),
    tier_quote: await pda(BOND, "tier_quote", t, A(p.quote)),
    launch: await pda(BOND, "launch", A(p.mint)),
    platform_config: platformConfig,
    collector,
    vault,
    vault_base: await ata(vault, p.mint, TOKEN),
    vault_quote: await ata(vault, p.quote, p.quoteTokenProgram),
    creator_base: await ata(p.creator, p.mint, TOKEN),
    creator_quote: await ata(p.creator, p.quote, p.quoteTokenProgram),
    quote_mint: p.quote,
    global_config: p.globalConfig,
    ll_authority: await pda(LAUNCHLAB, "vault_auth_seed"),
    pool_state: pool,
    base_vault: await pda(LAUNCHLAB, "pool_vault", A(pool), A(p.mint)),
    quote_vault: await pda(LAUNCHLAB, "pool_vault", A(pool), A(p.quote)),
    metadata: await pda(METADATA, "metadata", A(METADATA), A(p.mint)),
    event_authority: await pda(LAUNCHLAB, "__event_authority"),
    platform_fee_vault: await pda(LAUNCHLAB, A(platformConfig), A(p.quote)),
    creator_fee_vault: await pda(LAUNCHLAB, A(collector), A(p.quote)),
    quote_token_program: p.quoteTokenProgram,
  };
  const data = Uint8Array.from([
    ...def.discriminator,
    p.tier,
    0, // mode: Normal
    ...str(p.name), ...str(p.symbol), ...str(p.uri),
    ...getU16Encoder().encode(p.devShareBps),
    ...getU32Encoder().encode(0), // vest_duration
    ...getU32Encoder().encode(0), // tranche_interval
    ...getU64Encoder().encode(p.maxQuoteIn),
  ]);
  return {
    programAddress: BOND,
    accounts: def.accounts.map((a: IdlAccount) => ({
      address: a.address ? address(a.address) : accounts[a.name],
      role: a.s
        ? a.w ? AccountRole.WRITABLE_SIGNER : AccountRole.READONLY_SIGNER
        : a.w ? AccountRole.WRITABLE : AccountRole.READONLY,
    })),
    data,
  };
}

// The transaction: a 600 000 compute unit limit and a priority fee, the creator's quote
// account (idempotent create; for SOL, wrap max_quote_in into it), then bondLaunchIx.
// Compile it as a v0 message with Bond's lookup table and sign with creator and mint.

Anyone can call LaunchLab's initialize_v2 with one of Bond's PlatformConfigs, without the Bond program. Such a pool becomes a Bond token once it is adopted: the Bond program's adopt(tier) instruction (anyone can call it) creates its Launch account. Bond's keeper adopts every such pool within minutes, and a tool can put adopt right after initialize_v2 in the same transaction. What to know:

• The creator Bond pays is the pool's LaunchLab creator, fixed when the pool is created: pass the dev's wallet as creator. Bond's configs set LaunchLab's own creator fee to 0 and charge the whole fee (Bond's 0.75 % plus the tier's creator fee) into the tier's shared vault, so the creator is paid only through Bond, after adoption.
• Fees from before adoption are credited at adoption from Raydium's per-pool counter. In rare cases (counter reset by Raydium, surplus already swept) they come through a public 24 h catch-up instead.
• The curve (supply, amount sold, raise, start market cap) is whatever the tool sets, not Bond's standard curve; adoption does not change it.
• At graduation it migrates exactly like a Bond launch, as Bond's PlatformConfig sets: the tier's CPMM config, 100 % of the LP locked, the Fee Key NFT and the CPMM pool creator going to Bond's collector. Pools that graduated before adoption are adopted too, and their post-graduation creator fees are paid from then on.
• Never create such a pool with amm_fee_on set to BothToken (Bond's launch uses QuoteToken): its base-side creator fees after graduation cannot be handled, so the pool can never be adopted.
• With a quote Bond has not enabled, adoption waits until Bond enables that quote.
• No cap on the dev buy, no Tech dev vault, and no pooled "bond" address (Bond's partner API only co-signs the launch instruction).

The launch instruction stays the simplest path: the token is a Bond token from its first slot, with Bond's standard curve.

The pool's platform_config field identifies the tier. These five addresses are fixed and never rotated; each is named Bond with the website https://bond.rip. A Bond token also has its Launch account in the Bond program (PDA ["launch", mint]). Anyone can create a LaunchLab pool under these configs directly, so count only pools that have a Launch account.

Launch tool, bundler, bot, terminal or indexer: send us a message on X and we reply with anything else you need.