Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.raydium.io/llms.txt

Use this file to discover all available pages before exploring further.

This page documents the per-launch account graph: the PoolState (the root state account for one launch), its two vaults, the authority PDA, and the post-graduation references it gains when the launch settles.For the protocol-level config that bounds every launch, see products/launchlab/global-config. For the per-platform overlay, see products/launchlab/platform-config. For vesting accounts (VestingSchedule on PoolState, VestingRecord per beneficiary), see products/launchlab/vesting.

​
Account inventory

AccountOwnerPurpose
GlobalConfigLaunchLab programProtocol-level rules: fees, supply floors, migration wallets. One per (curve_type, index).
PlatformConfigLaunchLab programPer-platform overlay: branding, platform fee, NFT split at graduation, curve-shape whitelist.
PoolStateLaunchLab programPer-launch root state: mints, vaults, curve params, sold counters, fee counters, vesting schedule, graduation status.
authorityLaunchLab programSingle PDA at seed [b"vault_auth_seed"] that owns vaults across all launches and signs the post-graduation CPI.
base_vaultSPL Token / Token-2022Per-launch vault holding the unsold base tokens.
quote_vaultSPL TokenPer-launch vault holding accumulated quote tokens.
VestingRecordLaunchLab programPer-beneficiary cliff + linear-unlock record. Optional.
creator_fee_vaultSPL TokenPer-creator + per-quote-mint vault holding accrued creator fees, swept by ClaimCreatorFee.
platform_fee_vaultSPL TokenPer-platform + per-quote-mint vault holding accrued platform fees, swept by ClaimPlatformFeeFromVault.
(post-graduation) cpmm_pool_state or amm_pool_stateCPMM / AMM v4 programThe pool created by MigrateToCpswap / MigrateToAmm.
(post-graduation) Fee Key NFTLP-Lock programWraps the creator’s slice of LP at CPMM graduation; entitles the holder to ClaimCreatorFee on the CPMM pool.
The SDK’s raydium.launchpad.getLaunchById returns PoolState plus a flag indicating whether the launch has graduated; if it has, the post-migration pool ID is included.

​
PoolState

The per-launch root state. Field names below match the on-chain Rust struct (states/pool.rs); some values are simplified for readability — consult the source for the exact memory layout. 
// states/pool.rs (abridged)
pub struct PoolState {
    pub epoch:                     u64,        // recent_epoch tracker
    pub auth_bump:                 u8,
    pub status:                    u8,         // PoolStatus enum
    pub base_decimals:             u8,
    pub quote_decimals:            u8,
    pub migrate_type:              u8,         // 0 = AMM v4, 1 = CPMM
    pub supply:                    u64,        // total base tokens (no decimals)
    pub total_base_sell:           u64,        // base supply allocated to the curve
    pub virtual_base:              u64,        // virtual-reserve seed
    pub virtual_quote:             u64,        // virtual-reserve seed
    pub real_base:                 u64,        // base sold so far
    pub real_quote:                u64,        // quote raised so far (excl. fees)
    pub total_quote_fund_raising:  u64,        // graduation threshold in quote

    pub quote_protocol_fee:        u64,        // accrued, pending CollectFee
    pub platform_fee:              u64,        // accrued, pending ClaimPlatformFee
    pub migrate_fee:               u64,        // accrued, pending CollectMigrateFee
    pub vesting_schedule:          VestingSchedule,

    pub global_config:             Pubkey,
    pub platform_config:           Pubkey,
    pub creator:                   Pubkey,
    pub base_mint:                 Pubkey,
    pub quote_mint:                Pubkey,
    pub base_vault:                Pubkey,
    pub quote_vault:               Pubkey,

    pub amm_creator_fee_on:        u8,         // 0 = QuoteToken, 1 = BothToken (CPMM-only)
    pub token_program_flag:        u8,         // bit flags for SPL Token vs Token-2022
    pub padding:                   [u8; 54],
}

#[derive(Default, Debug, Clone)]
pub struct VestingSchedule {
    pub total_locked_amount:    u64,
    pub cliff_period:           u64,
    pub unlock_period:          u64,
    pub start_time:             u64,           // set at graduation
    pub allocated_share_amount: u64,           // running sum across VestingRecords
}
PoolStatus values (from the Anchor IDL): 
0 = Funding         — accepting buys / sells; below quote_reserve_target
1 = Migrate         — quote_reserve_target reached; awaiting MigrateTo*
2 = Migrated        — MigrateTo* already executed; vesting clock running
Integrator-facing fields:
  • status — three values, monotone (Funding → Migrate → Migrated). Reads always safe; writes gated.
  • real_base, real_quote — current curve state. Combined with virtual_base / virtual_quote they are sufficient to compute spot price without touching the vaults. See bonding-curve.
  • total_base_sell vs real_base — “progress toward graduation” ratio for UIs.
  • migrate_type — selects whether MigrateToAmm or MigrateToCpswap is the valid graduation path. Token-2022 launches must use CPMM.
  • amm_creator_fee_on — only meaningful when graduating to CPMM. Picks creator_fee_on = OnlyQuoteToken (0) or BothToken (1) on the post-graduation CPMM pool. Despite the name, this enum effectively also drives the migration target — BothToken is paired with MigrateToAmm in current operational practice; QuoteToken with MigrateToCpswap. See creator-fees.
  • quote_protocol_fee / platform_fee / migrate_fee — three independent fee counters. Each has its own claim instruction; see instructions.
  • vesting_schedule — present on every PoolState but inactive when total_locked_amount == 0. See vesting for the full lifecycle.

​
The authority PDA

LaunchLab uses a single authority PDA across all launches, derived with no per-launch seed: 
const LAUNCHLAB_PROGRAM_ID = new PublicKey("<LAUNCHLAB_ID>"); // see reference/program-addresses

const [authority, bump] = PublicKey.findProgramAddressSync(
  [Buffer.from("vault_auth_seed")],
  LAUNCHLAB_PROGRAM_ID,
);
That single PDA is:
  • The authority on every launch’s base_vault and quote_vault.
  • The mint_authority on each launch’s base_mint (pre-graduation).
  • The signer on the post-graduation CPI to AMM v4 / CPMM (MigrateTo*).
  • The signer on ClaimVestedToken transfers out of the base vault.
The mint_authority is revoked immediately after MigrateToAmm / MigrateToCpswap so the supply is permanently fixed. Two additional PDAs gate the fee vaults: 
const [creatorFeeVaultAuthority] = PublicKey.findProgramAddressSync(
  [Buffer.from("creator_fee_vault_auth_seed")],
  LAUNCHLAB_PROGRAM_ID,
);

const [platformFeeVaultAuthority] = PublicKey.findProgramAddressSync(
  [Buffer.from("platform_fee_vault_auth_seed")],
  LAUNCHLAB_PROGRAM_ID,
);
These sign the transfer out of the corresponding fee vaults during ClaimCreatorFee and ClaimPlatformFeeFromVault.

​
Base mint

Created inline by Initialize with:
  • mint_authority = authority (revoked at graduation).
  • freeze_authority = None.
  • supply = supply, entirely minted into base_vault.
  • decimals chosen by the creator at Initialize (commonly 6).
Because the full supply is pre-minted, base_mint.supply is constant for the life of the launch. Curve buys move tokens from base_vault to the buyer, but do not call mint_to. Initialize / InitializeV2 create SPL Token launches. The dedicated InitializeWithToken2022 instruction lets the base mint be a Token-2022 mint (with optional TransferFeeConfig); the quote mint is still SPL Token. Token-2022 launches must graduate to a CPMM pool because AMM v4 only supports SPL Token vaults.

​
Vaults

Both base_vault and quote_vault are standard SPL Token accounts owned by the LaunchLab authority PDA. Addresses are stored on PoolState and can also be derived: 
const [baseVault] = PublicKey.findProgramAddressSync(
  [Buffer.from("pool_vault"), poolState.toBuffer(), baseMint.toBuffer()],
  LAUNCHLAB_PROGRAM_ID,
);
const [quoteVault] = PublicKey.findProgramAddressSync(
  [Buffer.from("pool_vault"), poolState.toBuffer(), quoteMint.toBuffer()],
  LAUNCHLAB_PROGRAM_ID,
);
(Verify the exact seed prefixes from the source’s Initialize accounts struct before relying on a derivation in production.)

​
Fee vaults

Two PDAs aggregate fees across launches:
  • Creator fee vault — PDA at seeds [creator, quote_mint]. Every launch that earns the same creator fees on the same quote mint pours into the same vault. The creator sweeps it via ClaimCreatorFee.
  • Platform fee vault — PDA at seeds [platform_config, quote_mint]. Every launch routed through the same platform that uses the same quote mint pours into the same vault. The platform’s platform_fee_wallet sweeps it via ClaimPlatformFeeFromVault. There is also a per-launch sweep variant (ClaimPlatformFee) that pulls from the launch’s quote_vault directly without going through the aggregated vault.
The aggregated-vault pattern is what lets a high-volume creator or platform amortize the rent cost of fee accumulation across many launches.

​
Quote vault ↔ real_quote

quote_vault.balance and PoolState.real_quote should stay in sync. They can drift by at most the sum of the three pending fee counters (quote_protocol_fee, platform_fee, migrate_fee), which sit in the vault but belong to the fee counters and not the curve reserve. The curve math always uses real_quote, never the raw vault balance. Pre-graduation invariant: 
quote_vault.balance ==
   real_quote
 + quote_protocol_fee
 + platform_fee
 + migrate_fee

​
Lifecycle account transitions

EventStatusreal_basereal_quotePost-graduation pool
InitializeFunding00—
BuyExactIn / BuyExactOutFunding+base_out+quote_in_after_fee—
SellExactIn / SellExactOutFunding−base_in−quote_out_before_fee—
MigrateToAmm / MigrateToCpswapFunding → Migrate → Migrated(frozen)(frozen)created, LP split per PlatformConfig
ClaimCreatorFee / ClaimPlatformFee*any——drains a fee vault
CreateVestingAccountFunding——bumps vesting_schedule.allocated_share_amount
ClaimVestedTokenMigrated only——drains base_vault

​
Where to go next

Sources:
  • raydium-launch/programs/launchpad/src/states/pool.rs — PoolState, PoolStatus, VestingSchedule, AmmCreatorFeeOn.
  • raydium-launch/programs/launchpad/src/lib.rs — PDA seed constants (AUTH_SEED, CREATOR_FEE_VAULT_AUTH_SEED, PLATFORM_FEE_VAULT_AUTH_SEED).
  • Raydium SDK v2 launchpad module.