Saltar al contenido principal

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.

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 →
PlatformConfig es la superposición a nivel de plataforma que se sitúa encima de GlobalConfig. Mientras que GlobalConfig define las reglas a nivel de protocolo («la comisión comercial es del 1%, el suministro debe ser al menos 10M, solo esta billetera puede graduarse»), PlatformConfig es lo que cada plataforma de lanzamiento — pump.fun, la propia interfaz de Raydium, launchpads de terceros — utiliza para agregar su comisión, reclamar su porción del LP post-graduación, restringir qué formas de curva pueden elegir sus lanzamientos y mostrar su marca (nombre, sitio web, imagen) en cadena.

​
Qué es

Una cuenta PlatformConfig gestiona cuatro aspectos transversales para una plataforma:
  1. Marca — nombre, sitio web, enlace de imagen, todo almacenado inline para que cualquier explorador o agregador pueda mostrar la plataforma que lanzó un token.
  2. Comisión de plataforma — una comisión comercial adicional (fee_rate) además de trade_fee_rate del protocolo. Se acumula en la platform_fee_wallet de la plataforma. Limitada a 100 bps por GlobalConfig.max_share_fee_rate.
  3. Reparto de migración de NFT — tres números enteros (platform_scale, creator_scale, burn_scale) que suman RATE_DENOMINATOR_VALUE = 1_000_000 y dividen el LP post-graduación en una parte acuñada en la billetera NFT de la plataforma, una parte en la billetera NFT del creador y una parte quemada (Burn & Earn). Solo tiene sentido cuando la graduación apunta a CPMM (migrate_type = 1).
  4. Lista blanca de parámetros de curva — un Vec<PlatformCurveParam> que lista exactamente qué combinaciones de (supply, total_base_sell, total_quote_fund_raising, migrate_type, migrate_cpmm_fee_on, vesting_params...) están permitidas en esta plataforma. Si el vector está vacío o todas las entradas son inválidas, cualquier combinación está permitida; de lo contrario, los lanzamientos deben coincidir exactamente con una de las entradas.
Derivación de PDA: 
const [platformConfigPda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("platform_config"),
    platformAdmin.toBuffer(),       // platform's owning pubkey
  ],
  LAUNCHLAB_PROGRAM_ID,
);
(Consulta create_platform_config en el código fuente para la lista de semillas canónica).

​
Estructura

// states/platform_config.rs
pub const PLATFORM_CONFIG_SEED: &str = "platform_config";
pub const NAME_SIZE: usize = 64;
pub const WEB_SIZE:  usize = 256;
pub const IMG_SIZE:  usize = 256;
pub const MAX_CREATOR_FEE_RATE: u64 = 5000;       // 50 bps (denominator 1_000_000)
pub const MAX_TRANSFER_FEE_RATE: u16 = 500;       // 5%   (denominator 10_000)
pub const MAX_CURVE_PARAMS: usize = 10;

#[account]
pub struct PlatformConfig {
    pub epoch:                       u64,
    pub platform_fee_wallet:         Pubkey,            // signs ClaimPlatformFee
    pub platform_nft_wallet:         Pubkey,            // receives the platform NFT slice at CPMM graduation
    pub platform_scale:              u64,               // share of LP minted to platform NFT
    pub creator_scale:               u64,               // share of LP minted to creator NFT
    pub burn_scale:                  u64,               // share of LP burned via Burn & Earn
    pub fee_rate:                    u64,               // platform's trade fee (1/1_000_000)
    pub name:                        [u8; 64],          // utf-8 padded with zeros
    pub web:                         [u8; 256],
    pub img:                         [u8; 256],
    pub cpswap_config:               Pubkey,            // CPMM AmmConfig that the post-grad pool will bind to
    pub creator_fee_rate:            u64,               // creator-side fee taken pre-graduation
    pub transfer_fee_extension_auth: Pubkey,            // for Token-2022 launches: who inherits transfer-fee authorities post-graduation
    pub platform_vesting_wallet:     Pubkey,
    pub platform_vesting_scale:      u64,               // platform's slice of total_locked_amount
    pub platform_cp_creator:         Pubkey,            // optional creator-of-record on the post-graduation CPMM pool
    pub padding:                     [u8; 108],
    pub curve_params:                Vec<PlatformCurveParam>, // whitelist of permitted curve shapes
}
platform_scale + creator_scale + burn_scale debe ser igual a 1_000_000 (validado por MigrateNftInfo::check). Repartos comunes vistos en producción:
  • (0, 100_000, 900_000) — 90% LP quemado, 10% al creador. Lanzamiento justo estilo pump estándar.
  • (50_000, 100_000, 850_000) — pequeña porción de plataforma (5%), 10% creador, 85% quemado.
  • (0, 0, 1_000_000) — quemado completo, sin acuñaciones de NFT. Lanzamientos «sin informados» estrictos.

​
Campos de marca

name, web e img son matrices de bytes inline rellenadas con ceros hasta sus constantes de tamaño. Para leerlas como cadenas, corta hasta el primer \0: 
function readString(bytes: Uint8Array): string {
  const end = bytes.indexOf(0);
  return Buffer.from(end === -1 ? bytes : bytes.subarray(0, end)).toString("utf-8");
}
Las constantes son deliberadamente generosas (name: 64, web: 256, img: 256) para que las plataformas puedan incluir suficientes metadatos para exploradores y agregadores sin recurrir a almacenamiento fuera de cadena. Cualquier cosa que exceda estos tamaños revierte en CreatePlatformConfig con InvalidInput.

​
Mecánica de comisiones

Un swap en una curva vinculada a un PlatformConfig cobra tres comisiones en capas: 
trade_fee     = amount_in × global_config.trade_fee_rate    / 1_000_000
platform_fee  = amount_in × platform_config.fee_rate        / 1_000_000
creator_fee   = amount_in × platform_config.creator_fee_rate / 1_000_000

amount_after_fee = amount_in − trade_fee − platform_fee − creator_fee
  • trade_fee se acumula en protocol_fee_owner del protocolo (se reclama a través de CollectFee).
  • platform_fee se acumula en una bóveda por plataforma (se reclama a través de ClaimPlatformFee o ClaimPlatformFeeFromVault; consulta instructions).
  • creator_fee se acumula en una bóveda por creador clave por la clave pública del creador + mint de quote (se reclama a través de ClaimCreatorFee).
creator_fee_rate está limitado por MAX_CREATOR_FEE_RATE = 5000 (50 bps). fee_rate (la comisión de plataforma) está limitado a 10000 (100 bps) por GlobalConfig.max_share_fee_rate.

​
Reparto de migración de NFT (solo CPMM)

Cuando un lanzamiento se gradúa a CPMM (migrate_type = 1, firmado por migrate_to_cpswap_wallet), la instrucción de migración divide los tokens LP acuñados por CPMM::InitializeWithPermission en tres partes: 
lp_to_platform = lp_total × platform_scale / 1_000_000   → platform_nft_wallet
lp_to_creator  = lp_total × creator_scale  / 1_000_000   → creator NFT (Fee Key)
lp_to_burn     = lp_total × burn_scale     / 1_000_000   → Burn & Earn lock program
Las porciones de plataforma y creador se envuelven como NFT por el programa LP-Lock (LockrWmn6K5twhz3y9w1dQERbmgSaRkfnTeTKbpofwE) — el tenedor del NFT tiene derecho a reclamar comisiones CPMM acumuladas indefinidamente sin poder retirar la liquidez subyacente. Consulta products/launchlab/creator-fees para el flujo de Fee Key post-graduación. La porción quemada se envía al programa Lock con is_burn = true para que los tokens LP sean permanentemente inaccesibles — aseguran el piso de precio del pool sin jamás devolver comisiones a nadie. Cuando migrate_type = 0 (graduarse a AMM v4), los campos de reparto de NFT se ignoran y todo el LP se bloquea / quema según un flujo separado del lado de AMM v4.

​
Lista blanca de parámetros de curva

curve_params: Vec<PlatformCurveParam> es el mecanismo de la plataforma para restringir qué formas de curva pueden elegir sus lanzamientos. Si el vector es no vacío y al menos una entrada es válida, el programa requiere en Initialize que los parámetros del lanzamiento coincidan exactamente con al menos una entrada. 
#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct PlatformCurveParam {
    pub epoch:                u64,
    pub index:                u8,           // ordinal within this platform's whitelist
    pub global_config:        Pubkey,       // which GlobalConfig this entry applies to
    pub bonding_curve_param:  BondingCurveParam,
    pub padding:              [u64; 50],
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct BondingCurveParam {
    pub migrate_type:               u8,    // 0 = AMM v4, 1 = CPMM. u8::MAX = wildcard
    pub migrate_cpmm_fee_on:        u8,    // 0 = quote-only, 1 = both. u8::MAX = wildcard
    pub supply:                     u64,   // 0 = wildcard
    pub total_base_sell:            u64,   // 0 = wildcard
    pub total_quote_fund_raising:   u64,   // 0 = wildcard
    pub total_locked_amount:        u64,   // u64::MAX = wildcard
    pub cliff_period:               u64,   // u64::MAX = wildcard
    pub unlock_period:              u64,   // u64::MAX = wildcard
}
Cada campo tiene un valor centinela que significa comodín (cualquier valor coincide): u64::MAX para los campos u64, u8::MAX para los campos u8, 0 para los campos de suministro / venta / recaudación. Un BondingCurveParam con todos los centinelas es «permitir cualquier cosa» — equivalente al comportamiento de lista blanca vacía. El algoritmo de coincidencia en Initialize:
  1. Filtra curve_params a entradas cuya global_config coincida con la GlobalConfig elegida del lanzamiento.
  2. Si la lista filtrada está vacía, permite cualquier parámetro (la plataforma no incluyó nada en la lista blanca para esta GlobalConfig).
  3. Si toda entrada en la lista filtrada tiene all_is_invalid() (cada campo es el comodín), permite cualquier parámetro.
  4. De lo contrario, itera entradas; para cada entrada, verifica los parámetros del lanzamiento contra cada campo no comodín. Si todos los campos no comodín coinciden, acepta y retorna.
  5. Si ninguna entrada coincidió, revierte con InvalidInput.
Esto permite a una plataforma decir «solo permitimos la forma estándar de 1B-suministro / 800M-vendido / 30k-USDC-recaudado / sin-vesting» escribiendo una única entrada con valores concretos para esos cuatro campos y comodines en otros lugares. O una plataforma más estricta podría enumerar tres o cuatro formas discretas, una por nivel de lanzamiento soportado. MAX_CURVE_PARAMS = 10 limita el tamaño de la lista blanca.

​
PlatformGlobalAccess — autorizando una plataforma

Cuando un GlobalConfig tiene requires_platform_auth = 1, cada Initialize contra él debe incluir un PDA PlatformGlobalAccess probando que la plataforma ha sido pre-autorizada: 
// states/platform_global_access.rs
pub const PLATFORM_GLOBAL_ACCESS_SEED: &str = "platform_global_access";

#[account]
pub struct PlatformGlobalAccess {
    pub bump:            u8,
    pub global_config:   Pubkey,
    pub platform_config: Pubkey,
    pub padding:         [u64; 8],
}
Semillas de PDA: [b"platform_global_access", global_config, platform_config]. El administrador del protocolo crea uno de estos por par (GlobalConfig, PlatformConfig) vía CreatePlatformGlobalAccess y lo revoca vía ClosePlatformGlobalAccess. Sin esta cuenta, un lanzamiento no puede vincularse a ese GlobalConfig desde la plataforma restringida.

​
Ruta de lectura

const platformConfig = await raydium.launchpad.getPlatformConfig(platformConfigPda);

console.log("Platform:", readString(platformConfig.name));
console.log("Fee rate:", platformConfig.feeRate, "(/1M)");
console.log("NFT split:",
  platformConfig.platformScale,
  platformConfig.creatorScale,
  platformConfig.burnScale,
);
console.log("Curve whitelist size:", platformConfig.curveParams.length);
Para una interfaz mostrando «dónde se lanzó este token», PoolState.platform_config apunta directamente al PlatformConfig originador — descárgalo una vez y cachea la marca.

​
Ruta de actualización

InstrucciónQuién firmaQué cambia
CreatePlatformConfigadministrador de plataforma (una sola vez)Inicializa la cuenta con PlatformParams.
UpdatePlatformConfigadministrador de plataformaDispatch genérico clave por param: u8; muta un campo por llamada. Los campos de marca, tasas de comisión, cartera de vesting y las diversas carteras son todos configurables a través de esto.
UpdatePlatformCurveParamadministrador de plataformaAgrega o reemplaza una entrada PlatformCurveParam por (global_config, index).
RemovePlatformCurveParamadministrador de plataformaLimpia una entrada (la establece en todos-centinela = comodín).
ClaimPlatformFeeplatform_fee_walletBarre la comisión de plataforma por pool desde PoolState.quote_vault.
ClaimPlatformFeeFromVaultplatform_fee_walletBarre la bóveda de comisión por plataforma (PDA en [platform_config, quote_mint]).
Las rotaciones de cartera (platform_fee_wallet, platform_nft_wallet, platform_vesting_wallet, platform_cp_creator, transfer_fee_extension_auth, cpswap_config) todas van a través de UpdatePlatformConfig. Lee la tabla de dispatch de update_platform_config del código fuente para los códigos param exactos.

​
Trampas comunes

  • Centinelas de lista blanca mal configurados. Un BondingCurveParam con total_locked_amount = 0 no es un comodín — coincide con lanzamientos que explícitamente optan por no usar vesting. El comodín para ese campo es u64::MAX. La misma trampa existe para cliff_period y unlock_period. Usa clear() (que el programa expone) para establecer centinelas correctamente.
  • Redondeo de reparto de NFT. Las tres escalas deben sumar exactamente 1_000_000. Los errores de uno en CreatePlatformConfig revierten; los errores de uno en tiempo de ejecución acuñarían o quemarían una unidad de LP extra, que es para lo que existe la verificación de igualdad estricta.
  • Doble asignación de vesting de plataforma. Si platform_vesting_scale > 0, la plataforma debe llamar a CreatePlatformVestingAccount una sola vez después de que termine la recaudación del lanzamiento; si lo olvida, esa porción permanece sin asignar e inactiva para siempre (el presupuesto total_locked_amount del lanzamiento se consume pero la plataforma nunca lo reclama).
  • Ambigüedad de platform_cp_creator. Cuando se establece en Pubkey::default(), el creador del lanzamiento se registra como pool_creator del pool CPMM post-graduación; cuando se establece en una clave real, esa clave se registra en su lugar. Esto afecta quién puede llamar a CPMM::CollectCreatorFee después. Decide en el momento de la creación de config de plataforma qué modelo quieres.

​
Referencias

Fuentes:
  • raydium-launch/programs/launchpad/src/states/platform_config.rs — PlatformConfig, PlatformParams, MigrateNftInfo, PlatformCurveParam, BondingCurveParam, is_valid_curve_param.
  • raydium-launch/programs/launchpad/src/states/platform_global_access.rs — PlatformGlobalAccess.
  • raydium-launch/programs/launchpad/src/lib.rs — create_platform_config, update_platform_config, update_platform_curve_param, remove_platform_curve_param, create_platform_global_access, close_platform_global_access, claim_platform_fee, claim_platform_fee_from_vault.