Instruções do LaunchLab

Esta página foi traduzida automaticamente por IA. A versão em inglês é a fonte oficial.Ver versão em inglês →

O LaunchLab expõe um conjunto compacto de instruções: seis chamadas voltadas ao usuário mais alguns primitivos de administração. O SDK envolve todas elas; esta página documenta a superfície bruta para agregadores, ferramentas de monitoramento e programas que precisam de CPI.A atualização do programa 2026-09 reconstruiu o LaunchLab no Anchor 1.0.2 / Solana 3.1.10 e removeu três mecanismos de transição: o Initialize descontinuado agora sempre falha, MigrateToAmm perdeu seus três argumentos e todas as contas OpenBook, e o gate get_upgrade_timestamp que tornava várias verificações condicionais ao relógio desapareceu. Também adiciona uma instrução de administração, CollectExcessLamports. Veja a entrada do changelog 2026-09-09.

Inventário de instruções

Grupo	Instrução	Chamável por
Configuração global	`CreateConfig` / `UpdateConfig`	Admin do programa; a autoridade delegada de criar-config também pode chamar `CreateConfig`
Ciclo de vida do lançamento	`Initialize`	Ninguém — sempre falha com `NotApproved`. Retida apenas para que o discriminador permaneça ocupado e o IDL permaneça estável. Use `InitializeV2`.
Ciclo de vida do lançamento	`InitializeV2`	Qualquer um (criador) — mint base SPL Token; registra `amm_creator_fee_on` para a eventual graduação CPMM, e aceita um mint de quote Token-2022.
Ciclo de vida do lançamento	`InitializeWithToken2022`	Qualquer um (criador) — mint base Token-2022, `TransferFeeConfig` opcional; aceita qualquer programa de token de quote
Negociação	`BuyExactIn` / `BuyExactOut`	Qualquer um — compra com entrada exata / saída exata na curva de ligação
Negociação	`SellExactIn` / `SellExactOut`	Qualquer um — venda com entrada exata / saída exata na curva de ligação
Graduação	`MigrateToAmm`	Carteira de migração — graduação AMM v4 legada para pools inicializados antes da criação exclusiva CPMM ser aplicada. Não toma argumentos nem contas OpenBook desde 2026-09.
Graduação	`MigrateToCpswap`	Carteira de migração — graduar para CPMM. Todos os lançamentos recém-inicializados usam este caminho. Envolve `InitializeWithPermission` no CPMM.
Taxas	`CollectFee`	Admin — varrer taxas de protocolo de um lançamento
Taxas	`CollectMigrateFee`	Admin — varrer taxas de migração acumuladas
Taxas	`ClaimCreatorFee`	Criador — reivindicar taxas de criador acumuladas durante a fase de curva
Vesting	`CreateVestingAccount`	Criador — alocar tokens bloqueados a um beneficiário, desbloqueados após graduação
Vesting	`CreatePlatformVestingAccount`	Admin da plataforma — alocar tokens bloqueados a beneficiários do lado da plataforma
Vesting	`ClaimVestedToken`	Beneficiário — reivindicar tokens desbloqueados após o cliff
Configuração da plataforma	`CreatePlatformConfig` / `UpdatePlatformConfig`	Admin da plataforma
Configuração da plataforma	`CreatePlatformCurveRule` / `UpdatePlatformCurveRule` / `RemovePlatformCurveRule` / `ClosePlatformCurveRule`	`PlatformConfig.curve_rule_manager` ou o admin da plataforma — gerenciar a regra de parâmetro de lançamento de um `GlobalConfig`
Taxas da plataforma	`ClaimPlatformFee` / `ClaimPlatformFeeFromVault`	Admin da plataforma
Acesso da plataforma	`CreatePlatformAllowConfig` / `ClosePlatformAllowConfig`	Admin da plataforma — manter a lista de permissões `GlobalConfig` usada quando essa plataforma ativa restrição
Aluguel	`CollectExcessLamports`	Admin do programa ou a carteira dedicada de coleta de lamports — varrer lamports acima do mínimo isento de aluguel de cofres e PDAs controlados pelo LaunchLab. Adicionado em 2026-09.

A divisão “ExactIn/ExactOut” espelha SwapBaseInput / SwapBaseOutput do CPMM — na cadeia são discriminadores de instrução separados com arredondamento ligeiramente diferente. Seleção de caminho de graduação. Cada chamada nova InitializeV2 e InitializeWithToken2022 deve definir migrate_type = 1 (CPSWAP). Qualquer tentativa de inicializar um novo pool vinculado a AMM v4 retorna MigrateTypeNotMatch. amm_creator_fee_on apenas seleciona se a taxa de criador CPMM resultante se aplica ao token de quote ou a ambos os tokens; não seleciona o programa de destino. O Initialize legado não pode criar um lançamento em absoluto (veja abaixo). MigrateToAmm permanece chamável para um PoolState existente que foi inicializado com migrate_type = 0 antes dessa restrição. O lançamento não reescreve o estado do pool existente nem remove a instrução legada. Programa de token do lado da quote. O mint de quote pode ser de propriedade do programa SPL Token ou Token-2022. Cada instrução que o toca — CreateConfig, InitializeV2, InitializeWithToken2022, todas as quatro instruções de negociação, CollectFee, CollectMigrateFee, ClaimCreatorFee, ClaimPlatformFee e ClaimPlatformFeeFromVault — toma o programa proprietário em seu slot de conta de programa de quote. As posições das contas não mudaram; apenas o valor aceito mudou. Passe o programa que realmente possui GlobalConfig.quote_mint, que você pode ler de PoolState.token_program_flag bit1 para um lançamento existente (veja accounts) ou da conta de mint do proprietário caso contrário. O Initialize descontinuado é irrelevante aqui: sua conta de programa de quote ainda é digitada para SPL Token, e desde a atualização 2026-09 a instrução falha antes de ler qualquer conta. Lance através de InitializeV2 ou InitializeWithToken2022. MigrateToCpswap é a outra exceção, na direção oposta — toma ambos os programas incondicionalmente em vez de um por mint. Veja as contas de migração abaixo.

`Initialize`

Removido efetivamente a partir da atualização 2026-09 — esta instrução sempre falha. O handler de initialize agora é nada além de um log de Not supported. Please use initialize_v2 instruction e NotApproved (6000). É retido puramente para que seu discriminador permaneça ocupado e o IDL mantenha uma forma estável. (A struct Accounts é inalterada, então a validação gerada pelo Anchor ainda é executada primeiro; a transação reverte independentemente.)Anteriormente era gated no relógio: funcionava até três dias após o corte get_upgrade_timestamp e falhava depois. Esse helper de timestamp desapareceu, então a falha agora é incondicional. Lançamentos existentes criados através dele não são afetados — eles negociam e se formam normalmente através de MigrateToAmm ou MigrateToCpswap dependendo de seu migrate_type armazenado.Os argumentos e a lista de contas abaixo são de InitializeV2. A Initialize obsoleta recebe as mesmas 18 contas na mesma ordem e apenas os três primeiros argumentos — não tem amm_fee_on — e seu slot quote_token_program é tipado como SPL Token em vez de Interface<TokenInterface>.

Crie um novo lançamento. InitializeV2 adiciona apenas o argumento amm_fee_on em relação à Initialize obsoleta; a contagem e a ordem das contas são idênticas, e a única diferença no nível de conta é que quote_token_program é tipado Interface<TokenInterface>, de modo que um mint de quote Token-2022 é aceito. Argumentos Quatro argumentos posicionais, não uma única struct. (InitializeWithToken2022 acrescenta um quinto, transfer_fee_extension_param: Option<TransferFeeExtensionParams>; a Initialize obsoleta descarta amm_fee_on.)

base_mint_param: MintParams {
    decimals: u8,                 // must equal the program's BASE_MINT_DECIMALS
    name:     String,
    symbol:   String,
    uri:      String,
}

curve_param: CurveParams {        // Borsh enum — one leading variant-tag byte
    Constant { data: ConstantCurve { supply: u64, total_base_sell: u64,
                                     total_quote_fund_raising: u64, migrate_type: u8 } },
    Fixed    { data: FixedCurve    { supply: u64,
                                     total_quote_fund_raising: u64, migrate_type: u8 } },
    Linear   { data: LinearCurve   { supply: u64,
                                     total_quote_fund_raising: u64, migrate_type: u8 } },
}

vesting_param: VestingParams {
    total_locked_amount: u64,     // 0 requires cliff_period == unlock_period == 0
    cliff_period:        u64,     // seconds after fundraising ends
    unlock_period:       u64,     // seconds
}

amm_fee_on: AmmCreatorFeeOn       // 0 = QuoteToken, 1 = BothToken (CPMM migrations only)

A variante deve corresponder a global_config.curve_type ou a instrução reverte com InputNotMatchCurveConfig (6003). Não existe open_time, não existe argumento quote_mint (ele vem de global_config), nem struct fees, nem post_graduation_lp_policy — a disposição do LP é definida em PlatformConfig, não por lançamento. Contas — 18 no total (16 declaradas mais os dois anexos de #[event_cpi])

#	Nome	W	S	Notas
1	`payer`	W	S	Paga todo o aluguel. Não precisa ser o criador.
2	`creator`			Registrado como `pool_state.creator`; não é signatário.
3	`global_config`			Fornece o mint de quote, o tipo de curva e todos os pisos/limites.
4	`platform_config`			Fornece a taxa de plataforma e a política de disposição do LP.
5	`authority`			PDA `["vault_auth_seed"]` — uma única PDA global, compartilhada por todos os lançamentos.
6	`pool_state`	W		Nova conta.
7	`base_mint`	W	S	Keypair fresco — esta instrução o inicializa.
8	`quote_mint`			Deve ser igual a `global_config.quote_mint`.
9	`base_vault`	W		PDA `["pool_vault", pool_state, base_mint]`.
10	`quote_vault`	W		PDA `["pool_vault", pool_state, quote_mint]`.
11	`metadata_account`	W		PDA de metadados do Metaplex.
12	`base_token_program`			SPL Token para `InitializeV2`; Token-2022 para `InitializeWithToken2022`.
13	`quote_token_program`			O programa que possui `quote_mint` — SPL Token ou Token-2022.
14	`metadata_program`			Metaplex Token Metadata.
15	`system_program`
16	`rent_program`			Sysvar de rent.
17	`event_authority`			PDA `["__event_authority"]`; anexada por `#[event_cpi]`.
18	`program`			O id do programa LaunchLab; anexado por `#[event_cpi]`.

Pré-condições

quote_mint ∈ launch_config.allowed_quote_mints.
base_supply_graduation ≤ base_supply_max.
Parâmetros de taxa passam nas verificações launch_config.max_*_fee_rate.
open_time ≥ now − slop (SDK aplica ≥ now; programa tolera backdating leve).
curve_type é reconhecido.

Pós-condições

base_mint tem supply = curve_param.supply, tudo em base_vault.
A autoridade de mint é revogada nesta mesma instrução (set_authority(MintTokens, None)) logo depois de o fornecimento ser cunhado — não na graduação. O mint base fica, portanto, permanentemente com fornecimento fixo, e nenhuma instrução posterior pode cunhar mais.
PoolState inicializado com status = Fund (0), real_a = 0, real_b = 0.
total_fund_raising_b vem diretamente de curve_param.total_quote_fund_raising.
Para InitializeWithToken2022 com um TransferFeeConfig anexado: transfer_fee_config_authority = launch_authority, e withdraw_withheld_authority = PlatformConfig.transfer_fee_extension_auth quando esse campo está definido, caso contrário launch_authority. O lado de retirada é escrito na criação do mint precisamente para que a plataforma possa varrer taxas retidas antes da graduação. Veja platform-config.

Erros comuns — NotApproved (6000, incondicionalmente, para a Initialize obsoleta), InvalidInput (6002, um piso de fornecimento / taxa / arrecadação de GlobalConfig violado), InputNotMatchCurveConfig (6003, a variante de curve_param não corresponde a global_config.curve_type), MigrateTypeNotMatch (6007, migrate_type != 1), MathOverflow (6008), VestingRatioTooHigh (6010), NoSupportExtension (6017), NotEnoughRemainingAccounts (6018), InvalidPlatformAllowConfig (6022), CurveParamNotMatchPlatformRule (6025). Uma verificação address = / constraint = do Anchor que falha aparece como um código 2xxx, não como um destes — nenhum de InvalidQuoteMint, FeeRateTooHigh ou InvalidCurveParams existe no enum de erros do programa.

`Buy` (variante canônica: `BuyExactIn`)

O usuário fornece um valor de entrada fixo; a curva computa a saída. Argumentos

amount_in:           u64
minimum_amount_out:  u64
share_fee_rate:      u64   // referral fee on a 1_000_000 denominator; must be
                           // <= global_config.max_share_fee_rate. Pass 0 for no
                           // referral. Any non-zero value requires the share-fee
                           // receiver as remaining_accounts[0].

Contas

#	Nome	W	S	Notas
1	`payer`	W	S	Trader.
2	`authority`			PDA `["vault_auth_seed"]` — uma única PDA global, sem seed por lançamento.
3	`global_config`			`address = pool_state.global_config`.
4	`platform_config`			`address = pool_state.platform_config`.
5	`pool_state`	W
6	`user_base_token`	W		`token::mint = base_token_mint`.
7	`user_quote_token`	W		`token::mint = quote_token_mint`.
8	`base_vault`	W		`address = pool_state.base_vault`.
9	`quote_vault`	W		`address = pool_state.quote_vault`.
10	`base_token_mint`
11	`quote_token_mint`
12	`base_token_program`			O programa que possui o mint base — SPL Token ou Token-2022.
13	`quote_token_program`			O programa que possui o mint de quote.
14	`event_authority`			PDA `["__event_authority"]`; anexada por `#[event_cpi]`.
15	`program`			O id do programa LaunchLab; anexado por `#[event_cpi]`.

Contas restantes — o encanamento de taxas, lido nesta ordem exata:

share_fee_receiver — apenas quando share_fee_rate > 0.
system_program — sempre; verificado == System::id(), caso contrário InvalidInput.
platform_fee_vault — PDA [platform_config, quote_token_mint]; criada no primeiro uso.
creator_fee_vault — PDA [creator, quote_token_mint]; criada no primeiro uso.

Ficar sem contas retorna NotEnoughRemainingAccounts (6018). Não existe slot associated_token_program, e system_program é uma conta restante em vez de uma declarada. Pré-condições

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

Efeito

Divida quote_in em quote_in_after_fee e as partes de taxa.
Newton-resolva a curva para base_out dado o quote pós-taxa.
require(base_out ≥ minimum_base_out) caso contrário reverta ExceededSlippage.
Mova quote_in usuário → cofre. Mova base_out cofre → usuário.
Atualize base_sold += base_out, quote_reserve_real += quote_in_after_fee × (lp_share / total_share).
Atualize contadores de taxa (protocol_fees_quote, creator_fees_quote).
state_data.num_buys += 1.
Se quote_reserve_real ≥ quote_reserve_target após a atualização, o SDK tipicamente encadeia uma ix Graduate na mesma transação. O programa não se forma automaticamente dentro de Buy — um Graduate subsequente é necessário.

`BuyExactOut`

O usuário especifica o base_out exato; o programa computa quote_in. Argumentos

amount_out:         u64
maximum_amount_in:  u64
share_fee_rate:     u64   // as for BuyExactIn

Mesmas contas e o mesmo contrato de contas restantes que BuyExactIn. Usa a integral quadrática de forma fechada (ou o inverso CPMM, para curve_type 1) em vez de iteração Newton.

`Sell` / `SellExactIn` / `SellExactOut`

Espelho de Buy. O usuário retorna base_in à curva e recebe quote_out. A taxa é deduzida de quote_out, então o usuário recebe menos do que os rendimentos brutos integrados. Pré-condições —

user_base_ata.balance ≥ base_in.
Vender não pode empurrar base_sold abaixo de 0 (redundante com o acima dado que a contabilidade é consistente).
Lançamento é Active.

Efeito — simétrico a Buy. base_sold diminui, quote_reserve_real diminui. Taxas ainda acumulam.

Taxas de transferência do lado da quote

Quando o mint de quote carrega um TransferFeeConfig, o valor que o cofre move e o valor que o pagador é debitado ou creditado diferem, e o limite de slippage é verificado contra o lado do pagador. Em um mint de quote sem a extensão, cada caso abaixo é idêntico a um mint legado simples.

Instrução	Argumento	Verificado contra
`BuyExactIn`	`amount_in`	A curva é precificada em `amount_in − transfer_fee(amount_in)` — o que chega ao cofre. Um preenchimento completo debita exatamente `amount_in`; um preenchimento parcial debita o valor do cofre consumido mais sua taxa inversa.
`BuyExactOut`	`maximum_amount_in`	O valor do cofre mais a taxa de transferência inversa — o débito real.
`SellExactIn`	`minimum_amount_out`	O que o vendedor mantém após o mint reter sua taxa, não o valor bruto deixando o cofre.
`SellExactOut`	`amount_out`	Entregue exatamente. A curva visa `amount_out` mais a taxa de transferência inversa.

Duas consequências para cotação:

Um limite computado como se o mint fosse sem taxa é rejeitado. Passar o custo sem taxa como maximum_amount_in, ou os rendimentos sem taxa como minimum_amount_out, reverte com ExceededSlippage.
real_quote avança apenas pelo que chegou ao cofre. Um BuyExactIn de amount_in em um mint de quote de 5% move real_quote por amount_in × 0.95.

Um mint de quote com taxa de 100% (10000 pontos base) não pode ser invertido e reverte com CalculateOverflow nos caminhos exatos de saída. Ambos os mints do lado de negociação também são restritos ao programa passado em seu slot correspondente, então um base_token_program incompatível agora falha em vez de ser ignorado. Veja algorithms/token-2022-transfer-fees para a matemática de taxa subjacente.

Contas restantes de negociação

Todas as quatro instruções de negociação toma sua encanação de taxa através de remaining_accounts, nesta ordem:

Índice	Conta	Quando
0	`share_fee_receiver`	Apenas quando `share_fee_rate > 0`. Desloca cada índice abaixo por um quando presente.
próximo	`system_program`	Sempre. Financia criação de cofre de taxa.
próximo	`platform_fee_vault`	Sempre. PDA em seeds `[platform_config, quote_token_mint]`, criado no primeiro uso.
próximo	`creator_fee_vault`	Sempre. PDA em seeds `[creator, quote_token_mint]`, criado no primeiro uso.

Alterado em 2026-09: os últimos três agora são incondicionais, e system_program é validado. Antes desta versão o programa apenas os lia quando unix_timestamp >= get_upgrade_timestamp(), e pulava a divisão de taxa de plataforma/criador inteiramente antes daquele momento. O timestamp já passou, então o comportamento na mainnet é inalterado na prática — mas a ramificação desapareceu do código, e um construtor que ainda omite as três contas agora sempre falha com NotEnoughRemainingAccounts (6018) em vez de apenas após o corte. O slot system_program é adicionalmente verificado contra System::id() e retorna InvalidInput (6002) se contiver qualquer outra coisa, onde anteriormente qualquer conta era aceita naquela posição.

`MigrateToAmm` / `MigrateToCpswap`

Forme um lançamento em um pool negociável uma vez que a curva tenha atingido total_quote_fund_raising. Novos lançamentos são apenas CPMM. MigrateToAmm é retido para pools existentes cujo migrate_type armazenado é 0. Quem assina

MigrateToAmm — a migrate_to_amm_wallet registrada na vinculação GlobalConfig.
MigrateToCpswap — a migrate_to_cpswap_wallet registrada na vinculação GlobalConfig.

Essas carteiras são tipicamente mantidas pela manivela de graduação operada por Raydium; na prática a graduação chega segundos após o limite ser cruzado, independentemente de quem acionou a compra final. Argumentos Nenhum.

Mudança de quebra (apenas carteira de migração, 2026-09). MigrateToAmm descartou todos os três argumentos — base_lot_size, quote_lot_size, market_vault_signer_nonce — e nove contas. Seus dados de instrução agora são o discriminador nu, então um construtor antigo tanto envia 17 bytes de argumento inesperados quanto fornece uma lista de contas que não se alinha mais.Isso segue a própria remoção OpenBook do AMM v4: Initialize2 do AMM v4 não toma mais market_program ou amm_open_orders, então LaunchLab não tinha nada deixado para encaminhar. O programa também parou de fazer CPI em initialize_openbook_market, que é o que os três argumentos configuravam.Contas removidas: openbook_program, request_queue, event_queue, bids, asks, market_vault_signer, market_base_vault, market_quote_vault e amm_open_orders. A conta market permanece em sua posição — AMM v4 ainda a registra como um campo de referência — mas agora é declarada como um #[account(mut)] nu: sem restrição de proprietário, endereço ou seeds. É completamente não validada, é encaminhada direto para o CPI Initialize2 do AMM v4, e o programa não a inicializa mais. Um chamador que quer que a conta de mercado seja um mercado inicializado real tem que criá-la ele mesmo de antemão.A lista de 23 contas restante é, em ordem: payer, base_mint, quote_mint, market, amm_program, amm_pool, amm_authority, amm_lp_mint, amm_base_vault, amm_quote_vault, amm_target_orders, amm_config, amm_create_fee_destination, authority, pool_state, global_config, base_vault, quote_vault, pool_lp_token, spl_token_program, associated_token_program, system_program, rent_program.MigrateToCpswap não é afetado — nunca teve argumentos.

Efeito (comum a ambos)

Verifique pool_state.status == Migrate (ou seja, quote_reserve_target foi atingido). Caso contrário reverta com PoolMigrated (status já era Migrated) ou PoolFunding (ainda em financiamento).
Verifique pool_state.migrate_type corresponde à instrução (0 para AMM, 1 para CPMM). Caso contrário reverta com MigrateTypeNotMatch.
Compute as reservas pós-graduação:
- base_amount_out = base_vault.amount − vesting_schedule.total_locked_amount
- quote_amount_out = quote_vault.amount − quote_protocol_fee − migrate_fee − platform_fee
CPI no programa de destino (AMM v4 Initialize2 ou CPMM InitializeWithPermission) com essas reservas para criar o pool pós-graduação.
Para migrações CPMM executadas após a atualização 2026-08-17, combine platform_scale + creator_scale em uma participação de LP bloqueada de propriedade única da plataforma e cunhe no máximo um NFT de Chave de Taxa para platform_nft_wallet. Queime o restante burn_scale. Antes da atualização, creator_scale era bloqueado separadamente e sua Chave de Taxa ia para o criador do token. Migrações históricas concluídas não são modificadas. Para graduação AMM v4 legada, a disposição de LP segue o fluxo existente dessa instrução.
(Nenhuma etapa de autoridade de mint. base_mint.mint_authority já foi definido como None na criação do lançamento — veja a nota abaixo.)
Inverta pool_state.status = Migrated, defina vesting_schedule.start_time = block_time + cliff_period.

Transferência de autoridade de extensão de taxa Token-2022 — quando o mint base é um mint Token-2022 carregando TransferFeeConfig e PlatformConfig.transfer_fee_extension_auth é não-padrão, a migração também reatribui as autoridades dessa extensão à chave da plataforma:

transfer_fee_config_authority é sempre reatribuído. O PDA authority do lançamento o mantém por toda a fase pré-graduação, então sempre há algo para mover.
WithheldWithdraw é reatribuído apenas quando o PDA authority ainda o mantém. Lançamentos criados a partir de 2026-08-27 em diante já carregam transfer_fee_extension_auth naquela autoridade a partir da criação de mint, então a etapa é pulada. A guarda é o que impede a migração de reverter nesses mints — o PDA não pode assinar uma autoridade que não mantém mais.

Se transfer_fee_extension_auth é Pubkey::default() no tempo de migração, nenhuma autoridade se move e ambas permanecem com o PDA authority permanentemente. Veja platform-config.

O suprimento do mint base é fixo a partir da criação, não da graduação. InitializeV2 e InitializeWithToken2022 cunham o suprimento inteiro no cofre base e então imediatamente revogam MintTokens na mesma instrução, então base_mint.mint_authority é None por toda a vida do lançamento. A migração não a toca. (Revisões anteriores desta página colocavam a revogação na graduação; isso estava errado.) As únicas autoridades que a migração pode mover são as de taxa de transferência Token-2022 descritas abaixo.

Pós-condições — BuyExactIn, BuyExactOut, SellExactIn, SellExactOut rejeitarão a partir deste ponto com PoolMigrated. O pool AMM resultante é canônico e negocia como qualquer outro pool AMM v4 / CPMM. Erros comuns — PoolFunding, PoolMigrated, MigrateTypeNotMatch, InvalidCpSwapConfig, MathOverflow.

Contas restantes de migração CPMM

Clientes construindo MigrateToCpswap devem usar estes índices de remaining_accounts fixos:

Índice	Conta
0–4	Proprietário da Chave de Taxa de Taxa da Plataforma, mint, conta de token, PDA de liquidez bloqueada e conta de metadados
5	Criador de lançamento original; usado quando `platform_cp_creator` não está definido
6	PDA de permissão CPMM derivado de `[b"permission", launch_authority]`
7	`platform_cp_creator` configurado; usado quando o campo é não-padrão
8	PDA de mint de suporte CPMM para `mint0` classificado, derivado de `[b"support_mint", mint0]`
9	PDA de mint de suporte CPMM para `mint1` classificado, derivado de `[b"support_mint", mint1]`

A instrução requer pelo menos dez contas restantes. As contas de mint de suporte são entradas CPI somente leitura. Derive ambos os endereços mesmo quando o mint não tem registro de suporte inicializado. Construtores mais antigos que ainda anexam contas de bloqueio de criador ou omitem índices 8–9 devem ser atualizados.

Alterado em 2026-09. Duas limpezas, nenhuma das quais muda um construtor correto:

O caminho CPMM permissionado agora é o único caminho. MigrateToCpswap costumava escolher entre InitializeCpSwap e InitializeCpSwapWithPermission baseado em unix_timestamp >= get_upgrade_timestamp(). O helper de timestamp e o CPI legado desapareceram, então o caminho permissionado — e portanto o mínimo de dez contas — se aplica incondicionalmente.
Três restrições de endereço se moveram da struct de conta para o corpo da instrução. platform_config, base_vault e quote_vault ainda são necessários para corresponder aos valores armazenados em PoolState, mas a incompatibilidade agora é levantada por require_keys_eq! em vez de pela restrição address = do Anchor. A verificação é equivalente; apenas a superfície de erro difere — você obtém o genérico RequireKeysEqViolated (2502) do Anchor em vez de ConstraintAddress (2012), e é relatado sem um nome de conta. Atualize qualquer tratamento de erro que correspondeu a 2012 para essas três contas.

Programas de token de migração CPMM

MigrateToCpswap toma ambos os programas de token incondicionalmente e descobre qual deles possui cada mint. Suas duas contas de programa de token foram renomeadas correspondentemente:

Posição	Conta	Valor
primeira	`token_program`	Sempre o programa SPL Token legado
segunda	`token_program_2022`	Sempre o programa Token-2022

Eles substituem o antigo base_token_program (qualquer programa que possuía o mint base) e quote_token_program (sempre legado). As posições são inalteradas, então esta é uma mudança de valor em vez de uma mudança de layout — mas os dois valores são próximos de invertidos, e um construtor que continua passando seu par antigo fornecerá Token-2022 onde o programa legado é necessário assim que qualquer mint for um mint Token-2022. O programa legado é necessário mesmo quando nenhum mint o usa, porque o mint de LP CPMM e o NFT de Chave de Taxa de liquidez bloqueada sempre vivem nele.

Lista de permissões `GlobalConfig` da plataforma

PlatformConfig.restrict_global_config controla a verificação:

0: a plataforma aceita qualquer GlobalConfig válido; nenhuma conta de permissão é necessária.
1: Initialize, InitializeV2 e InitializeWithToken2022 devem incluir o PlatformAllowConfig correspondente em qualquer lugar em remaining_accounts.

O admin da plataforma cria ou fecha o PDA com CreatePlatformAllowConfig e ClosePlatformAllowConfig. Suas seeds são [b"platform_allow_config", platform_config, global_config]. As antigas instruções PlatformGlobalAccess gerenciadas por admin e PDA são aposentadas.

Regras de parâmetro de lançamento da plataforma

Quatro instruções gerenciam uma conta PlatformCurveRule. Todas as quatro são assinadas por PlatformConfig.curve_rule_manager ou pelo admin da plataforma — o programa aceita o admin re-derivando o PDA PlatformConfig do signatário, então nenhuma conta separada o prova. Um signatário que é nenhum dos dois retorna InvalidCurveRuleAuthority.

Instrução	Contas	Argumentos
`CreatePlatformCurveRule`	`curve_rule_authority` (signatário, mut), `platform_config`, `global_config`, `platform_curve_rule` (mut), `system_program`	nenhum
`UpdatePlatformCurveRule`	mesmas cinco	`group_id: u16`, `constraints: Vec<ParamConstraint>`
`RemovePlatformCurveRule`	mesmas cinco	`group_id: u16`
`ClosePlatformCurveRule`	as primeiras quatro	nenhum

platform_curve_rule é o PDA em [b"platform_curve_rule", platform_config, global_config].

Create aloca a conta sem grupo. Esse estado não restringe nada.
Update faz upsert do grupo com esse group_id, substituindo-o inteiramente se existir. Redimensiona a conta para caber, então o signatário complementa o aluguel que cresce e recebe de volta o aluguel que encolhe. Um novo grupo além do décimo retorna CurveRuleGroupsExceeded; mais de 25 restrições, um campo desconhecido ou operador, ou o mesmo par (field, op) duas vezes em um grupo retorna InvalidCurveRuleConstraint; os quatro campos derivados de TotalSellA em uma config não-produto-constante retorna CurveRuleFieldNotSupportedByCurve.
Remove descarta um grupo por id, encolhendo a conta e reembolsando a diferença. Um id desconhecido retorna CurveRuleGroupNotExist.
Close retorna todo o aluguel ao signatário. A config fica irrestrita novamente mesmo enquanto restrict_curve_param permanece 1.

Nenhum dos quatro muda se as regras são aplicadas. Isso é UpdatePlatformConfig::RestrictCurveParam(0 | 1), que apenas o admin da plataforma pode chamar. No caminho de lançamento. Enquanto restrict_curve_param é 1, InitializeV2 e InitializeWithToken2022 requerem o PDA de regra em remaining_accounts — incluindo quando não existe, para que omiti-lo não possa pular a verificação. Uma conta ausente é NotEnoughRemainingAccounts; um lançamento que satisfaz nenhum grupo é CurveParamNotMatchPlatformRule. A verificação é executada antes dos próprios limites de GlobalConfig e pode apenas estreitá-los. Modelo e playbooks: products/launchlab/curve-rules. Ambos os erros são evitáveis do lado do cliente — o SDK espelha essa verificação como uma função pura, veja Verifique antes de enviar.

`CollectFee`

Varredura de admin das taxas de negociação acumuladas do protocolo em um único lançamento. Argumentos — nenhum. Contas

#	Nome	W	S	Notas
1	`protocol_fee_owner`		S	Deve ser igual a `global_config.protocol_fee_owner`.
2	`authority`			PDA `[b"vault_auth_seed"]`; assina a transferência do cofre.
3	`pool_state`	W		Mutado para zerar `quote_protocol_fee`.
4	`global_config`			Fonte de verdade para o signatário.
5	`quote_vault`	W		Drenado por `quote_protocol_fee`.
6	`quote_mint`
7	`recipient_token_account`	W		ATA de `protocol_fee_owner` em `quote_mint`.
8	`token_program`			O programa que possui o mint de quote — SPL Token ou Token-2022.

Aqui quote_mint vem antes de recipient_token_account — o inverso de ClaimCreatorFee, ClaimPlatformFee e ClaimPlatformFeeFromVault, que todas colocam o destinatário primeiro. Os dois slots têm tipos Anchor diferentes (Mint vs TokenAccount), portanto trocá-los falha na desserialização em tempo de execução e parece um bug de conta errada. CollectMigrateFee tem a mesma ordem que CollectFee.

Efeito — transferir pool_state.quote_protocol_fee de quote_vault para recipient_token_account, então zerar o contador. Chamável qualquer hora após a primeira compra.

`CollectMigrateFee`

Varredura de admin da taxa de migração acumulada na graduação. Mesma forma de conta que CollectFee com migrate_fee_owner como o signatário (em vez de protocol_fee_owner) e pool_state.migrate_fee como o contador drenado.

`ClaimCreatorFee`

Varredura por criador de taxas de criador acumuladas em cada lançamento que o criador possui que usa o mesmo mint de quote. Drena o cofre de taxa por criador, não o por pool. Argumentos — nenhum. Contas

#	Nome	W	S	Notas
1	`creator`	W	S	O criador do pool.
2	`fee_vault_authority`			PDA `[b"creator_fee_vault_auth_seed"]`.
3	`creator_fee_vault`	W		PDA em seeds `[creator, quote_mint]`; o cofre de criador agregado.
4	`recipient_token_account`	W		`init_if_needed`; ATA de `creator` em `quote_mint`.
5	`quote_mint`
6	`token_program`
7	`system_program`			Para criação de ATA se necessário.
8	`associated_token_program`

Efeito — transferir o saldo inteiro de creator_fee_vault para recipient_token_account. Reverte com uma verificação de requerimento-maior-que-zero se o cofre estiver vazio.

`ClaimPlatformFee`

Varredura por plataforma que drena um cofre de quote de lançamento diretamente. Use isso quando uma plataforma quer reivindicar sua fatia para um lançamento específico sem passar pelo cofre de plataforma agregado. Argumentos — nenhum. Contas

#	Nome	W	S	Notas
1	`platform_fee_wallet`	W	S	Deve ser igual a `platform_config.platform_fee_wallet`.
2	`authority`			PDA `[b"vault_auth_seed"]`.
3	`pool_state`	W		Drenado por `pool_state.platform_fee`.
4	`platform_config`			Fonte de verdade para o signatário.
5	`quote_vault`	W		Drenado.
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`

Efeito — transferir pool_state.platform_fee de quote_vault para recipient_token_account, zerar o contador.

`ClaimPlatformFeeFromVault`

Varredura agregada por plataforma. Drena o cofre de taxa por mint de quote da plataforma que acumula taxas de cada lançamento roteado através da plataforma. Argumentos — nenhum. Contas

#	Nome	W	S	Notas
1	`platform_fee_wallet`	W	S	Deve ser igual a `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 em seeds `[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`

Efeito — transferir o saldo completo de platform_fee_vault para recipient_token_account. Reverte se o cofre estiver vazio.

`CollectExcessLamports`

Varredura de admin de lamports sentados acima do mínimo isento de aluguel em contas que LaunchLab controla. Adicionado na atualização 2026-09 para que o protocolo possa reclamar o sobre-financiamento que a redução de aluguel SIMD-0437 deixa para trás em contas criadas antes de cada etapa. Apenas o excesso se move. Saldos de token, dados de conta, proprietários, estado de curva e vesting não são tocados, e a instrução é uma no-op contra uma conta já em seu mínimo — então é seguro re-executar após cada etapa de lançamento. Argumentos — nenhum. Contas

#	Nome	W	S	Notas
1	`collect_lamports_wallet`	W	S	Destino para cada lamport varrido. Deve ser ou o admin do programa LaunchLab ou a carteira dedicada de coleta de lamports — veja `reference/program-addresses`. Qualquer outro signatário falha com `InvalidOwner` (`6001`).
2	`authority`			Uma dos três PDAs de autoridade de cofre do LaunchLab (veja abaixo). Assina os CPIs do programa de token para cada conta de token nesta chamada.
3	`token_program`			SPL Token.
4	`token_program_2022`			Token-2022. Ambos são necessários incondicionalmente; o programa escolhe por conta de origem.
5..	`remaining_accounts`	W		`M` contas de origem para varrer, qualquer número, qualquer ordem.

Escolhendo authority A conta é passada sem verificação e resolvida pelo programa, que re-deriva todos os três PDAs de autoridade do LaunchLab e corresponde:

Seed	Possui
`[b"vault_auth_seed"]`	Cada cofre de pool base e quote de lançamento
`[b"platform_fee_vault_auth_seed"]`	Cada cofre de taxa de plataforma
`[b"creator_fee_vault_auth_seed"]`	Cada cofre de taxa de criador

Uma chave que não corresponde a nenhuma das três falha a instrução inteira com InvalidOwner (6001).

Agrupe suas contas de origem por autoridade. Uma chamada carrega uma authority, e o programa de token requer que o proprietário real da conta assine. Uma conta de token de propriedade de um dos três PDAs diferente do authority que você passou faz o CPI falhar e leva a transação inteira com ele. Varra cofres de pool, cofres de taxa de plataforma e cofres de taxa de criador em transações separadas.PDAs de propriedade do programa são a exceção — são debitados diretamente, então podem andar junto com qualquer autoridade.

Como cada conta de origem é tratada

Proprietário da conta de origem	Tratamento
SPL Token ou Token-2022, conta de token não-nativa	CPI `WithdrawExcessLamports` (discriminante do programa de token `38`), assinado por `authority`.
SPL Token ou Token-2022, nativa (wSOL) conta de token	`WithdrawExcessLamports` rejeita contas nativas. O programa faz CPI em `SyncNative`, mede quanto o `amount` envolvido cresceu, `UnwrapLamports` (discriminante `45`) para exatamente esse delta, então requer que o saldo envolvido seja igual ao seu valor pré-sync — caso contrário `LamportsCalculateError` (`6031`). Um lançamento cotado em SOL portanto mantém sua reserva de quote completa.
O próprio programa LaunchLab — `PoolState`, `GlobalConfig`, `PlatformConfig`, `VestingRecord`, `PlatformCurveRule`, `PlatformAllowConfig`	O programa debita a conta diretamente para `rent.minimum_balance(data_len)`.
Qualquer outra coisa	Pulado silenciosamente. Sem erro, sem lamports movidos.

Mints base não podem ser varridos. InitializeV2 e InitializeWithToken2022 revogam MintTokens no mint base na mesma instrução que cunha o suprimento, então nenhuma chave pode assinar um WithdrawExcessLamports para ele — o aluguel do mint permanece onde está permanentemente. Erros comuns — InvalidOwner (6001, signatário errado ou uma authority que não é nenhum dos três PDAs), LamportsCalculateError (6031, a volta redonda wSOL não resultou em zero) e InsufficientFunds do caminho de propriedade do programa quando uma conta mantém menos do que seu próprio mínimo de aluguel. Sem construtor SDK. @raydium-io/raydium-sdk-v2 não envia um construtor para esta instrução, e nem o repositório raydium-sdk-V2-demo — é um caminho de admin. Codifique-o à mão, da forma que a varredura do lado da carteira em solana-fundamentals/rent-and-reclaimable-rent faz para a instrução do programa de token.

Instruções de vesting e configuração de plataforma

Estas são documentadas em páginas dedicadas porque cada uma tem seu próprio modelo de estado:

Matriz de mudança de estado

Instrução	`status`	`real_base`	`real_quote`	Contadores de taxa	Pool pós-estado
`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	(mesmo)	—
Limite atingido	→ Migrate	—	—	—	—
`MigrateToCpswap` / `MigrateToAmm` legado	→ Migrated	(congelado)	(congelado)	`migrate_fee` definido	criado; LP CPMM dividido em bloqueio de plataforma e queima
`CollectExcessLamports`	—	—	—	—	—
`CollectFee` / `CollectMigrateFee`	qualquer	—	—	contador zerado	—
`ClaimCreatorFee` / `ClaimPlatformFee*`	qualquer	—	—	drena cofre	—
`CreateVestingAccount`	Funding	—	—	—	aumenta `allocated_share_amount`
`ClaimVestedToken`	Migrated	—	—	—	drena `base_vault`

Para onde ir a seguir

products/launchlab/code-demos — exemplos TypeScript para cada instrução.
products/launchlab/accounts — forma de estado completo.
reference/error-codes — enum de erro do LaunchLab.

Fontes:

Módulo LaunchLab do Raydium SDK v2
Fonte do programa Raydium LaunchLab

LaunchLab

Token launch flow

Tips & Gotchas

Instruções do LaunchLab

Inventário de instruções

`Initialize`

`Buy` (variante canônica: `BuyExactIn`)

`BuyExactOut`

`Sell` / `SellExactIn` / `SellExactOut`

Taxas de transferência do lado da quote

Contas restantes de negociação

`MigrateToAmm` / `MigrateToCpswap`

Contas restantes de migração CPMM

Programas de token de migração CPMM

Lista de permissões `GlobalConfig` da plataforma

Regras de parâmetro de lançamento da plataforma

`CollectFee`

`CollectMigrateFee`

`ClaimCreatorFee`

`ClaimPlatformFee`

`ClaimPlatformFeeFromVault`

`CollectExcessLamports`

Instruções de vesting e configuração de plataforma

Matriz de mudança de estado

Para onde ir a seguir

​Inventário de instruções

​Initialize

​Buy (variante canônica: BuyExactIn)

​BuyExactOut

​Sell / SellExactIn / SellExactOut

​Taxas de transferência do lado da quote

​Contas restantes de negociação

​MigrateToAmm / MigrateToCpswap

​Contas restantes de migração CPMM

​Programas de token de migração CPMM

​Lista de permissões GlobalConfig da plataforma

​Regras de parâmetro de lançamento da plataforma

​CollectFee

​CollectMigrateFee

​ClaimCreatorFee

​ClaimPlatformFee

​ClaimPlatformFeeFromVault

​CollectExcessLamports

​Instruções de vesting e configuração de plataforma

​Matriz de mudança de estado

​Para onde ir a seguir

Inventário de instruções

`Initialize`

`Buy` (variante canônica: `BuyExactIn`)

`BuyExactOut`

`Sell` / `SellExactIn` / `SellExactOut`

Taxas de transferência do lado da quote

Contas restantes de negociação

`MigrateToAmm` / `MigrateToCpswap`

Contas restantes de migração CPMM

Programas de token de migração CPMM

Lista de permissões `GlobalConfig` da plataforma

Regras de parâmetro de lançamento da plataforma

`CollectFee`

`CollectMigrateFee`

`ClaimCreatorFee`

`ClaimPlatformFee`

`ClaimPlatformFeeFromVault`

`CollectExcessLamports`

Instruções de vesting e configuração de plataforma

Matriz de mudança de estado

Para onde ir a seguir