Instructions CPMM

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

Cette page est la référence d’instruction faisant autorité. Pour le code qui compose réellement ces instructions, consultez products/cpmm/code-demos. Pour les significations des codes d’erreur, consultez reference/error-codes.La mise à niveau du programme 2026-09 a reconstruit CPMM sur Anchor 1.0.2 / Solana 3.1.10, a ajouté l’instruction admin CollectExcessLamports, a supprimé la liste blanche de mints Token-2022 codée en dur, et a modifié ce que CreateAmmConfig écrit dans protocol_owner / fund_owner. Aucune instruction orientée utilisateur n’a changé ses comptes, arguments ou mathématiques. Consultez l’entrée du journal des modifications du 2026-09-09.La mise à niveau 2026-10-30 ajoute InitializeV2 : une création de pool sans permission où le créateur choisit d’activer ou non les frais de créateur, et de quel côté. Elle est purement additive. Initialize, InitializeWithPermission et toutes les autres instructions conservent leurs discriminateurs, comptes et arguments. Consultez l’entrée du journal des modifications du 2026-10-30.

Les deux instructions de collecte de frais créateurs ont changé leurs listes de comptes le 2026-09-19. CollectCreatorFee gagne creator_fee_share ; CollectCreatorFeePermissionless gagne amm_config et creator_fee_share. Les deux sont ajoutés après system_program, donc chaque compte qu’un client existant passe déjà conserve son index — mais les nouveaux comptes sont obligatoires, donc une transaction construite selon l’ancienne disposition se retrouve à court de comptes et est rejetée avec l’erreur AccountNotEnoughKeys (3005) d’Anchor. Deux instructions admin — CreateCreatorFeeShare et CloseCreatorFeeShare — sont ajoutées, et UpdateAmmConfig prend un nouveau param = 8. Consultez l’entrée du journal des modifications du 2026-09-19.

Résumé des instructions

Nom du discriminateur	Qui signe	Ce qu’elle fait
`Initialize`	créateur du pool	Créer un nouveau pool CPMM à partir de deux mints et d’une `AmmConfig`. Sans permission ; n’importe qui peut l’appeler. Code en dur `enable_creator_fee = false` sur le nouveau pool. Le compte `pool_state` peut être soit le PDA canonique, soit une nouvelle paire de clés aléatoire (voir les comptes Initialize).
`InitializeV2`	créateur du pool	Identique à `Initialize`, avec en plus un argument optionnel `creator_fee_on`. Sans permission. `Some(...)` stocke `enable_creator_fee = true` avec le côté choisi ; `None` stocke les mêmes paramètres de frais de créateur que `Initialize`. Mêmes comptes que `Initialize` sans le sysvar `rent` final. Ajoutée le 2026-10-30.
`InitializeWithPermission`	payeur + détenteur d’un PDA `Permission`	Variante avec permission de `Initialize`. L’appelant (`payer`) doit posséder un PDA `Permission` dérivé de sa propre clé publique. Utilisée par les plateformes qui ont besoin d’une création de pool contrôlée (par exemple, les graduations LaunchLab). Permet à l’appelant d’épingler `creator_fee_on` (`BothToken` / `OnlyToken0` / `OnlyToken1`) et force `enable_creator_fee = true` sur le nouveau pool. Le champ `creator` sur `pool_state` est défini sur un compte `creator` passé séparément, pas le payeur. Même flexibilité PDA-canonique-ou-paire-aléatoire pour `pool_state` que `Initialize`.
`Deposit`	LP	Ajouter de la liquidité dans les deux tokens ; recevoir des tokens LP.
`Withdraw`	LP	Brûler les tokens LP ; recevoir les deux tokens sous-jacents au prorata.
`SwapBaseInput`	swappeur	Swap à entrée exacte (`amount_in` en, ≥ `minimum_amount_out` en sortie).
`SwapBaseOutput`	swappeur	Swap à sortie exacte (≤ `maximum_amount_in` en, `amount_out` en sortie).
`CollectProtocolFee`	`protocol_owner` (de `AmmConfig`)	Collecter les frais de protocole accumulés des vaults.
`CollectFundFee`	`fund_owner` (de `AmmConfig`)	Collecter les frais de fonds accumulés des vaults.
`CollectCreatorFee`	`pool_creator`	Collecter les frais créateurs accumulés (si les frais créateurs étaient activés), nets de la part du protocole, qui est enregistrée dans le bucket de protocole du pool.
`CollectCreatorFeePermissionless`	n’importe quel payeur	Collecter les frais créateurs accumulés vers les comptes de tokens canoniques du `pool_creator`, nets de la même part de protocole. Le payeur peut créer les ATAs destinataires manquantes mais ne peut pas rediriger le transfert.
`UpdatePoolStatus`	`admin`	Mettre en pause / reprendre des opérations spécifiques sur un pool via un masque de bits.
`UpdateAmmConfig`	`admin`	Modifier les taux de frais ou le propriétaire du protocole/fonds sur une `AmmConfig`.
`CreateAmmConfig`	`admin`	Créer un nouveau palier de frais (nouveau compte `AmmConfig`).
`CreatePermissionPda`	`admin` ou créateur de PDA de permission délégué	Créer un PDA `Permission` qui permet à une autorité spécifique d’appeler `InitializeWithPermission`.
`ClosePermissionPda`	`admin` ou le créateur de PDA de permission dédié	Révoquer un PDA `Permission` précédemment émis. Depuis la mise à niveau 2026-09, l’autorité créatrice dédiée peut également fermer une autorisation qu’elle a émise ; c’était réservé à l’admin avant.
`CreateSupportMintAssociated`	`admin` ou le propriétaire de mint de support dédié	Enregistrer un mint Token-2022 qui échouerait autrement la liste blanche d’extensions, en créant son PDA `SupportMintAssociated`.
`CloseSupportMintAssociated`	`admin` ou le propriétaire de mint de support dédié	Supprimer l’enregistrement d’un mint.
`CollectExcessLamports`	`admin` ou le portefeuille de collecte de lamports dédié	Collecter les lamports au-dessus du minimum exempt de loyer des vaults, mints LP et PDAs contrôlés par CPMM. Ajouté 2026-09.
`CreateCreatorFeeShare`	`admin` ou le propriétaire de partage de frais créateurs dédié	Définir une part de protocole personnalisée des frais créateurs pour une paire `(creator, amm_config)`, remplaçant `AmmConfig.creator_fee_share_rate`. Ajouté 2026-09-19.
`CloseCreatorFeeShare`	`admin` ou le propriétaire de partage de frais créateurs dédié	Supprimer ce remplacement ; la paire revient à la valeur par défaut de la config. Ajouté 2026-09-19.

Masque de statut : le status de chaque pool est un u8 où le bit 0 = dépôt désactivé, bit 1 = retrait désactivé, bit 2 = swap désactivé (PoolStatusBitIndex { Deposit, Withdraw, Swap } dans le programme). Un bit clair signifie que l’opération est autorisée ; un bit défini signifie qu’elle est en pause. UpdatePoolStatus prend un u8 brut et remplace la valeur existante. Les sections suivantes détaillent chacune. L’ordre des comptes suit l’IDL CPMM ; le SDK et le client Rust dans raydium-cp-swap/programs/cp-swap/src/instructions correspondent à cet ordre.

`Initialize`

Créer un nouveau pool CPMM. Arguments

init_amount_0: u64
init_amount_1: u64
open_time:     u64   // Timestamp Unix ; les swaps sont rejetés avant cela

Comptes (W = inscriptible, S = signataire)

#	Nom	W	S	Notes
1	`creator`	W	S	Paie le loyer ; enregistré comme `pool_state.pool_creator`.
2	`amm_config`			Le palier de frais choisi.
3	`authority`			PDA d’autorité globale CPMM.
4	`pool_state`	W	S*	`init`ialisé ici. Soit le PDA canonique `["pool", amm_config, token_0_mint, token_1_mint]` soit une nouvelle paire de clés aléatoire — quand ce n’est pas le PDA canonique, le programme exige que `pool_state` signe (`require_eq!(pool_account_info.is_signer, true)`). Le chemin de paire aléatoire permet à un créateur d’éviter les tentatives de front-running sur le PDA canonique. Les PDAs en aval (`lp_mint`, `vaults`, `observation_state`) sont dérivés de `pool_state.key()` de toute façon.
5	`token_0_mint`			Triés : `token_0_mint < token_1_mint`.
6	`token_1_mint`
7	`lp_mint`	W		`init`ialisé ici. Autorité définie sur `authority`.
8	`creator_token_0`	W		ATA source pour `init_amount_0`.
9	`creator_token_1`	W		ATA source pour `init_amount_1`.
10	`creator_lp_token`	W		ATA du créateur sur `lp_mint`. `init` (pas `init_if_needed`) — il ne doit pas déjà exister, ce qui ne peut pas être le cas, puisque `lp_mint` est créé dans cette même instruction.
11	`token_0_vault`	W		`init`ialisé ici. Possédé par `authority`.
12	`token_1_vault`	W
13	`create_pool_fee`	W		ATA destinataire pour le `create_pool_fee` payé par le créateur.
14	`observation_state`	W		`init`ialisé ici.
15	`token_program`			SPL Token (pour le mint LP).
16	`token_0_program`			SPL Token ou Token-2022.
17	`token_1_program`			SPL Token ou Token-2022.
18	`associated_token_program`
19	`system_program`
20	`rent`

* pool_state signe uniquement sur le chemin de paire aléatoire ; le chemin PDA canonique s’exécute sans que pool_state signe. Conditions préalables

Les mints sont triés (token_0_mint < token_1_mint par ordre d’octets).
Aucun mint n’utilise une extension en dehors de la liste blanche CPMM (TransferFeeConfig, MetadataPointer, TokenMetadata, InterestBearingConfig, ScaledUiAmount) — voir products/cpmm/accounts. Un mint dont le PDA SupportMintAssociated (seed [b"support_mint", mint]) existe ignore la vérification d’extension — mais vous devez ajouter ce PDA à remaining_accounts. Le programme ne scanne que les comptes que vous passez et ne charge jamais le PDA lui-même, donc compter sur le registre sans fournir le compte échoue quand même avec NotSupportMint (6007). L’ordre n’a pas d’importance (la correspondance se fait par clé) ; passez une entrée par mint qui a besoin du contournement. Ce registre est le seul contournement depuis que la mise à niveau 2026-09 a supprimé la liste blanche de quatre mints codée en dur.
creator a au moins init_amount_0 et init_amount_1 dans les ATAs respectifs.
amm_config.disable_create_pool == false.

Postconditions

pool_state.lp_supply = sqrt(init_amount_0 * init_amount_1) — la racine carrée complète. Le créateur reçoit lp_supply − 100 ; les 100 unités de base verrouillées sont comptées dans lp_supply mais jamais créées.
Donc lp_mint.supply == pool_state.lp_supply − 100 pour la durée de vie du pool. Toutes les mathématiques de part LP (dépôt, retrait) divisent par lp_supply, donc utilisez ce champ et ne substituez pas l’approvisionnement du mint en chaîne. Revient avec InitLpAmountTooLess si sqrt(...) < 100.
observation_state est initialisé ; observation_index = 0 et pool_id = pool_state.key().
Les lamports create_pool_fee sont transférés du créateur au destinataire et synchronisés en SOL natif (c’est un ATA wSOL).
Le masque de statut du pool est 0 (dépôt / retrait / swap tous activés).
enable_creator_fee = false et creator_fee_on = BothToken. Initialize ne supporte pas l’activation des frais créateurs. Utilisez InitializeV2 pour les activer sans octroi de permission.
open_time est augmenté à block_timestamp + 1 si l’appelant a passé une valeur <= block_timestamp. Les swaps sont rejetés avant open_time ; les dépôts et retraits fonctionnent immédiatement.

Erreurs courantes (liste complète dans reference/error-codes)

InvalidInput — mints non triés, ou mints identiques.
NotSupportMint — extension Token-2022 bloquée.
ExceededSlippage — rarement ; si init_amount_0/1 résultent en zéro LP en raison d’une inadéquation de décimales.

`InitializeV2`

Créer un nouveau pool CPMM et choisir ses paramètres de frais de créateur. Ajoutée dans la mise à niveau 2026-10-30. InitializeV2 exécute le même flux de création que Initialize. La seule différence est ce qu’elle écrit dans enable_creator_fee et creator_fee_on sur le nouveau pool. Avant cette instruction, seule InitializeWithPermission pouvait créer un pool avec les frais de créateur activés, et ce chemin nécessite un PDA Permission émis par l’admin. Arguments

init_amount_0:  u64
init_amount_1:  u64
open_time:      u64                    // Timestamp Unix ; les swaps sont rejetés avant cela
creator_fee_on: Option<CreatorFeeOn>   // None = frais de créateur désactivés
                                       // Some(BothToken | OnlyToken0 | OnlyToken1) = frais de créateur activés

CreatorFeeOn est un enum Borsh, donc l’argument s’encode avec un octet de tag pour l’Option, plus un octet de variante quand il vaut Some :

Valeur	Octets	Stocké sur `pool_state`
`None`	`00`	`enable_creator_fee = false`, `creator_fee_on = 0` (`BothToken`)
`Some(BothToken)`	`01 00`	`enable_creator_fee = true`, `creator_fee_on = 0`
`Some(OnlyToken0)`	`01 01`	`enable_creator_fee = true`, `creator_fee_on = 1`
`Some(OnlyToken1)`	`01 02`	`enable_creator_fee = true`, `creator_fee_on = 2`

Tout autre octet échoue à la désérialisation des arguments par Anchor avant l’exécution du handler. Discriminateur : initialize_v2 → [67, 153, 175, 39, 218, 16, 38, 32]. Comptes (W = inscriptible, S = signataire) Les 19 premiers comptes sont identiques à ceux de Initialize, dans le même ordre. InitializeV2 supprime uniquement le sysvar rent final.

#	Nom	W	S	Notes
1	`creator`	W	S	Paie le loyer, les frais de création du pool et la liquidité initiale. Enregistré comme `pool_state.pool_creator`, donc les frais de créateur vont à ce signataire.
2	`amm_config`			Le palier de frais choisi. Son `creator_fee_rate` est le taux que le pool facture.
3	`authority`			PDA d’autorité globale CPMM.
4	`pool_state`	W	S*	PDA canonique ou nouvelle paire de clés aléatoire, exactement comme pour `Initialize`.
5	`token_0_mint`			Triés : `token_0_mint < token_1_mint`.
6	`token_1_mint`
7	`lp_mint`	W		`init`ialisé ici.
8	`creator_token_0`	W		Compte source pour `init_amount_0`.
9	`creator_token_1`	W		Compte source pour `init_amount_1`.
10	`creator_lp_token`	W		ATA du créateur sur `lp_mint`. `init`ialisé ici.
11	`token_0_vault`	W		`init`ialisé ici.
12	`token_1_vault`	W
13	`create_pool_fee`	W		Destination du `create_pool_fee`.
14	`observation_state`	W		`init`ialisé ici.
15	`token_program`			SPL Token (pour le mint LP).
16	`token_0_program`			SPL Token ou Token-2022.
17	`token_1_program`			SPL Token ou Token-2022.
18	`associated_token_program`
19	`system_program`

* pool_state signe uniquement sur le chemin de paire aléatoire. Les remaining_accounts fonctionnent comme pour Initialize : ajoutez le PDA SupportMintAssociated pour tout mint Token-2022 qui a besoin du contournement par le registre.

Comme les 19 premiers comptes correspondent, vous pouvez adapter un builder Initialize existant : changez le discriminateur, ajoutez les octets de creator_fee_on et supprimez rent. Si vous laissez rent, Anchor le transmet comme une entrée de remaining_accounts, et le scan support-mint l’ignore car ce n’est pas un compte détenu par CPMM. Supprimez-le quand même pour économiser l’emplacement de compte.

Conditions préalables — les mêmes que pour Initialize. Il n’y a aucune vérification de permission ni nouvelle contrainte sur creator_fee_on. Postconditions — les mêmes que pour Initialize, sauf :

enable_creator_fee et creator_fee_on sont définis à partir de l’argument, comme dans le tableau ci-dessus.
pool_creator est toujours le creator signataire. Sur InitializeWithPermission, le créateur est un compte séparé, non signataire ; sur InitializeV2, il ne peut pas être défini sur quelqu’un d’autre.

Activer les frais de créateur ne choisit pas leur taux. Le pool facture l’AmmConfig.creator_fee_rate du palier de frais auquel il est lié. Sur un palier où ce taux vaut 0, un pool activé n’accumule rien. Lisez la configuration avant de choisir un palier. Le choix est aussi permanent : aucune instruction ne modifie enable_creator_fee ni creator_fee_on après la création. Voir products/cpmm/fees.

Quand les frais sont activés, les swaps les accumulent dans creator_fees_token_{0,1}. Le créateur les collecte via CollectCreatorFee ou CollectCreatorFeePermissionless, et la part du protocole issue de la mise à niveau 2026-09-19 s’applique comme d’habitude. Erreurs courantes — les mêmes que pour Initialize.

`Deposit`

Ajouter de la liquidité dans les deux tokens proportionnellement au pool. Arguments

lp_token_amount:   u64   // combien de tokens LP créer pour le LP
maximum_token_0:   u64
maximum_token_1:   u64

Comptes

#	Nom	W	S
1	`owner`		S
2	`authority`
3	`pool_state`	W
4	`owner_lp_token`	W
5	`token_0_account`	W
6	`token_1_account`	W
7	`token_0_vault`	W
8	`token_1_vault`	W
9	`token_program`
10	`token_program_2022`
11	`vault_0_mint`
12	`vault_1_mint`
13	`lp_mint`	W

Mathématiques

total_0 = vault_0 − protocol_fees_0 − fund_fees_0 − creator_fees_0    // idem pour le côté 1

needed_token_0 = ceil(lp_token_amount * total_0 / lp_supply)
transfer_0     = needed_token_0 + inverse_transfer_fee(needed_token_0) // Token-2022
require(transfer_0 <= maximum_token_0, "ExceededSlippage")             // idem pour le côté 1

Deux détails à épingler : la base au prorata est le total du vault excluant les frais (vault_amount_without_fee, c’est-à-dire le solde brut moins les compteurs de frais de protocole, de fonds et de créateurs accumulés), pas le solde brut du vault ; et le plafond de slippage est vérifié par rapport à ce que le payeur transfère réellement, après que le frais de transfert Token-2022 soit ajouté, pas par rapport au mouvement brut du vault. Aucun changement à la proportionnalité de k — les deux totaux et lp_supply se mettent à l’échelle par le même facteur. Postconditions

lp_supply += lp_token_amount.
vault_0 += needed_token_0 (net de tout frais de transfert Token-2022 sur l’entrée).
vault_1 += needed_token_1 (net de tout frais de transfert Token-2022 sur l’entrée).

Erreurs courantes — ExceededSlippage, ZeroTradingTokens, InvalidStatus si le dépôt est en pause.

`Withdraw`

Brûler les tokens LP et recevoir les deux tokens sous-jacents au prorata. Arguments

lp_token_amount:   u64
minimum_token_0:   u64
minimum_token_1:   u64

Comptes

#	Nom	W	S
1	`owner`		S
2	`authority`
3	`pool_state`	W
4	`owner_lp_token`	W
5	`token_0_account`	W
6	`token_1_account`	W
7	`token_0_vault`	W
8	`token_1_vault`	W
9	`token_program`
10	`token_program_2022`
11	`vault_0_mint`
12	`vault_1_mint`
13	`lp_mint`	W
14	`memo_program`

Les 13 premiers comptes sont identiques à Deposit, et lp_mint est inscriptible car les tokens LP sont brûlés. Withdraw prend en plus un 14e compte, memo_program (contraint address = memo::ID) — Deposit ne le fait pas. Un Withdraw à 13 comptes échoue la désérialisation Anchor, donc le LP ne peut pas sortir. Mathématiques

total_0 = vault_0 − protocol_fees_0 − fund_fees_0 − creator_fees_0    // idem pour le côté 1

out_token_0     = min(total_0, floor(lp_token_amount * total_0 / lp_supply))
receive_token_0 = out_token_0 − transfer_fee(out_token_0)             // Token-2022
require(receive_token_0 >= minimum_token_0, "ExceededSlippage")       // idem pour le côté 1

// Comme avec Deposit : la base est le total du vault excluant les frais, et le plancher est
// vérifié par rapport à ce que le LP reçoit réellement, après le frais de transfert.

Postconditions

lp_supply -= lp_token_amount.
Les vaults envoient out_token_0 / out_token_1 (brut ; l’utilisateur reçoit net de tout frais de transfert Token-2022).

`SwapBaseInput`

Swap à entrée exacte. Arguments

amount_in:            u64
minimum_amount_out:   u64

Comptes

#	Nom	W	S
1	`payer`		S
2	`authority`
3	`amm_config`
4	`pool_state`	W
5	`input_token_account`	W
6	`output_token_account`	W
7	`input_vault`	W
8	`output_vault`	W
9	`input_token_program`
10	`output_token_program`
11	`input_token_mint`
12	`output_token_mint`
13	`observation_state`	W

L’ordre entrée → sortie est par la direction de l’utilisateur, pas par le token_0 / token_1 canonique du pool. Le programme détermine quel vault est lequel en faisant correspondre les mints. Mathématiques — voir products/cpmm/math. Conditions préalables

open_time <= now.
pool_status autorise le swap.
Aucun mint en pause ou gelé pour cette autorité.
amount_in > 0.

Erreurs courantes

ExceededSlippage — amount_out < minimum_amount_out.
ZeroTradingTokens — le commerce s’arrondit à zéro.
NotApproved — le pool est en pause pour les swaps via UpdatePoolStatus.
InvalidInput — les mints ne correspondent à aucun des mints du vault du pool.

`SwapBaseOutput`

Swap à sortie exacte. Arguments

max_amount_in:  u64
amount_out:     u64

Comptes — identiques à SwapBaseInput. Mathématiques — courbe inverse avec plafond, voir products/cpmm/math. Erreurs courantes — ExceededSlippage (gross_in > max_amount_in), ZeroTradingTokens, InvalidInput, NotApproved.

`CollectProtocolFee`

Collecter les frais de protocole accumulés des vaults vers la destination du protocole. Arguments — aucun. Comptes

#	Nom	W	S	Notes
1	`owner`		S	Doit égaler `amm_config.protocol_owner` ou la clé admin codée en dur du programme.
2	`authority`
3	`pool_state`	W
4	`amm_config`
5	`token_0_vault`	W
6	`token_1_vault`	W
7	`vault_0_mint`
8	`vault_1_mint`
9	`recipient_token_0_account`	W
10	`recipient_token_1_account`	W
11	`token_program`
12	`token_program_2022`

Effet

transfer pool_state.protocol_fees_token0 from vault_0 to recipient_0
transfer pool_state.protocol_fees_token1 from vault_1 to recipient_1
pool_state.protocol_fees_token0 = 0
pool_state.protocol_fees_token1 = 0

Aucun changement aux soldes effectifs de la courbe (les frais accumulés étaient déjà exclus). Erreur courante — InvalidOwner (6001) si le signataire n’est ni amm_config.protocol_owner ni l’admin du programme. (Il n’y a pas de NotApproved sur ce chemin.)

`CollectFundFee`

Même forme que CollectProtocolFee mais signé par amm_config.fund_owner — ou, encore une fois, l’admin du programme — et mettant à zéro les compteurs fund_fees_*. Même InvalidOwner sur un mauvais signataire.

`CollectCreatorFee`

Signé par pool_state.pool_creator. Il règle les frais créateurs accumulés et transfère la part du créateur vers les comptes de tokens du créateur. Arguments — aucun. Comptes

#	Nom	W	S	Notes
1	`creator`	W	S	Contraint `address = pool_state.pool_creator`.
2	`authority`			PDA d’autorité globale du vault CPMM.
3	`pool_state`	W		Détient les compteurs de frais créateurs accumulés.
4	`amm_config`			Contraint `address = pool_state.amm_config`. Porte le `creator_fee_share_rate` par défaut.
5	`token_0_vault`	W		Doit correspondre au vault token 0 du pool.
6	`token_1_vault`	W		Doit correspondre au vault token 1 du pool.
7	`vault_0_mint`			Doit correspondre à `token_0_vault.mint`.
8	`vault_1_mint`			Doit correspondre à `token_1_vault.mint`.
9	`creator_token_0`	W		Destination pour la part du créateur du token 0.
10	`creator_token_1`	W		Destination pour la part du créateur du token 1.
11	`token_0_program`			SPL Token ou Token-2022, correspondant au token 0.
12	`token_1_program`			SPL Token ou Token-2022, correspondant au token 1.
13	`associated_token_program`
14	`system_program`
15	`creator_fee_share`			Ajouté 2026-09-19, ajouté en fin de liste après `system_program`. PDA à `["creator_fee_share", creator, amm_config]`. Doit être passé à chaque appel, mais n’est pas obligatoire d’exister — quand il est vide ou non possédé par CPMM, le programme revient à `amm_config.creator_fee_share_rate`. La contrainte de seed s’applique toujours, donc l’adresse doit être le PDA canonique.

Effet

share_rate = creator_fee_share.share_rate   (si le compte existe)
           | amm_config.creator_fee_share_rate   (sinon)

shared_i  = floor(creator_fees_token_i * share_rate / 1_000_000)
creator_i = creator_fees_token_i - shared_i

transfer creator_i from vault_i to creator_token_i
pool_state.protocol_fees_token_i += shared_i     // reste dans le vault
pool_state.creator_fees_token_i   = 0
pool_state.recent_epoch = current epoch

La part du protocole ne quitte jamais le vault ici — elle est réétiquetée comme un frais de protocole et attend CollectProtocolFee. Les deux compteurs sont déjà exclus de la vue du pool de la vault, donc le prix du pool ne bouge pas. Dérivation complète dans products/cpmm/fees. Erreurs courantes — NoFeeCollect quand les deux compteurs de créateurs sont zéro (vérifiés avant la division), InvalidInput (6003) si le share_rate résolu dépasse 1_000_000, MathOverflow (6011) si l’enregistrement de la part déborderait protocol_fees_token_*, et l’erreur ConstraintSeeds d’Anchor si creator_fee_share n’est pas le PDA canonique.

`CollectCreatorFeePermissionless`

N’importe qui peut déclencher la collecte des frais créateurs. L’instruction envoie toujours la part du créateur vers les comptes de tokens associés canoniques possédés par pool_state.pool_creator ; l’appelant ne peut pas choisir un autre créateur ou destination. Si l’une des ATAs est manquante, le payeur finance sa création. Le CollectCreatorFee original reste appelable, donc un créateur qui veut signer pour sa propre collecte peut toujours le faire. Arguments — aucun. Comptes

#	Nom	W	S	Notes
1	`payer`	W	S	N’importe quel signataire ; finance les ATAs créateurs manquantes.
2	`creator`			Doit égaler `pool_state.pool_creator` ; ne signe pas.
3	`authority`			PDA d’autorité globale du vault CPMM.
4	`pool_state`	W		Détient les compteurs de frais créateurs accumulés.
5	`token_0_vault`	W		Doit correspondre au vault token 0 du pool.
6	`token_1_vault`	W		Doit correspondre au vault token 1 du pool.
7	`vault_0_mint`			Doit correspondre à `token_0_vault.mint`.
8	`vault_1_mint`			Doit correspondre à `token_1_vault.mint`.
9	`creator_token_0`	W		ATA canonique du créateur pour `vault_0_mint` ; créée si manquante.
10	`creator_token_1`	W		ATA canonique du créateur pour `vault_1_mint` ; créée si manquante.
11	`token_0_program`			SPL Token ou Token-2022, correspondant au token 0.
12	`token_1_program`			SPL Token ou Token-2022, correspondant au token 1.
13	`associated_token_program`			Crée une ATA destinataire manquante.
14	`system_program`			Finance la création de compte à partir de `payer`.
15	`amm_config`			Ajouté 2026-09-19, ajouté en fin de liste après `system_program`. Contraint `address = pool_state.amm_config`.
16	`creator_fee_share`			Ajouté 2026-09-19, ajouté en dernier. Même PDA et même règle d’existence optionnelle que sur `CollectCreatorFee`.

Les deux nouveaux comptes sont ajoutés après system_program, et non insérés. Chaque compte de payer à system_program conserve la position qu’il avait avant la mise à niveau, donc la rupture est nette : une transaction construite selon l’ancienne disposition de quatorze comptes ne mésinterprète pas un vault comme une config — elle passe simplement trop peu de comptes et Anchor la rejette avec AccountNotEnoughKeys (3005) avant qu’aucune contrainte ne s’exécute. Les comptes restent obligatoires : ajoutez-les tous les deux en fin de liste et actualisez l’IDL ; il n’y a pas de chemin de compatibilité pour l’ancienne disposition.

Effet — identique à CollectCreatorFee ci-dessus : la part est résolue à partir de creator_fee_share ou amm_config, la part du protocole est enregistrée dans protocol_fees_token_{0,1}, la part du créateur est transférée vers les ATAs du créateur, les deux compteurs de créateurs sont mis à zéro, et recent_epoch est mis à jour. Retourne NoFeeCollect quand les deux compteurs sont zéro.

`UpdatePoolStatus`

Mettre en pause ou reprendre des opérations individuelles sur un pool. Le champ status est un masque de bits :

Bit	Drapeau	Effet quand défini
0	`DEPOSIT_DISABLED`	`Deposit` rejette avec `NotApproved`.
1	`WITHDRAW_DISABLED`	`Withdraw` rejette.
2	`SWAP_DISABLED`	`SwapBaseInput` / `SwapBaseOutput` rejettent.

Arguments

status: u8      // nouveau masque de bits

Comptes

#	Nom	W	S	Notes
1	`authority`		S	Doit correspondre à la clé admin du programme CPMM.
2	`pool_state`	W

La clé admin est une clé publique compilée dans le programme (crate::admin::ID), pas l’autorité de mise à niveau BPF — la modifier nécessite une mise à niveau du programme. Consultez reference/program-addresses pour la valeur et security/admin-and-multisig pour qui la détient.

`CreateAmmConfig`

Créer un nouveau palier de frais. Arguments

index:             u16
trade_fee_rate:    u64
protocol_fee_rate: u64
fund_fee_rate:     u64
create_pool_fee:   u64
creator_fee_rate:  u64

Comptes

#	Nom	W	S	Notes
1	`owner`	W	S	Admin.
2	`amm_config`	W		`init`ialisé ici.
3	`system_program`

Conditions préalables

Aucune AmmConfig existante avec le même index.
protocol_fee_rate + fund_fee_rate <= FEE_RATE_DENOMINATOR_VALUE.

Modifié en 2026-09 : les propriétaires de frais de la nouvelle config ne proviennent plus du signataire. create_amm_config écrit maintenant le protocol_fee_owner::ID codé en dur du programme dans protocol_owner et fund_fee_owner::ID dans fund_owner, au lieu de copier la clé du signataire admin dans les deux. Les adresses sont dans reference/program-addresses.Conséquences : les frais sur une nouvelle AmmConfig atterrissent dans les portefeuilles de frais dédiés plutôt que celui de l’admin. L’admin reste un signataire accepté pour la collecte — CollectProtocolFee / CollectFundFee acceptent amm_config.protocol_owner / fund_owner ou crate::admin::ID — donc rien n’a à être pivoté pour collecter ; ce qui a changé est seulement où les produits vont par défaut. Les comptes AmmConfig existants ne sont pas réécrits — tout ce qui y est stocké gouverne toujours, donc lisez toujours protocol_owner / fund_owner du compte au lieu d’assumer l’une ou l’autre valeur. Les paramètres 3 et 4 de UpdateAmmConfig les font toujours pivoter.

`UpdateAmmConfig`

Modifier les taux de frais ou la propriété sur une AmmConfig existante. Prend un param: u8 (quel champ mettre à jour) et une value: u64. La table de dispatch complète :

param = 0 → trade_fee_rate (affirme trade_fee_rate + creator_fee_rate < 1_000_000)
param = 1 → protocol_fee_rate (affirme ≤ 1_000_000 et + fund_fee_rate ≤ 1_000_000)
param = 2 → fund_fee_rate (affirme ≤ 1_000_000 et + protocol_fee_rate ≤ 1_000_000)
param = 3 → protocol_owner. La nouvelle clé n’est pas dans value : ajoutez-la comme remaining_accounts[0] (lecture seule est fine). Elle ne doit pas être la clé publique par défaut, et omettre le compte panique sur un unwrap().
param = 4 → fund_owner. Même mécanisme que 3.
param = 5 → create_pool_fee
param = 6 → disable_create_pool (toute value non-zéro désactive)
param = 7 → creator_fee_rate (affirme creator_fee_rate + trade_fee_rate < 1_000_000)
param = 8 → creator_fee_share_rate (affirme ≤ 1_000_000). Ajouté 2026-09-19. La part par défaut du protocole des frais créateurs sur ce palier ; voir products/cpmm/fees. Elle n’est pas liée à protocol_fee_rate, qui divise les frais commerciaux.

Tout autre param retourne InvalidInput. Les modifications sont signées par l’admin et affectent chaque pool lié à cette AmmConfig au prochain swap. Pas de migration ; les pools lisent simplement les nouvelles valeurs.

`CreateCreatorFeeShare`

Définir une part de protocole personnalisée des frais créateurs pour une paire (creator, amm_config), remplaçant AmmConfig.creator_fee_share_rate pour chaque pool que ce créateur possède sur ce palier de frais. Ajouté dans la mise à niveau de partage de frais créateurs 2026-09-19. Arguments

share_rate: u64   // part du protocole DES frais créateurs, sur FEE_RATE_DENOMINATOR = 1_000_000

Comptes

#	Nom	W	S	Notes
1	`owner`	W	S	Doit être l’admin du programme CPMM ou le propriétaire de partage de frais créateurs dédié — voir `reference/program-addresses`. Tout autre signataire échoue avec `InvalidOwner` (`6001`). Paie le loyer.
2	`creator`			Le créateur du pool auquel la taux s’applique. Non vérifié — il ne doit pas être un créateur de pool existant, et il ne signe pas.
3	`amm_config`			Le palier de frais auquel la taux s’applique.
4	`creator_fee_share`	W		`init`ialisé ici à `["creator_fee_share", creator, amm_config]`, `space = 145`.
5	`system_program`

Conditions préalables

share_rate <= 1_000_000, sinon InvalidInput (6003).
Le PDA ne doit pas déjà exister — l’init d’Anchor échoue sur un deuxième appel pour la même paire. Pour modifier une taux, fermez le compte et recréez-le.

Postconditions

creator_fee_share stocke bump, creator, amm_config et share_rate.
Chaque CollectCreatorFee / CollectCreatorFeePermissionless ultérieur sur un pool créé par creator sous amm_config résout la part à partir de ce compte au lieu de la config.

Le créateur du pool n’est pas une partie à cette instruction et ne la signe pas. La taux est lue au moment de la collecte, donc un remplacement créé après que les frais aient déjà accumulé s’applique à ce solde accumulé aussi.

`CloseCreatorFeeShare`

Supprimer le remplacement. La paire revient à AmmConfig.creator_fee_share_rate. Arguments — aucun. Comptes

#	Nom	W	S	Notes
1	`owner`	W	S	Mêmes deux signataires acceptés que `CreateCreatorFeeShare` ; reçoit le loyer.
2	`creator`			Le créateur du pool auquel la taux s’appliquait.
3	`amm_config`			Le palier de frais auquel la taux s’appliquait.
4	`creator_fee_share`	W		Fermé vers `owner`. Doit être le PDA canonique pour la paire.
5	`system_program`

Postconditions

Le compte est fermé et ses lamports vont à owner.
Les collectes pour cette paire résolvent la part à partir de amm_config.creator_fee_share_rate à nouveau — qui est 0 sauf si un admin a défini le paramètre 8 de UpdateAmmConfig.

`CollectExcessLamports`

Collecte admin des lamports assis au-dessus du minimum exempt de loyer sur les comptes que CPMM contrôle. Ajouté dans la mise à niveau 2026-09 pour que le protocole puisse récupérer le sur-financement que la réduction de loyer SIMD-0437 laisse derrière sur les comptes créés avant chaque étape. Seul l’excédent se déplace. Les soldes de tokens, les données de compte, les propriétaires, l’état du pool et la courbe restent inchangés, et l’instruction est un non-op par rapport à un compte déjà à son minimum — donc il est sûr de réexécuter après chaque étape de déploiement. Arguments — aucun. Comptes

#	Nom	W	S	Notes
1	`collect_lamports_wallet`	W	S	Destination pour chaque lamport collecté. Doit être soit l’admin du programme CPMM, soit le portefeuille de collecte de lamports dédié — voir `reference/program-addresses`. Tout autre signataire échoue avec `InvalidOwner`.
2	`authority`			Le PDA d’autorité du vault et du mint LP CPMM à la seed `[b"vault_and_lp_mint_auth_seed"]`. Il signe les CPIs du programme de tokens.
3	`token_program`			SPL Token.
4	`token_program_2022`			Token-2022. Les deux sont requis inconditionnellement ; le programme choisit par compte source.
5..	`remaining_accounts`	W		`M` comptes sources à collecter, n’importe quel nombre, n’importe quel ordre.

Correction de l’ordre, 2026-09-19. Le programme fait maintenant deux passages sur remaining_accounts — chaque CPI du programme de tokens d’abord, puis les débits directs des PDAs possédés par CPMM. Les entrelacer avortait avec le UnbalancedInstruction du runtime (« la somme des soldes de compte avant et après l’instruction ne correspondent pas ») chaque fois qu’un PDA était débité avant un CPI, car les changements de lamports en attente de l’appelant ne sont vidés dans les comptes qu’un CPI porte réellement. Les appelants n’ont pas à grouper ou trier la liste eux-mêmes.

Comment chaque compte source est traité Le programme distribue sur le propriétaire du compte source :

Propriétaire du compte source	Traitement
SPL Token ou Token-2022, compte de token non-natif ou mint — vaults de pool et mints LP	CPI `WithdrawExcessLamports` (discriminant du programme de tokens `38`), signé par `authority`.
SPL Token ou Token-2022, compte de token natif (wSOL)	`WithdrawExcessLamports` rejette les comptes natifs. Le programme CPIs `SyncNative`, mesure combien le `amount` enveloppé a grandi, `UnwrapLamports` (discriminant `45`) pour exactement ce delta, puis exige que le solde enveloppé égale sa valeur pré-sync — sinon `LamportsCalculateError` (`6015`). Un vault de pool côté SOL garde donc sa liquidité complète.
Le programme CPMM lui-même — `PoolState`, `AmmConfig`, `ObservationState`, `Permission`, `SupportMintAssociated`	Le programme débite le compte directement jusqu’à `rent.minimum_balance(data_len)`.
N’importe quoi d’autre	Ignoré silencieusement. Pas d’erreur, pas de lamports déplacés.

Parce qu’il prend une liste remaining_accounts non bornée, la taille de la transaction est la limite réelle — la même contrainte que la collecte côté portefeuille décrite dans solana-fundamentals/rent-and-reclaimable-rent. Erreurs courantes — InvalidOwner (6001, mauvais signataire), LamportsCalculateError (6015, l’aller-retour wSOL n’a pas nettoyé à zéro), et InsufficientFunds du chemin possédé par le programme quand un compte détient moins que son propre minimum de loyer. Pas de constructeur SDK. @raydium-io/raydium-sdk-v2 ne livre pas de constructeur pour cette instruction, et non plus le repo raydium-sdk-V2-demo — c’est un chemin admin. Encodez-la à la main, de la même façon que la collecte côté portefeuille dans solana-fundamentals/rent-and-reclaimable-rent le fait pour l’instruction du programme de tokens.

Matrice de changement d’état

Instruction	`lp_supply`	Soldes des vaults	Champs de frais accumulés	`observation`
`Initialize`	+ init LP	+ `init_amount_{0,1}`	0	init
`InitializeV2`	+ init LP	+ `init_amount_{0,1}`	0	init
`InitializeWithPermission`	+ init LP	+ `init_amount_{0,1}`	0	init
`Deposit`	+	+ les deux	—	—
`Withdraw`	−	− les deux	—	—
`SwapBaseInput`	—	+ entrée, − sortie	+ `trade_fee` divisé en protocole/fonds ; + `creator_fee` si activé	+ (si intervalle écoulé)
`SwapBaseOutput`	—	+ entrée, − sortie	+ `trade_fee` divisé en protocole/fonds ; + `creator_fee` si activé	+ (si intervalle écoulé)
`CollectProtocolFee`	—	− (par buckets de protocole)	`protocol_*` → 0	—
`CollectFundFee`	—	− (par buckets de fonds)	`fund_*` → 0	—
`CollectCreatorFee`	—	− (par la part du créateur seulement)	`creator_` → 0 ; `protocol_` += la part partagée	—
`CollectCreatorFeePermissionless`	—	− (par la part du créateur seulement)	`creator_` → 0 ; `protocol_` += la part partagée	—
`UpdatePoolStatus`	—	—	—	—
`CreateCreatorFeeShare`	—	—	—	—
`CloseCreatorFeeShare`	—	—	—	—
`CollectExcessLamports`	—	— (soldes de tokens inchangés)	—	—

Où aller ensuite

products/cpmm/code-demos — exemples TypeScript exécutables pour ce qui précède.
reference/error-codes — la table d’erreur Anchor complète.
products/cpmm/fees — le modèle d’accumulation de frais que les instructions Collect*Fee drainent.

Sources :

Produits

Algorithmes

Résumé des instructions

`Initialize`

`InitializeV2`

`Deposit`

`Withdraw`

`SwapBaseInput`

`SwapBaseOutput`

`CollectProtocolFee`

`CollectFundFee`

`CollectCreatorFee`

`CollectCreatorFeePermissionless`

`UpdatePoolStatus`

`CreateAmmConfig`

`UpdateAmmConfig`

`CreateCreatorFeeShare`

`CloseCreatorFeeShare`

`CollectExcessLamports`

Matrice de changement d’état

Où aller ensuite

​Résumé des instructions

​Initialize

​InitializeV2

​Deposit

​Withdraw

​SwapBaseInput

​SwapBaseOutput

​CollectProtocolFee

​CollectFundFee

​CollectCreatorFee

​CollectCreatorFeePermissionless

​UpdatePoolStatus

​CreateAmmConfig

​UpdateAmmConfig

​CreateCreatorFeeShare

​CloseCreatorFeeShare

​CollectExcessLamports

​Matrice de changement d’état

​Où aller ensuite

Résumé des instructions

`Initialize`

`InitializeV2`

`Deposit`

`Withdraw`

`SwapBaseInput`

`SwapBaseOutput`

`CollectProtocolFee`

`CollectFundFee`

`CollectCreatorFee`

`CollectCreatorFeePermissionless`

`UpdatePoolStatus`

`CreateAmmConfig`

`UpdateAmmConfig`

`CreateCreatorFeeShare`

`CloseCreatorFeeShare`

`CollectExcessLamports`

Matrice de changement d’état

Où aller ensuite