Instructions LaunchLab

Initialize, Buy, Sell, Graduate, CollectFees, SetParams — formes des arguments, listes de comptes, et pré/postconditions pour chaque instruction LaunchLab.

Cette page est traduite automatiquement par IA. La version anglaise fait foi.

Voir la version anglaise →

LaunchLab expose un ensemble d’instructions compact : six appels accessibles aux utilisateurs plus quelques primitives d’administration. Le SDK les encapsule tous ; cette page documente la surface brute pour les agrégateurs, les outils de monitoring et les programmes qui ont besoin de CPI.

​

Inventaire des instructions

Groupe	Instruction	Appelable par
Configuration globale	CreateConfig / UpdateConfig	Admin du programme ; l’autorité de création de config déléguée peut aussi appeler CreateConfig
Cycle de vie du lancement	Initialize / InitializeV2	N’importe qui (créateur) — mint de base SPL Token ; V2 enregistre amm_creator_fee_on pour la graduation CPMM éventuelle. Seul V2 accepte un mint de quote Token-2022.
Cycle de vie du lancement	InitializeWithToken2022	N’importe qui (créateur) — mint de base Token-2022, TransferFeeConfig optionnel ; accepte l’un ou l’autre programme de token de quote
Échange	BuyExactIn / BuyExactOut	N’importe qui — achat à entrée/sortie exacte sur la courbe de liaison
Échange	SellExactIn / SellExactOut	N’importe qui — vente à entrée/sortie exacte sur la courbe de liaison
Graduation	MigrateToAmm	Portefeuille de migration — graduation AMM v4 héritée pour les pools initialisés avant l’application de la création CPMM uniquement.
Graduation	MigrateToCpswap	Portefeuille de migration — diplôme en CPMM. Tous les lancements nouvellement initialisés utilisent ce chemin. Encapsule InitializeWithPermission sur CPMM.
Frais	CollectFee	Admin — récupérer les frais de protocole d’un lancement
Frais	CollectMigrateFee	Admin — récupérer les frais de migration accumulés
Frais	ClaimCreatorFee	Créateur — réclamer les frais de créateur accumulés pendant la phase de courbe
Vesting	CreateVestingAccount	Créateur — allouer des tokens verrouillés à un bénéficiaire, déverrouillés après la graduation
Vesting	CreatePlatformVestingAccount	Admin de plateforme — allouer des tokens verrouillés aux bénéficiaires côté plateforme
Vesting	ClaimVestedToken	Bénéficiaire — réclamer les tokens déverrouillés après la falaise
Configuration de plateforme	CreatePlatformConfig / UpdatePlatformConfig	Admin de plateforme
Configuration de plateforme	CreatePlatformCurveRule / UpdatePlatformCurveRule / RemovePlatformCurveRule / ClosePlatformCurveRule	PlatformConfig.curve_rule_manager ou l’admin de plateforme — gérer la règle de paramètre de lancement d’une GlobalConfig
Frais de plateforme	ClaimPlatformFee / ClaimPlatformFeeFromVault	Admin de plateforme
Accès à la plateforme	CreatePlatformAllowConfig / ClosePlatformAllowConfig	Admin de plateforme — maintenir la liste d’autorisation GlobalConfig utilisée quand cette plateforme active la restriction

La division « ExactIn/ExactOut » reflète celle de CPMM SwapBaseInput / SwapBaseOutput — sur la chaîne, ce sont des discriminateurs d’instruction distincts avec un arrondi légèrement différent.

Sélection du chemin de graduation. Chaque nouvel appel Initialize, InitializeV2 et InitializeWithToken2022 doit définir migrate_type = 1 (CPSWAP). Toute tentative d’initialiser un nouveau pool lié à AMM v4 retourne MigrateTypeNotMatch. amm_creator_fee_on sélectionne uniquement si les frais de créateur CPMM résultants s’appliquent au token de quote ou aux deux tokens ; il ne sélectionne pas le programme cible.

MigrateToAmm reste appelable pour un PoolState existant qui a été initialisé avec migrate_type = 0 avant cette restriction. La version ne réécrit pas l’état du pool existant ni ne supprime l’instruction héritée.

Programme de token côté quote. Le mint de quote peut être détenu par le programme SPL Token ou Token-2022. Chaque instruction qui le touche — CreateConfig, InitializeV2, InitializeWithToken2022, les quatre instructions d’échange, CollectFee, CollectMigrateFee, ClaimCreatorFee, ClaimPlatformFee et ClaimPlatformFeeFromVault — prend le programme propriétaire dans son emplacement de compte de programme de quote. Les positions de compte n’ont pas changé ; seule la valeur acceptée a changé. Passez le programme qui possède réellement GlobalConfig.quote_mint, que vous pouvez lire à partir du bit1 de PoolState.token_program_flag pour un lancement existant (voir accounts) ou à partir du propriétaire du compte mint sinon.

Le Initialize déprécié est l’exception : son compte de programme de quote est toujours typé en SPL Token, donc une config dont le mint de quote est Token-2022 doit être lancée via InitializeV2 ou InitializeWithToken2022.

MigrateToCpswap est l’autre exception, dans la direction opposée — il prend les deux programmes sans condition plutôt qu’un par mint. Voir les comptes de migration ci-dessous.

​

Initialize

Créer un nouveau lancement.

Arguments

launch_params: {
    curve_type:                 u8,
    base_supply_max:            u64,
    base_supply_graduation:     u64,
    k:                          u128,              // ou initial_virtual_quote_reserve pour curve_type=1
    open_time:                  u64,
    quote_mint:                 Pubkey,
    base_token_metadata: {                         // nom/symbole/uri en ligne ; le programme CPI vers Metaplex
        name:   String,
        symbol: String,
        uri:    String,
    },
    fees: {
        buy_numerator:   u64,
        buy_denominator: u64,
        sell_numerator:  u64,
        sell_denominator: u64,
        lp_share:        u64,
        creator_share:   u64,
        protocol_share:  u64,
        total_share:     u64,
    },
    post_graduation_lp_policy:  u8,                // 0 = Burn, 1 = Lock, 2 = ToCreator
}

Comptes (abrégé)

#	Nom	W	S	Notes
1	creator	W	S	Paie le loyer + création du mint de base.
2	launch_config			Liaison de configuration du protocole.
3	launch_state	W		Nouveau compte.
4	launch_authority			PDA.
5	base_mint	W	S	Keypair frais (ou PDA) — cette instruction l’initialise.
6	base_vault	W		ATA de launch_authority sur base_mint.
7	quote_mint
8	quote_vault	W		ATA de launch_authority sur quote_mint.
9	metadata	W		PDA de métadonnées Metaplex.
10	metaplex_program
11	token_program			SPL Token pour le mint de base. InitializeV2 et InitializeWithToken2022 prennent un compte de programme de quote séparé qui peut être l’un ou l’autre programme.
12	system_program
13	rent

Préconditions

• quote_mint ∈ launch_config.allowed_quote_mints.
• base_supply_graduation ≤ base_supply_max.
• Les paramètres de frais passent les vérifications launch_config.max_*_fee_rate.
• open_time ≥ now − slop (le SDK applique ≥ now ; le programme tolère un léger antidatage).
• curve_type est reconnu.

Postconditions

• base_mint a supply = base_supply_max, tout dans base_vault.
• base_mint.mint_authority = launch_authority, freeze_authority = None.
• LaunchState initialisé avec status = Active, base_sold = 0, quote_reserve_real = 0.
• quote_reserve_target calculé à partir des paramètres de courbe + base_supply_graduation + buy_numerator (approximativement).
• Pour InitializeWithToken2022 avec un TransferFeeConfig attaché : transfer_fee_config_authority = launch_authority, et withdraw_withheld_authority = PlatformConfig.transfer_fee_extension_auth quand ce champ est défini, sinon launch_authority. Le côté retrait est écrit à la création du mint précisément pour que la plateforme puisse récupérer les frais retenus avant la graduation. Voir platform-config.

Erreurs courantes — InvalidQuoteMint, FeeRateTooHigh, InvalidCurveParams, MathOverflow.

​

Buy (variante canonique : BuyExactIn)

L’utilisateur fournit un quote_in fixe ; la courbe calcule base_out.

Arguments

quote_in:          u64
minimum_base_out:  u64

Comptes

#	Nom	W	S
1	user	W	S
2	launch_state	W
3	launch_authority
4	base_vault	W
5	quote_vault	W
6	user_base_ata	W
7	user_quote_ata	W
8	base_mint
9	quote_mint
10	token_program
11	associated_token_program
12	system_program

Préconditions

• launch_state.status == Active.
• now ≥ open_time.
• user_quote_ata.balance ≥ quote_in.
• quote_in > 0.

Effet

1. Diviser quote_in en quote_in_after_fee et les parties de frais.
2. Résoudre par Newton la courbe pour base_out étant donné le quote post-frais.
3. require(base_out ≥ minimum_base_out) sinon revenir ExceededSlippage.
4. Déplacer quote_in utilisateur → coffre. Déplacer base_out coffre → utilisateur.
5. Mettre à jour base_sold += base_out, quote_reserve_real += quote_in_after_fee × (lp_share / total_share).
6. Mettre à jour les compteurs de frais (protocol_fees_quote, creator_fees_quote).
7. state_data.num_buys += 1.
8. Si quote_reserve_real ≥ quote_reserve_target après la mise à jour, le SDK enchaîne généralement une instruction Graduate dans la même transaction. Le programme ne diplôme pas automatiquement à l’intérieur de Buy — un Graduate ultérieur est requis.

​

BuyExactOut

L’utilisateur spécifie le base_out exact ; le programme calcule quote_in.

Arguments

base_out:      u64
maximum_quote_in: u64

Mêmes comptes que BuyExactIn. Utilise l’intégrale quadratique de forme fermée (ou l’inverse CPMM, pour curve_type 1) plutôt que l’itération de Newton.

​

Sell / SellExactIn / SellExactOut

Miroir de Buy. L’utilisateur retourne base_in à la courbe et reçoit quote_out. Les frais sont déduits de quote_out, donc l’utilisateur reçoit moins que le produit intégré brut.

Préconditions —

• user_base_ata.balance ≥ base_in.
• La vente ne peut pas pousser base_sold en dessous de 0 (redondant avec ce qui précède étant donné que la comptabilité est cohérente).
• Le lancement est Active.

Effet — symétrique à Buy. base_sold diminue, quote_reserve_real diminue. Les frais s’accumulent toujours.

​

Frais de transfert côté quote

Quand le mint de quote porte un TransferFeeConfig, le montant que le coffre déplace et le montant que le payeur est débité ou crédité diffèrent, et la limite de slippage est vérifiée contre le côté du payeur. Sur un mint de quote sans l’extension, chaque cas ci-dessous est identique à un mint hérité simple.

Instruction	Argument	Vérifié contre
BuyExactIn	amount_in	La courbe est tarifée sur amount_in − transfer_fee(amount_in) — ce qui atteint le coffre. Un remplissage complet débite exactement amount_in ; un remplissage partiel débite le montant du coffre consommé plus son frais inverse.
BuyExactOut	maximum_amount_in	Le montant du coffre plus le frais de transfert inverse — le débit réel.
SellExactIn	minimum_amount_out	Ce que le vendeur garde après que le mint retienne ses frais, pas le montant brut quittant le coffre.
SellExactOut	amount_out	Livré exactement. La courbe cible amount_out plus le frais de transfert inverse.

Deux conséquences pour les devis :

• Une limite calculée comme si le mint était sans frais est rejetée. Passer le coût sans frais comme maximum_amount_in, ou le produit sans frais comme minimum_amount_out, revient avec ExceededSlippage.
• real_quote n’avance que par ce qui a atteint le coffre. Un BuyExactIn de amount_in sur un mint de quote à 5% déplace real_quote de amount_in × 0.95.

Un mint de quote à 100% de frais (10000 points de base) ne peut pas être inversé et revient avec CalculateOverflow sur les chemins exact-out.

Les deux mints côté échange sont également limités au programme passé dans leur emplacement correspondant, donc un base_token_program mal assorti échoue maintenant plutôt que d’être ignoré. Voir algorithms/token-2022-transfer-fees pour les mathématiques de frais sous-jacentes.

​

MigrateToAmm / MigrateToCpswap

Diplômer un lancement dans un pool tradable une fois que la courbe a atteint total_quote_fund_raising. Les nouveaux lancements sont CPMM uniquement. MigrateToAmm est conservé pour les pools existants dont le migrate_type stocké est 0.

Qui signe

• MigrateToAmm — le migrate_to_amm_wallet enregistré sur la GlobalConfig de liaison.
• MigrateToCpswap — le migrate_to_cpswap_wallet enregistré sur la GlobalConfig de liaison.

Ces portefeuilles sont généralement détenus par la manivelle de graduation opérée par Raydium ; en pratique, la graduation se produit quelques secondes après le franchissement du seuil, quel que soit celui qui a déclenché l’achat final.

Arguments

MigrateToAmm prend trois (principalement des paramètres de marché OpenBook que le programme transmet à AMM v4) :

base_lot_size:               u64
quote_lot_size:              u64
market_vault_signer_nonce:   u8

MigrateToCpswap n’en prend aucun.

Effet (commun aux deux)

1. Vérifier pool_state.status == Migrate (c.-à-d., quote_reserve_target a été atteint). Sinon revenir avec PoolMigrated (le statut était déjà Migrated) ou PoolFunding (toujours en financement).
2. Vérifier que pool_state.migrate_type correspond à l’instruction (0 pour AMM, 1 pour CPMM). Sinon revenir avec MigrateTypeNotMatch.
3. Calculer les réserves post-graduation :
   • base_amount_out = base_vault.amount − vesting_schedule.total_locked_amount
   • quote_amount_out = quote_vault.amount − quote_protocol_fee − migrate_fee − platform_fee
4. CPI dans le programme cible (AMM v4 Initialize2 ou CPMM InitializeWithPermission) avec ces réserves pour créer le pool post-graduation.
5. Pour les migrations CPMM exécutées après la mise à niveau du 2026-08-17, combinez platform_scale + creator_scale en une part LP verrouillée détenue par la plateforme et frappez au maximum une clé de frais NFT vers platform_nft_wallet. Brûlez le reste burn_scale. Avant la mise à niveau, creator_scale était verrouillé séparément et sa clé de frais allait au créateur de token. Les migrations historiques complétées ne sont pas modifiées. Pour la graduation AMM v4 héritée, la disposition LP suit le flux existant de cette instruction.
6. Révoquer base_mint.mint_authority (défini à None).
7. Basculer pool_state.status = Migrated, définir vesting_schedule.start_time = block_time + cliff_period.

Transfert d’autorité d’extension de frais Token-2022 — quand le mint de base est un mint Token-2022 portant TransferFeeConfig et PlatformConfig.transfer_fee_extension_auth est non-défaut, la migration réassigne également les autorités de cette extension à la clé de plateforme :

• transfer_fee_config_authority est toujours réassigné. Le PDA authority du lancement le détient pendant toute la phase pré-graduation, donc il y a toujours quelque chose à déplacer.
• WithheldWithdraw est réassigné uniquement quand le PDA authority le détient toujours. Les lancements créés à partir du 2026-08-27 portent déjà transfer_fee_extension_auth sur cette autorité à partir de la création du mint, donc l’étape est ignorée. La garde est ce qui empêche la migration de revenir sur ces mints — le PDA ne peut pas renoncer à une autorité qu’il ne détient plus.

Si transfer_fee_extension_auth est Pubkey::default() au moment de la migration, aucune autorité ne se déplace et les deux restent avec le PDA authority de façon permanente. Voir platform-config.

Postconditions — BuyExactIn, BuyExactOut, SellExactIn, SellExactOut rejetteront à partir de ce moment avec PoolMigrated. Le pool AMM résultant est canonique et se négocie comme n’importe quel autre pool AMM v4 / CPMM.

Erreurs courantes — PoolFunding, PoolMigrated, MigrateTypeNotMatch, InvalidCpSwapConfig, MathOverflow.

​

Comptes restants de migration CPMM

Les clients construisant MigrateToCpswap doivent utiliser ces indices remaining_accounts fixes :

Index	Compte
0–4	Propriétaire de la clé de frais de plateforme, mint, compte de token, PDA de liquidité verrouillée et compte de métadonnées
5	Créateur de lancement original ; utilisé quand platform_cp_creator n’est pas défini
6	PDA de permission CPMM dérivé de [b"permission", launch_authority]
7	platform_cp_creator configuré ; utilisé quand le champ est non-défaut
8	PDA de support-mint CPMM pour mint0 trié, dérivé de [b"support_mint", mint0]
9	PDA de support-mint CPMM pour mint1 trié, dérivé de [b"support_mint", mint1]

L’instruction nécessite au moins dix comptes restants sur le chemin mis à niveau. Les comptes de support-mint sont des entrées CPI en lecture seule. Dérivez les deux adresses même quand le mint n’a pas d’enregistrement de support initialisé. Les anciens constructeurs qui ajoutent toujours des comptes de verrouillage de créateur ou omettent les indices 8–9 doivent être mis à jour.

​

Programmes de token de migration CPMM

MigrateToCpswap prend les deux programmes de token sans condition et détermine lui-même quel programme possède chaque mint. Ses deux comptes de programme de token ont été renommés en conséquence :

Position	Compte	Valeur
premier	token_program	Toujours le programme SPL Token hérité
deuxième	token_program_2022	Toujours le programme Token-2022

Ils remplacent l’ancien base_token_program (quel que soit le programme qui possédait le mint de base) et quote_token_program (toujours hérité). Les positions sont inchangées, donc c’est un changement de valeur plutôt qu’un changement de disposition — mais les deux valeurs sont proches d’être inversées, et un constructeur qui continue de passer son ancienne paire fournira Token-2022 où le programme hérité est requis dès que l’un des mints est un mint Token-2022.

Le programme hérité est requis même quand aucun mint ne l’utilise, car le mint LP CPMM et la clé de frais NFT de liquidité verrouillée vivent toujours sur lui.

​

Liste d’autorisation GlobalConfig de plateforme

PlatformConfig.restrict_global_config contrôle la vérification :

• 0 : la plateforme accepte n’importe quel GlobalConfig valide par ailleurs ; aucun compte d’autorisation n’est requis.
• 1 : Initialize, InitializeV2 et InitializeWithToken2022 doivent inclure le PlatformAllowConfig correspondant n’importe où dans remaining_accounts.

L’admin de plateforme crée ou ferme le PDA avec CreatePlatformAllowConfig et ClosePlatformAllowConfig. Ses graines sont [b"platform_allow_config", platform_config, global_config]. Les anciennes instructions PlatformGlobalAccess gérées par l’admin et le PDA sont retirés.

​

Règles de paramètres de lancement de plateforme

Quatre instructions gèrent un compte PlatformCurveRule. Les quatre sont signées par PlatformConfig.curve_rule_manager ou par l’admin de plateforme — le programme accepte l’admin en re-dérivant le PDA PlatformConfig à partir du signataire, donc aucun compte séparé ne le prouve. Un signataire qui n’est ni l’un ni l’autre retourne InvalidCurveRuleAuthority.

Instruction	Comptes	Arguments
CreatePlatformCurveRule	curve_rule_authority (signataire, mut), platform_config, global_config, platform_curve_rule (mut), system_program	aucun
UpdatePlatformCurveRule	les mêmes cinq	group_id: u16, constraints: Vec<ParamConstraint>
RemovePlatformCurveRule	les mêmes cinq	group_id: u16
ClosePlatformCurveRule	les quatre premiers	aucun

platform_curve_rule est le PDA à [b"platform_curve_rule", platform_config, global_config].

• Create alloue le compte ne contenant aucun groupe. Cet état ne restreint rien.
• Update upsert le groupe avec ce group_id, le remplaçant entièrement s’il existe. Il redimensionne le compte pour l’adapter, donc le signataire complète le loyer qu’il augmente et reçoit le loyer qu’il diminue. Un nouveau groupe au-delà du dixième retourne CurveRuleGroupsExceeded ; plus de 25 contraintes, un champ inconnu ou un opérateur, ou la même paire (field, op) deux fois dans un groupe retourne InvalidCurveRuleConstraint ; les quatre champs dérivés de TotalSellA sur une config non-produit constant retournent CurveRuleFieldNotSupportedByCurve.
• Remove supprime un groupe par id, rétrécissant le compte et remboursant la différence. Un id inconnu retourne CurveRuleGroupNotExist.
• Close retourne le loyer entier au signataire. La config est alors à nouveau sans restriction même si restrict_curve_param reste 1.

Aucun des quatre ne change si les règles sont appliquées. C’est UpdatePlatformConfig::RestrictCurveParam(0 | 1), que seul l’admin de plateforme peut appeler.

Sur le chemin de lancement. Tandis que restrict_curve_param est 1, InitializeV2 et InitializeWithToken2022 nécessitent le PDA de règle dans remaining_accounts — y compris quand il n’existe pas, pour que l’omission ne puisse pas contourner la vérification. Un compte manquant est NotEnoughRemainingAccounts ; un lancement qui ne satisfait aucun groupe est CurveParamNotMatchPlatformRule. La vérification s’exécute avant les propres limites de GlobalConfig et ne peut que les réduire. Modèle et playbooks : products/launchlab/curve-rules. Les deux erreurs sont évitables côté client — le SDK reflète cette vérification comme une fonction pure, voir Vérifier avant d’envoyer.

​

CollectFee

Récupération admin des frais commerciaux accumulés du protocole sur un seul lancement.

Arguments — aucun.

Comptes

#	Nom	W	S	Notes
1	protocol_fee_owner		S	Doit égaler global_config.protocol_fee_owner.
2	authority			PDA [b"vault_auth_seed"] ; signe le transfert du coffre.
3	pool_state	W		Muté pour mettre à zéro quote_protocol_fee.
4	global_config			Source de vérité pour le signataire.
5	quote_vault	W		Drainé par quote_protocol_fee.
6	recipient_token_account	W		ATA de protocol_fee_owner sur quote_mint.
7	quote_mint
8	token_program			Le programme qui possède le mint de quote — SPL Token ou Token-2022.

Effet — transférer pool_state.quote_protocol_fee de quote_vault à recipient_token_account, puis mettre le compteur à zéro. Appelable n’importe quand après le premier achat.

​

CollectMigrateFee

Récupération admin des frais de migration accumulés à la graduation. Même forme de compte que CollectFee avec migrate_fee_owner comme signataire (au lieu de protocol_fee_owner) et pool_state.migrate_fee comme compteur drainé.

​

ClaimCreatorFee

Récupération par créateur des frais de créateur accumulés sur chaque lancement que le créateur possède qui utilise le même mint de quote. Draine le coffre de frais par créateur, pas celui par pool.

Arguments — aucun.

Comptes

#	Nom	W	S	Notes
1	creator	W	S	Le créateur du pool.
2	fee_vault_authority			PDA [b"creator_fee_vault_auth_seed"].
3	creator_fee_vault	W		PDA aux graines [creator, quote_mint] ; le coffre de créateur agrégé.
4	recipient_token_account	W		init_if_needed ; ATA de creator sur quote_mint.
5	quote_mint
6	token_program
7	system_program			Pour la création d’ATA si nécessaire.
8	associated_token_program

Effet — transférer le solde entier de creator_fee_vault à recipient_token_account. Revient avec une vérification require-greater-than-zero si le coffre est vide.

​

ClaimPlatformFee

Récupération par plateforme qui draine directement le coffre de quote d’un lancement. Utilisez ceci quand une plateforme veut réclamer sa part pour un lancement spécifique sans passer par le coffre de plateforme agrégé.

Arguments — aucun.

Comptes

#	Nom	W	S	Notes
1	platform_fee_wallet	W	S	Doit égaler platform_config.platform_fee_wallet.
2	authority			PDA [b"vault_auth_seed"].
3	pool_state	W		Drainé par pool_state.platform_fee.
4	platform_config			Source de vérité pour le signataire.
5	quote_vault	W		Drainé.
6	recipient_token_account	W		init_if_needed ; ATA de platform_fee_wallet.
7	quote_mint
8	token_program
9	system_program
10	associated_token_program

Effet — transférer pool_state.platform_fee de quote_vault à recipient_token_account, mettre le compteur à zéro.

​

ClaimPlatformFeeFromVault

Récupération agrégée par plateforme. Draine le coffre de frais par mint de quote de la plateforme qui accumule les frais de chaque lancement acheminé via la plateforme.

Arguments — aucun.

Comptes

#	Nom	W	S	Notes
1	platform_fee_wallet	W	S	Doit égaler platform_config.platform_fee_wallet.
2	fee_vault_authority			PDA [b"platform_fee_vault_auth_seed"].
3	platform_config
4	platform_fee_vault	W		PDA aux graines [platform_config, quote_mint].
5	recipient_token_account	W		init_if_needed ; ATA de platform_fee_wallet.
6	quote_mint
7	token_program
8	system_program
9	associated_token_program

Effet — transférer le solde complet de platform_fee_vault à recipient_token_account. Revient si le coffre est vide.

​

Instructions de vesting et de configuration de plateforme

Celles-ci sont documentées sur des pages dédiées car chacune a son propre modèle d’état :

• CreateVestingAccount, CreatePlatformVestingAccount, ClaimVestedToken
• CreatePlatformConfig, UpdatePlatformConfig, CreatePlatformAllowConfig, ClosePlatformAllowConfig
• CreatePlatformCurveRule, UpdatePlatformCurveRule, RemovePlatformCurveRule, ClosePlatformCurveRule
• CreateConfig, UpdateConfig

​

Matrice de changement d’état

Instruction	status	real_base	real_quote	Compteurs de frais	Pool post-état
Initialize{V2,WithToken2022}	Funding	0	0	0	—
BuyExactIn(q_in)	Funding	+∆	+∆q_after_fee	quote_protocol_fee += ∆, platform_fee += ∆	—
SellExactIn(b_in)	Funding	−∆	−∆q_before_fee	(même)	—
Seuil atteint	→ Migrate	—	—	—	—
MigrateToCpswap / MigrateToAmm hérité	→ Migrated	(gelé)	(gelé)	migrate_fee défini	créé ; LP CPMM divisé en verrouillage de plateforme et brûlure
CollectFee / CollectMigrateFee	n’importe quel	—	—	compteur mis à zéro	—
ClaimCreatorFee / ClaimPlatformFee*	n’importe quel	—	—	draine le coffre	—
CreateVestingAccount	Funding	—	—	—	augmente allocated_share_amount
ClaimVestedToken	Migrated	—	—	—	draine base_vault

​

Où aller ensuite

• products/launchlab/code-demos — exemples TypeScript pour chaque instruction.
• products/launchlab/accounts — forme d’état complète.
• reference/error-codes — énumération d’erreur LaunchLab.

Sources :

• Module Raydium SDK v2 LaunchLab
• Source du programme Raydium LaunchLab