Cuentas de LaunchLab

PoolState (raíz por lanzamiento), los vaults base y quote, el PDA de autoridad, y el gráfico de cuentas por lanzamiento. GlobalConfig a nivel de protocolo y PlatformConfig a nivel de plataforma se encuentran en sus propias páginas.

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: 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 limita 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, billeteras 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. Fijo 944 bytes.
PoolState	Programa LaunchLab	Estado raíz por lanzamiento: mints, vaults, parámetros de curva, contadores 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 de cliff + desbloqueo lineal por beneficiario. 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 opcional gestionado por plataforma para un par (PlatformConfig, GlobalConfig). Se verifica solo cuando la plataforma habilita la restricción.
PlatformCurveRule	Programa LaunchLab	Regla de parámetros de lanzamiento opcional gestionada por plataforma 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 nuevo lanzamiento. 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 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 método raydium.launchpad.getLaunchById del SDK devuelve PoolState más una bandera indicando si el lanzamiento se ha graduado; si es así, se incluye el ID del pool posterior a la migración.

​

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 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
}

Valores de PoolStatus (del IDL de Anchor):

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

Campos orientados al integrador:

• status — tres valores, monótonos (Funding → Migrate → Migrated). Las lecturas siempre son seguras; las escrituras están controladas.
• 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.
• La mint_authority en cada mint base de lanzamiento (pre-graduación).
• El firmante en el CPI de graduación CPMM, y en la graduación AMM v4 heredada para estado existente.
• El firmante en transferencias ClaimVestedToken fuera del vault base.
• La transfer_fee_config_authority en la TransferFeeConfig de un mint base Token-2022, para toda la fase pre-graduación — y su withdraw_withheld_authority también, pero solo cuando la plataforma dejó PlatformConfig.transfer_fee_extension_auth sin establecer.

La mint_authority se revoca inmediatamente después de una llamada MigrateToCpswap o MigrateToAmm heredada, por lo que el suministro se fija permanentemente.

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 se pre-acuña, 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). Las tres rutas de inicialización requieren graduación CPMM.

Cuando InitializeWithToken2022 adjunta una 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 la 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 las otras 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. La 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 pre-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 cuentas del ciclo de vida

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 MigrateToAmm heredado)	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

​

A 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 PDA (AUTH_SEED, CREATOR_FEE_VAULT_AUTH_SEED, PLATFORM_FEE_VAULT_AUTH_SEED).
• Módulo launchpad del SDK de Raydium v2.