Saltar para o conteúdo principal

Documentation Index

Fetch the complete documentation index at: https://docs.raydium.io/llms.txt

Use this file to discover all available pages before exploring further.

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

​
Resumo de instruções

TagDiscriminadorExatoVariante
0SwapBaseInWithUserAccountEntradaLegado
1SwapBaseOutWithUserAccountSaídaLegado
5CreateSyncNative—Utilitário
6CloseTokenAccount—Utilitário
8SwapBaseInEntradaAtual
9SwapBaseOutSaídaAtual
Legenda:
  • Exato: qual quantidade é fixada pelo chamador (Entrada = entrada exata amount_in; Saída = saída exata amount_out).
  • Variante: instruções legadas exigem uma deque limit_prices não vazia mesmo se nenhum hop CLMM estiver na rota. Instruções atuais (8 / 9) tratam um limit_prices vazio como “sem verificações”, que é o caminho recomendado para novo código.
Todas as variantes de swap roteiam tokens intermediários através de ATAs controladas pelo usuário — o usuário é proprietário da ATA de entrada, de cada ATA intermediária e da ATA de saída. Para novas integrações, use tag 8 (SwapBaseIn) ou tag 9 (SwapBaseOut) a menos que você tenha um motivo específico para chamar uma variante Legada.

​
Instruções de swap atuais (recomendadas)

Estes são os pontos de entrada que o novo código deve usar. A estrutura de argumentos é a mesma que as variantes Legadas, mas limit_prices pode estar vazio.

​
SwapBaseIn (tag 8)

Swap multi-hop com entrada exata. O chamador fixa amount_in; o roteador executa hop a hop e afirma que o montante final fica em ou acima de minimum_amount_out. Argumentos 
amount_in:            u64
minimum_amount_out:   u64
limit_prices:         VecDeque<u128>  // opcional; deque vazio significa sem verificação de preço CLMM por hop
Contas 
[
  <user_input_ata> W S,         // assinante; saldo >= amount_in
  <user_intermediate_ata_1> W,  // um por hop intermediário
  ... <user_intermediate_ata_N> W,
  <user_output_ata> W,
  <token_program>,

  <pool_program_hop_1>,         // identifica qual família AMM o hop 1 é
  <pool_state_hop_1> W,
  ... <outras contas exigidas pelo programa do hop 1>,

  <pool_program_hop_2>,
  <pool_state_hop_2> W,
  ... <contas do hop 2>,

  ... [repita por hop]
]
A lista exata de contas por hop depende do programa AMM subjacente (AMM v4 / CPMM / CLMM / Stable). O roteador envia CPI em cada um por sua vez e valida que o ID do programa corresponde a um dos quatro programas suportados. Pré-condições
  • O chamador assina com user_input_ata.
  • user_input_ata.amount >= amount_in.
  • Cada ATA intermediária do usuário existe e é de propriedade do chamador.
  • Se algum hop é CLMM e você quer aplicação vinculada a preço, forneça uma entrada de limit_prices por hop CLMM.
Pós-condições
  • Saldo de user_input_ata diminuído por amount_in.
  • Saldo de user_output_ata aumentado por ≥ minimum_amount_out.
  • Cada ATA intermediária é deixada com mudança líquida zero (a rota consome tudo que produziu um hop anterior).
Erros comuns
  • ExceededSlippage — saída final < minimum_amount_out.
  • InvalidInput — rota vazia, contas malformadas ou pool_program não suportado.
  • SqrtPriceX64 — o preço de um hop CLMM se moveu fora do limite de limit_prices fornecido (apenas quando limit_prices não está vazio).

​
SwapBaseOut (tag 9)

Swap multi-hop com saída exata. O chamador fixa amount_out; o roteador afirma que a entrada real não excede maximum_amount_in. Argumentos 
maximum_amount_in:   u64
amount_out:          u64
limit_prices:        VecDeque<u128>  // opcional; deque vazio significa sem verificação de preço CLMM por hop
Contas — mesma estrutura que tag 8. Pré-condições
  • O chamador assina com user_input_ata; saldo >= maximum_amount_in (pior caso).
  • Cada ATA intermediária e de saída existem.
Pós-condições
  • user_input_ata diminuído pelo montante real necessário (≤ maximum_amount_in).
  • user_output_ata aumentado por exatamente amount_out.
Erros comuns
  • ExceededSlippage — entrada necessária excede maximum_amount_in.
  • InvalidInput, SqrtPriceX64 — como para tag 8.

​
Instruções de swap legadas

Estas variantes mais antigas ainda podem ser chamadas no programa ao vivo e são documentadas aqui por completude. Prefira tag 8 / tag 9 para novo código; ambas as variantes Legadas abaixo exigem uma deque limit_prices não vazia mesmo quando nenhum hop CLMM está envolvido, o que as torna incômodas de usar.

​
SwapBaseInWithUserAccount (tag 0)

Swap multi-hop com entrada exata, idêntico em forma à tag 8, mas com o requisito mais rigoroso de limit_prices. Argumentos 
amount_in:           u64
minimum_amount_out:  u64
limit_prices:        VecDeque<u128>  // obrigatório, não vazio
Contas — mesma forma que SwapBaseIn (tag 8). Todos os slots intermediários devem ser ATAs de propriedade do chamador. Pré-condições
  • O chamador assina com user_input_ata.
  • user_input_ata.amount >= amount_in.
  • Todas as ATAs intermediárias do usuário existem e são de propriedade do chamador.
  • limit_prices é não vazio (uma entrada por hop CLMM; preencha com valores de placeholder se nenhum hop CLMM estiver envolvido).
Pós-condições
  • Saldo de user_input_ata diminuído por amount_in.
  • Saldo de user_output_ata aumentado por ≥ minimum_amount_out.
Erros comuns
  • ExceededSlippage.
  • InvalidInput — limit_prices vazio é rejeitado nesta variante Legada.
  • SqrtPriceX64.

​
SwapBaseOutWithUserAccount (tag 1)

Swap com saída exata, o equivalente Legado de SwapBaseOut (tag 9). Argumentos 
maximum_amount_in:   u64
amount_out:          u64
limit_prices:        VecDeque<u128>  // obrigatório, não vazio
Contas — mesma forma que tag 0 / tag 9. Pré-condições
  • O chamador assina com user_input_ata.
  • user_input_ata.amount >= maximum_amount_in.
  • Todas as ATAs intermediárias do usuário existem e são de propriedade do chamador.
  • limit_prices é não vazio.
Pós-condições
  • user_input_ata diminuído pelo montante real necessário (≤ maximum_amount_in).
  • user_output_ata aumentado por exatamente amount_out.
Erros comuns
  • ExceededSlippage.
  • InvalidInput.
  • SqrtPriceX64.

​
Instruções de utilitário

​
CreateSyncNative (tag 5)

Cria (se ausente) e sincroniza uma ATA wSOL em uma única etapa. Conveniente ao encapsular SOL junto com um swap. Argumentos 
amount: u64    // SOL a encapsular (lamports)
Contas 
[
  <user_wsol_ata> W,            // ATA para wSOL; criada se ausente
  <user_native_account> W S,    // assinante; SOL é debitado daqui
  <wsol_mint>,
  <system_program>,
  <token_program>,
  <associated_token_program>,
]
Efeito
  • Cria user_wsol_ata se ela ainda não existir.
  • Transfere amount lamports do saldo SOL nativo do assinante para a ATA.
  • Chama SyncNative na ATA para que seu saldo de token reflita os novos lamports.
Erros comuns
  • InvalidOwner — o proprietário de user_wsol_ata não é o assinante.

​
CloseTokenAccount (tag 6)

Fecha uma conta de token e retorna seu aluguel para a carteira de destino. Funciona em par com CreateSyncNative: após um swap de wSOL, chame CloseTokenAccount para recuperar o aluguel que apoiou a ATA wSOL. Argumentos — nenhum. Contas 
[
  <token_account_to_close> W,
  <destination_for_rent> W,
  <owner> S,
  <token_program>,
]
Efeito
  • Fecha token_account_to_close.
  • Transfere o saldo de lamports isento de aluguel (~0.00203928 SOL em mainnet para uma conta SPL Token vanilla) para destination_for_rent.
  • A conta de token deve ter saldo de token zero.
Erros comuns
  • InvalidOwner — o chamador não é o proprietário da ATA.
  • Saldo da conta de token é não zero.

​
Próximas etapas