Cuentas de LaunchLab

Esta página fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.Ver versión en inglés →

Esta página documenta el gráfico de cuentas por lanzamiento: el PoolState (la cuenta de estado raíz para un lanzamiento), sus dos vaults, el PDA de autoridad, y las referencias posteriores a la graduación que adquiere cuando el lanzamiento se liquida.Para la configuración a nivel de protocolo que vincula cada lanzamiento, consulta products/launchlab/global-config. Para la superposición por plataforma, consulta products/launchlab/platform-config. Para cuentas de vesting (VestingSchedule en PoolState, VestingRecord por beneficiario), consulta products/launchlab/vesting.

Inventario de cuentas

Cuenta	Propietario	Propósito
`GlobalConfig`	Programa LaunchLab	Reglas a nivel de protocolo: comisiones, pisos de suministro, carteras de migración. Una por `(curve_type, index)`.
`PlatformConfig`	Programa LaunchLab	Superposición por plataforma: marca, comisión de plataforma, división de NFT en graduación, conmutador de parámetros de lanzamiento y gestor de reglas. 944 bytes fijos.
`PoolState`	Programa LaunchLab	Estado raíz por lanzamiento: mints, vaults, parámetros de curva, contadores de vendidos, contadores de comisiones, cronograma de vesting, estado de graduación.
`authority`	Programa LaunchLab	PDA único con semilla `[b"vault_auth_seed"]` que posee vaults en todos los lanzamientos y firma el CPI posterior a la graduación.
`base_vault`	SPL Token / Token-2022	Vault por lanzamiento que contiene los tokens base no vendidos.
`quote_vault`	SPL Token / Token-2022	Vault por lanzamiento que contiene tokens quote acumulados. Sigue el programa que posee el mint quote.
`VestingRecord`	Programa LaunchLab	Registro por beneficiario de acantilado + desbloqueo lineal. Opcional.
`creator_fee_vault`	SPL Token / Token-2022	Vault por creador + por mint quote que contiene comisiones de creador acumuladas, barridas por `ClaimCreatorFee`. Sigue el programa del mint quote.
`platform_fee_vault`	SPL Token / Token-2022	Vault por plataforma + por mint quote que contiene comisiones de plataforma acumuladas, barridas por `ClaimPlatformFeeFromVault`. Sigue el programa del mint quote.
`PlatformAllowConfig`	Programa LaunchLab	Permiso gestionado por plataforma opcional para un par `(PlatformConfig, GlobalConfig)`. Se verifica solo cuando la plataforma habilita la restricción.
`PlatformCurveRule`	Programa LaunchLab	Regla de parámetro de lanzamiento gestionada por plataforma opcional para un par `(PlatformConfig, GlobalConfig)`. Se verifica solo cuando la plataforma establece `restrict_curve_param`. Tamaño variable, 150 bytes vacío.
(post-graduación) `cpmm_pool_state`	Programa CPMM	Pool creado por `MigrateToCpswap` para cada lanzamiento nuevo. El estado heredado aún puede hacer referencia a una graduación AMM v4.
(post-graduación) Fee Key NFT	Programa LP-Lock	Antes de la actualización del 2026-08-17, las escalas de plataforma y creador podían producir Fee Keys separadas. Las migraciones ejecutadas después combinan ambas escalas en una Fee Key de plataforma.

El SDK lee esto con raydium.launchpad.getRpcPoolInfo({ poolId }), que devuelve el PoolState decodificado con el GlobalConfig vinculado adjunto como configInfo (getRpcPoolsInfo({ poolIdList }) para la forma por lotes). No existe getLaunchById. El id del pool en sí es un PDA de (programId, mintA, mintB) — getPdaLaunchpadPoolId.

`PoolState`

El estado raíz por lanzamiento. Los nombres de campo a continuación coinciden con la estructura Rust en cadena (states/pool.rs); algunos valores se simplifican para legibilidad — consulta la fuente para el diseño exacto de memoria.

// 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 base_mint:                 Pubkey,
    pub quote_mint:                Pubkey,
    pub base_vault:                Pubkey,
    pub quote_vault:               Pubkey,
    pub creator:                   Pubkey,     // NOTE: last of the seven pubkeys, not third

    pub token_program_flag:        u8,         // bit0 = base mint, bit1 = quote mint; 0 = SPL Token, 1 = Token-2022
    pub amm_creator_fee_on:        u8,         // 0 = QuoteToken, 1 = BothToken (CPMM-only)
    pub platform_vesting_share:    u64,        // the platform's slice of total_locked_amount
    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
}

Valores de PoolStatus (los nombres de variante del IDL son Fund / Migrate / Trade):

= Fund            — accepting buys / sells; below total_quote_fund_raising
= Migrate         — threshold reached; awaiting MigrateToAmm / MigrateToCpswap
= Trade           — migration done; post-graduation AMM trading, vesting clock running

Campos orientados al integrador:

status — tres valores, monótonos (Fund → Migrate → Trade). Las lecturas siempre son seguras; las escrituras están controladas. ClaimVestedToken requiere Trade.
real_base, real_quote — estado actual de la curva. Combinados con virtual_base / virtual_quote son suficientes para calcular el precio spot sin tocar los vaults. Consulta bonding-curve.
total_base_sell vs real_base — relación de “progreso hacia graduación” para interfaces de usuario.
migrate_type — la nueva inicialización requiere 1 (CPSWAP). Un 0 almacenado sigue siendo significativo solo para un lanzamiento existente creado antes de la aplicación exclusiva de CPMM.
amm_creator_fee_on — elige creator_fee_on = OnlyQuoteToken (0) o BothToken (1) en el pool CPMM posterior a la graduación. No elige el destino de migración. Consulta creator-fees.
token_program_flag — un campo de bits, no un booleano. Bit0 es el mint base y bit1 es el mint quote, cada uno 0 para SPL Token y 1 para Token-2022, por lo que el byte toma cuatro valores: 0 (ambos heredados), 1 (Token-2022 base), 2 (Token-2022 quote), 3 (ambos Token-2022). Lee un mint con (token_program_flag >> bit) & 1. Comparar el byte completo contra 0 para clasificar el mint base resuelve 2 al programa incorrecto. Bit1 fue constante 0 hasta que se admitieron mints quote Token-2022.
quote_protocol_fee / platform_fee / migrate_fee — tres contadores de comisión independientes. Cada uno tiene su propia instrucción de reclamación; consulta instructions.
vesting_schedule — presente en cada PoolState pero inactivo cuando total_locked_amount == 0. Consulta vesting para el ciclo de vida completo.

El PDA de autoridad

LaunchLab utiliza un único PDA de autoridad en todos los lanzamientos, derivado sin semilla por lanzamiento:

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,
);

Ese PDA único es:

La autoridad en cada base_vault y quote_vault de lanzamiento.
Nada en el base_mint — la autoridad de mint se revoca antes de que InitializeV2 regrese (consulta a continuación).
El firmante en el CPI de graduación CPMM, y en la graduación AMM v4 heredada para estado existente.
El firmante en las transferencias ClaimVestedToken fuera del vault base.
El transfer_fee_config_authority en la TransferFeeConfig de un mint base Token-2022, para toda la fase anterior a la graduación — y su withdraw_withheld_authority también, pero solo cuando la plataforma dejó PlatformConfig.transfer_fee_extension_auth sin establecer.

El mint_authority se revoca en la instrucción initialize, no en la graduación: InitializeV2 e InitializeWithToken2022 acuñan el suministro completo en base_vault y luego establecen MintTokens en None en la misma instrucción. El suministro es por lo tanto fijo desde el momento en que existe el lanzamiento, y la migración no tiene paso de autoridad de mint. Un efecto secundario: nadie puede firmar por el mint base, por lo que su renta no puede ser reclamada por CollectExcessLamports. Dos PDAs adicionales controlan los vaults de comisión:

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,
);

Estos firman la transferencia fuera del vault de comisión correspondiente durante ClaimCreatorFee y ClaimPlatformFeeFromVault.

Mint base

Creado en línea por Initialize con:

mint_authority = authority (revocado en graduación).
freeze_authority = None.
supply = supply, completamente acuñado en base_vault.
decimals elegido por el creador en Initialize (comúnmente 6).

Debido a que el suministro completo está pre-acuñado, base_mint.supply es constante durante la vida del lanzamiento. Las compras de curva mueven tokens de base_vault al comprador, pero no llaman a mint_to. Initialize / InitializeV2 crean mints base SPL Token. La instrucción dedicada InitializeWithToken2022 permite que el mint base sea un mint Token-2022 (con TransferFeeConfig opcional). Los tres caminos de inicialización requieren graduación CPMM. Cuando InitializeWithToken2022 adjunta un TransferFeeConfig, el mint se crea con transfer_fee_config_authority = authority y withdraw_withheld_authority = PlatformConfig.transfer_fee_extension_auth, retrocediendo a authority cuando la plataforma no ha establecido ese campo. Ambas autoridades se reasignan a la clave de plataforma en graduación, el lado de retiro solo si el PDA aún lo posee. Consulta platform-config. El mint quote es independiente del mint base y puede ser en sí mismo un mint Token-2022 — InitializeV2 e InitializeWithToken2022 aceptan cualquier programa en su ranura de programa quote. El Initialize deprecado no: su cuenta de programa quote aún está tipificada a SPL Token, por lo que una configuración cuyo mint quote es Token-2022 solo puede lanzarse a través de los otros dos. LaunchLab nunca crea el mint quote; es lo que GlobalConfig.quote_mint nombra. Consulta global-config y reference/token-2022-support.

Vaults

Tanto base_vault como quote_vault son cuentas de token propiedad del PDA authority de LaunchLab, cada una creada en el programa que posee su propio mint — por lo que un lanzamiento puede tener un vault base heredado y un vault quote Token-2022, o cualquier otra combinación. token_program_flag registra cuál es cuál. Las direcciones se almacenan en PoolState y también se pueden derivar:

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,
);

(Verifica los prefijos de semilla exactos de la estructura de cuentas Initialize de la fuente antes de confiar en una derivación en producción.)

Vaults de comisión

Dos PDAs agregan comisiones en todos los lanzamientos:

Vault de comisión de creador — PDA con semillas [creator, quote_mint]. Cada lanzamiento que gana las mismas comisiones de creador en el mismo mint quote vierte en el mismo vault. El creador lo barre a través de ClaimCreatorFee.
Vault de comisión de plataforma — PDA con semillas [platform_config, quote_mint]. Cada lanzamiento enrutado a través de la misma plataforma que usa el mismo mint quote vierte en el mismo vault. El platform_fee_wallet de la plataforma lo barre a través de ClaimPlatformFeeFromVault. También hay una variante de barrido por lanzamiento (ClaimPlatformFee) que extrae del quote_vault del lanzamiento directamente sin pasar por el vault agregado.

Ambos se crean de forma perezosa en el primer swap que acumula una comisión, en el programa que posee el mint quote. Un creador o plataforma que ejecuta lanzamientos contra un mint quote heredado y uno Token-2022 termina con un vault por mint, como ya lo hizo para dos mints heredados diferentes. El patrón de vault agregado es lo que permite que un creador o plataforma de alto volumen amortice el costo de renta de acumulación de comisiones en muchos lanzamientos.

Quote vault ↔ `real_quote`

quote_vault.balance y PoolState.real_quote deben mantenerse sincronizados. Pueden desviarse como máximo por la suma de los tres contadores de comisión pendientes (quote_protocol_fee, platform_fee, migrate_fee), que se encuentran en el vault pero pertenecen a los contadores de comisión y no a la reserva de curva. Las matemáticas de curva siempre usan real_quote, nunca el saldo bruto del vault. Invariante anterior a la graduación:

quote_vault.balance ==
   real_quote
 + quote_protocol_fee
 + platform_fee
 + migrate_fee

`PlatformCurveRule`

Una cuenta por par (PlatformConfig, GlobalConfig), que contiene las formas de lanzamiento que esa plataforma permite en esa configuración. Las semillas del PDA son [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,
}

La cuenta se crea sin grupo y se redimensiona en cada cambio de grupo, por lo que su longitud es 150 + Σ(14 + 18 × constraints) y los decodificadores no deben asumir un tamaño fijo. Los grupos se ORean: un lanzamiento se permite tan pronto como se cumplen todas las restricciones de un grupo. Cero grupos significa sin restricción. Léelo solo cuando el PlatformConfig.restrict_curve_param propietario sea 1 — en 0 el programa ignora la cuenta, y una regla obsoleta bien puede estar sentada allí. Los IDs de campo, operadores y los manuales están en products/launchlab/curve-rules.

Transiciones de ciclo de vida de cuentas

Evento	Estado	`real_base`	`real_quote`	Pool posterior a graduación
`Initialize`	Funding	0	0	—
`BuyExactIn` / `BuyExactOut`	Funding	`+base_out`	`+quote_in_after_fee`	—
`SellExactIn` / `SellExactOut`	Funding	`−base_in`	`−quote_out_before_fee`	—
`MigrateToCpswap` (o heredado `MigrateToAmm`)	Funding → Migrate → Migrated	(congelado)	(congelado)	creado; LP de CPMM se divide en LP bloqueado propiedad de plataforma y LP quemado
`ClaimCreatorFee` / `ClaimPlatformFee*`	cualquiera	—	—	drena un vault de comisión
`CreateVestingAccount`	Funding	—	—	aumenta `vesting_schedule.allocated_share_amount`
`ClaimVestedToken`	Solo Migrated	—	—	drena `base_vault`
`CollectExcessLamports`	cualquiera	—	—	— (mueve solo lamports, nunca saldos de token)

Dónde ir a continuación

products/launchlab/bonding-curve — las matemáticas detrás de real_base ↔ real_quote.
products/launchlab/instructions — listas de cuentas por instrucción.
products/launchlab/global-config — vinculación a nivel de protocolo.
products/launchlab/platform-config — superposición de plataforma.
products/launchlab/vesting — mecánica de suministro bloqueado.
products/cpmm/accounts — cómo se ve el cpmm_pool_state posterior a la graduación.

Fuentes:

raydium-launch/programs/launchpad/src/states/pool.rs — PoolState, PoolStatus, VestingSchedule, AmmCreatorFeeOn.
raydium-launch/programs/launchpad/src/lib.rs — constantes de semilla de PDA (AUTH_SEED, CREATOR_FEE_VAULT_AUTH_SEED, PLATFORM_FEE_VAULT_AUTH_SEED).
Módulo launchpad del SDK de Raydium v2.

LaunchLab

Flujo de lanzamiento de token

Tips & Gotchas

Inventario de cuentas

`PoolState`

El PDA de autoridad

Mint base

Vaults

Vaults de comisión

Quote vault ↔ `real_quote`

`PlatformCurveRule`

Transiciones de ciclo de vida de cuentas

Dónde ir a continuación

​Inventario de cuentas

​PoolState

​El PDA de autoridad

​Mint base

​Vaults

​Vaults de comisión

​Quote vault ↔ real_quote

​PlatformCurveRule

​Transiciones de ciclo de vida de cuentas

​Dónde ir a continuación

Inventario de cuentas

`PoolState`

El PDA de autoridad

Mint base

Vaults

Vaults de comisión

Quote vault ↔ `real_quote`

`PlatformCurveRule`

Transiciones de ciclo de vida de cuentas

Dónde ir a continuación