LaunchLab accounts

PoolState (per-launch root), the base and quote vaults, the authority PDA, and the small graph of per-launch accounts. Protocol-level GlobalConfig and platform-level PlatformConfig live on their own pages.

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

Account	Owner	Purpose
GlobalConfig	LaunchLab program	Protocol-level rules: fees, supply floors, migration wallets. One per (curve_type, index).
PlatformConfig	LaunchLab program	Per-platform overlay: branding, platform fee, NFT split at graduation, launch-parameter switch and rule manager. Fixed 944 bytes.
PoolState	LaunchLab program	Per-launch root state: mints, vaults, curve params, sold counters, fee counters, vesting schedule, graduation status.
authority	LaunchLab program	Single PDA at seed [b"vault_auth_seed"] that owns vaults across all launches and signs the post-graduation CPI.
base_vault	SPL Token / Token-2022	Per-launch vault holding the unsold base tokens.
quote_vault	SPL Token / Token-2022	Per-launch vault holding accumulated quote tokens. Follows whichever program owns the quote mint.
VestingRecord	LaunchLab program	Per-beneficiary cliff + linear-unlock record. Optional.
creator_fee_vault	SPL Token / Token-2022	Per-creator + per-quote-mint vault holding accrued creator fees, swept by ClaimCreatorFee. Follows the quote mint’s program.
platform_fee_vault	SPL Token / Token-2022	Per-platform + per-quote-mint vault holding accrued platform fees, swept by ClaimPlatformFeeFromVault. Follows the quote mint’s program.
PlatformAllowConfig	LaunchLab program	Optional platform-managed permission for one (PlatformConfig, GlobalConfig) pair. Checked only when the platform enables restriction.
PlatformCurveRule	LaunchLab program	Optional platform-managed launch-parameter rule for one (PlatformConfig, GlobalConfig) pair. Checked only when the platform sets restrict_curve_param. Variable size, 150 bytes empty.
(post-graduation) cpmm_pool_state	CPMM program	Pool created by MigrateToCpswap for every new launch. Legacy state can still reference an AMM v4 graduation.
(post-graduation) Fee Key NFT	LP-Lock program	Before the 2026-08-17 upgrade, platform and creator scales could produce separate Fee Keys. Migrations executed afterward combine both scales into one platform Fee Key.

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,         // bit0 = base mint, bit1 = quote mint; 0 = SPL Token, 1 = 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 — new initialization requires 1 (CPSWAP). A stored 0 remains meaningful only for an existing launch created before CPMM-only enforcement.
• amm_creator_fee_on — picks creator_fee_on = OnlyQuoteToken (0) or BothToken (1) on the post-graduation CPMM pool. It does not choose the migration target. See creator-fees.
• token_program_flag — a bitfield, not a boolean. Bit0 is the base mint and bit1 is the quote mint, each 0 for SPL Token and 1 for Token-2022, so the byte takes four values: 0 (both legacy), 1 (Token-2022 base), 2 (Token-2022 quote), 3 (both Token-2022). Read one mint with (token_program_flag >> bit) & 1. Comparing the whole byte against 0 to classify the base mint resolves 2 to the wrong program. Bit1 was constant 0 until Token-2022 quote mints were supported.
• 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 CPMM graduation CPI, and on legacy AMM v4 graduation for existing state.
• The signer on ClaimVestedToken transfers out of the base vault.
• The transfer_fee_config_authority on a Token-2022 base mint’s TransferFeeConfig, for the whole pre-graduation phase — and its withdraw_withheld_authority too, but only when the platform left PlatformConfig.transfer_fee_extension_auth unset.

The mint_authority is revoked immediately after MigrateToCpswap or a legacy MigrateToAmm call, 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 base mints. The dedicated InitializeWithToken2022 instruction lets the base mint be a Token-2022 mint (with optional TransferFeeConfig). All three initialization paths require CPMM graduation.

When InitializeWithToken2022 attaches a TransferFeeConfig, the mint is created with transfer_fee_config_authority = authority and withdraw_withheld_authority = PlatformConfig.transfer_fee_extension_auth, falling back to authority when the platform has not set that field. Both authorities are reassigned to the platform key at graduation, the withdraw side only if the PDA still holds it. See platform-config.

The quote mint is independent of the base mint and may itself be a Token-2022 mint — InitializeV2 and InitializeWithToken2022 accept either program in their quote-program slot. The deprecated Initialize does not: its quote-program account is still typed to SPL Token, so a config whose quote mint is Token-2022 can only be launched through the other two. The quote mint is never created by LaunchLab; it is whatever GlobalConfig.quote_mint names. See global-config and reference/token-2022-support.

Vaults

Both base_vault and quote_vault are token accounts owned by the LaunchLab authority PDA, each created on the program that owns its own mint — so a launch can have a legacy base vault and a Token-2022 quote vault, or any other combination. token_program_flag records which is which. 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.

Both are created lazily on the first swap that accrues a fee, on whichever program owns the quote mint. A creator or platform that runs launches against both a legacy and a Token-2022 quote mint ends up with one vault per mint, as it already did for two different legacy mints.

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

PlatformCurveRule

One account per (PlatformConfig, GlobalConfig) pair, holding the launch shapes that platform permits on that config. PDA seeds are [b"platform_curve_rule", platform_config, global_config].

#[account]
pub struct PlatformCurveRule {
    pub bump:            u8,
    pub version:         u8,
    pub platform_config: Pubkey,
    pub global_config:   Pubkey,
    pub epoch:           u64,
    pub padding:         [u64; 8],
    pub groups:          Vec<CurveRuleGroup>,   // up to 10
}

pub struct CurveRuleGroup {
    pub group_id:    u16,                       // stable id, used to update or remove the group
    pub epoch:       u64,
    pub constraints: Vec<ParamConstraint>,      // up to 25, ANDed
}

pub struct ParamConstraint {
    pub field: u8,                              // which launch parameter
    pub op:    u8,                              // 0 Eq, 1 Gte, 2 Lte, 3 Neq
    pub value: u128,
}

The account is created holding no group and resized on every group change, so its length is 150 + Σ(14 + 18 × constraints) and decoders must not assume a fixed size. Groups are ORed: a launch is allowed as soon as one group’s constraints all hold. Zero groups means no restriction.

Read it only when the owning PlatformConfig.restrict_curve_param is 1 — at 0 the program ignores the account, and a stale rule may well be sitting there. Field ids, operators, and the playbooks are in products/launchlab/curve-rules.

Lifecycle account transitions

Event	Status	real_base	real_quote	Post-graduation pool
Initialize	Funding	0	0	—
BuyExactIn / BuyExactOut	Funding	+base_out	+quote_in_after_fee	—
SellExactIn / SellExactOut	Funding	−base_in	−quote_out_before_fee	—
MigrateToCpswap (or legacy MigrateToAmm)	Funding → Migrate → Migrated	(frozen)	(frozen)	created; CPMM LP is split into platform-owned locked LP and burned LP
ClaimCreatorFee / ClaimPlatformFee*	any	—	—	drains a fee vault
CreateVestingAccount	Funding	—	—	bumps vesting_schedule.allocated_share_amount
ClaimVestedToken	Migrated only	—	—	drains base_vault

Where to go next

• products/launchlab/bonding-curve — the math behind real_base ↔ real_quote.
• products/launchlab/instructions — per-instruction account lists.
• products/launchlab/global-config — protocol-level binding.
• products/launchlab/platform-config — platform overlay.
• products/launchlab/vesting — locked supply mechanics.
• products/cpmm/accounts — what the post-graduation cpmm_pool_state looks like.

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.