> ## 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. # Demos de código do AMM v4 > Exemplos em TypeScript para realizar swaps contra um pool AMM v4 existente e fornecer liquidez. A criação de novos pools está fora do escopo — use CPMM. **Esta página foi traduzida automaticamente por IA. A versão em inglês é a fonte oficial.** [Ver versão em inglês →](/products/amm-v4/code-demos) **Versão.** Todos os demos visam `@raydium-io/raydium-sdk-v2@0.2.42-alpha` contra Solana mainnet-beta, verificado em 2026-04. ID do programa: `675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8` (veja [`reference/program-addresses`](/pt/reference/program-addresses)). **Criação de novos pools não é mostrada aqui.** A UI do Raydium não oferece mais criação de pools AMM v4 — novos pares usam por padrão [CPMM](/pt/products/cpmm/code-demos). O programa AMM v4 em si ainda aceita `Initialize2` on-chain; simplesmente não é o caminho recomendado. Os demos abaixo cobrem as operações de pool ativo que todo integrador ainda precisa: swap, depósito, saque. ## Configuração ```ts theme={null} import { Connection, Keypair, clusterApiUrl } from "@solana/web3.js"; import { Raydium, TxVersion } from "@raydium-io/raydium-sdk-v2"; import fs from "node:fs"; const connection = new Connection(process.env.RPC_URL ?? clusterApiUrl("mainnet-beta")); const owner = Keypair.fromSecretKey( new Uint8Array(JSON.parse(fs.readFileSync(process.env.KEYPAIR!, "utf8"))), ); const raydium = await Raydium.load({ owner, connection, cluster: "mainnet" }); ``` ## Buscar um pool por ID ```ts theme={null} import { PublicKey } from "@solana/web3.js"; const poolId = new PublicKey(""); // Extrai o objeto pool normalizado pelo SDK. Para AMM v4 isto inclui as // contas OpenBook que os construtores de instruções precisarão. const data = await raydium.liquidity.getPoolInfoFromRpc({ poolId }); const { poolInfo, poolKeys, poolRpcData } = data; console.log("Par:", poolInfo.mintA.symbol, "/", poolInfo.mintB.symbol); console.log("Versão:", poolInfo.version); // 4 para AMM v4 console.log("Mercado:", poolKeys.marketId.toBase58()); ``` `poolKeys` é a estrutura que os construtores de instruções consomem. Ela carrega todas as contas AMM v4 e OpenBook na ordem que o programa espera. ## Swap (entrada de base) ```ts theme={null} import BN from "bn.js"; const amountIn = new BN(1_000_000); // 1 USDC (cotação com 6 decimais) const inputMint = new PublicKey(poolInfo.mintB.address); // USDC const slippage = 0.005; const computed = raydium.liquidity.computeAmountOut({ poolInfo, amountIn, mintIn: inputMint, mintOut: new PublicKey(poolInfo.mintA.address), slippage, }); const { execute } = await raydium.liquidity.swap({ poolInfo, poolKeys, amountIn, amountOut: computed.minAmountOut, fixedSide: "in", inputMint, txVersion: TxVersion.V0, }); const { txId } = await execute({ sendAndConfirm: true }); console.log("Tx de swap:", txId); ``` O SDK adiciona todas as contas OpenBook automaticamente. Não tente substituí-las manualmente — o programa valida cada slot. ## Swap (saída de base) ```ts theme={null} const amountOut = new BN(1_000_000_000); // 1 SOL (base com 9 decimais) const slippage = 0.005; const computed = raydium.liquidity.computeAmountIn({ poolInfo, amountOut, mintOut: new PublicKey(poolInfo.mintA.address), mintIn: new PublicKey(poolInfo.mintB.address), slippage, }); const { execute } = await raydium.liquidity.swap({ poolInfo, poolKeys, amountIn: computed.maxAmountIn, amountOut, fixedSide: "out", inputMint: new PublicKey(poolInfo.mintB.address), txVersion: TxVersion.V0, }); await execute({ sendAndConfirm: true }); ``` ## Adicionar liquidez ```ts theme={null} const amountA = new BN(100_000_000); // 0.1 SOL const { anotherAmount, maxAnotherAmount } = raydium.liquidity.computePairAmount({ poolInfo, amount: amountA, baseIn: true, slippage: 0.01, }); const { execute } = await raydium.liquidity.addLiquidity({ poolInfo, poolKeys, amountInA: amountA, amountInB: maxAnotherAmount, fixedSide: "a", txVersion: TxVersion.V0, }); await execute({ sendAndConfirm: true }); ``` `fixedSide: "a"` diz ao SDK que você forneceu o `amountInA` exato e que `amountInB` deve ser no máximo `maxAnotherAmount`. A liquidez em livro do pool é liquidada antes da matemática pro-rata, portanto a razão de depósito corresponde às reservas mais recentes. ## Remover liquidez ```ts theme={null} const lpAmount = new BN(50_000); // LP a queimar const { execute } = await raydium.liquidity.removeLiquidity({ poolInfo, poolKeys, lpAmount, baseAmountMin: new BN(0), quoteAmountMin: new BN(0), txVersion: TxVersion.V0, }); await execute({ sendAndConfirm: true }); ``` Os mínimos de slippage protegem contra o estado do pool mudar entre sua pré-cotação e o tempo de execução. ## Ajuste de unidade de computação / taxa de prioridade Os swaps AMM v4 são pesados em computação porque toda instrução valida o estado completo do OpenBook. Um swap típico usa 180k–250k CU dependendo de quantas ordens abertas precisam ser liquidadas. Sempre passe um limite de unidade de computação: ```ts theme={null} import { ComputeBudgetProgram } from "@solana/web3.js"; const { execute, innerTransactions } = await raydium.liquidity.swap({ /* ...params... */ computeBudgetConfig: { units: 400_000, microLamports: 50_000, // taxa de prioridade }, }); ``` Se você omitir `computeBudgetConfig`, o SDK ainda pode usar seu próprio padrão; inspecione `innerTransactions` para confirmar. Veja [`integration-guides/priority-fee-tuning`](/pt/integration-guides/priority-fee-tuning). ## CPI Rust Direto Se você deve fazer CPI para AMM v4 a partir do seu próprio programa Anchor, você precisará modelar a lista de contas de `SwapBaseIn` literalmente. Um esboço mínimo: ```rust theme={null} use anchor_lang::prelude::*; use anchor_lang::solana_program::program::invoke_signed; use anchor_lang::solana_program::instruction::Instruction; const AMM_V4_PROGRAM_ID: Pubkey = pubkey!("675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"); #[derive(Accounts)] pub struct ProxyAmmV4Swap<'info> { /// CHECK: pub token_program: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub amm: UncheckedAccount<'info>, /// CHECK: pub amm_authority: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub amm_open_orders: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub amm_target_orders: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub pool_coin_token_account: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub pool_pc_token_account: UncheckedAccount<'info>, /// CHECK: pub market_program: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub market: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub market_bids: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub market_asks: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub market_event_queue: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub market_coin_vault: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub market_pc_vault: UncheckedAccount<'info>, /// CHECK: pub market_vault_signer: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub user_source: UncheckedAccount<'info>, #[account(mut)] /// CHECK: pub user_dest: UncheckedAccount<'info>, pub user_owner: Signer<'info>, } pub fn proxy_swap( ctx: Context, amount_in: u64, minimum_amount_out: u64, ) -> Result<()> { // O discriminador de instrução para SwapBaseIn é 9 no AMM v4. let mut data = vec![9u8]; data.extend_from_slice(&amount_in.to_le_bytes()); data.extend_from_slice(&minimum_amount_out.to_le_bytes()); let ix = Instruction { program_id: AMM_V4_PROGRAM_ID, accounts: vec![ AccountMeta::new_readonly(ctx.accounts.token_program.key(), false), AccountMeta::new(ctx.accounts.amm.key(), false), AccountMeta::new_readonly(ctx.accounts.amm_authority.key(), false), AccountMeta::new(ctx.accounts.amm_open_orders.key(), false), AccountMeta::new(ctx.accounts.amm_target_orders.key(), false), AccountMeta::new(ctx.accounts.pool_coin_token_account.key(), false), AccountMeta::new(ctx.accounts.pool_pc_token_account.key(), false), AccountMeta::new_readonly(ctx.accounts.market_program.key(), false), AccountMeta::new(ctx.accounts.market.key(), false), AccountMeta::new(ctx.accounts.market_bids.key(), false), AccountMeta::new(ctx.accounts.market_asks.key(), false), AccountMeta::new(ctx.accounts.market_event_queue.key(), false), AccountMeta::new(ctx.accounts.market_coin_vault.key(), false), AccountMeta::new(ctx.accounts.market_pc_vault.key(), false), AccountMeta::new_readonly(ctx.accounts.market_vault_signer.key(), false), AccountMeta::new(ctx.accounts.user_source.key(), false), AccountMeta::new(ctx.accounts.user_dest.key(), false), AccountMeta::new_readonly(ctx.accounts.user_owner.key(), true), ], data, }; invoke_signed(&ix, &ctx.accounts.to_account_infos(), &[])?; Ok(()) } ``` AMM v4 não fornece um crate Anchor para CPI. O esboço acima usa uma `Instruction` construída manualmente. ## Armadilhas * **Falta de uma conta OpenBook.** Todas as 8 contas do lado OpenBook são obrigatórias em cada swap, depósito e saque; o SDK trata disso, instruções construídas manualmente geralmente não. * **Ler saldos brutos de cofre.** Não reflete quantidades depositadas em livro ou PnL acumulado. Use a cotação do SDK ou `api-v3.raydium.io/pools/info/ids`. * **Fila de eventos OpenBook cheia.** Um pool pode reverter swaps com `SerumOrderError` quando a fila de eventos do seu mercado precisa de cranking. Cranking é sem permissão (`MonitorStep` nas contas OpenBook do mercado). * **Mints Token-2022.** Não suportado. Um pool AMM v4 não pode ser criado contra um mint Token-2022; qualquer par Token-2022 deve estar em CPMM ou CLMM. ## Próximas etapas * [`products/amm-v4/instructions`](/pt/products/amm-v4/instructions) — a superfície em nível de instrução por trás destes demos. * [`user-flows/migrate-amm-v4-to-cpmm`](/pt/user-flows/migrate-amm-v4-to-cpmm) — se você for um LP considerando migração. * [`integration-guides/priority-fee-tuning`](/pt/integration-guides/priority-fee-tuning) — dimensionamento de taxa de prioridade para swaps pesados do AMM v4. Fontes: * [Raydium SDK v2](https://github.com/raydium-io/raydium-sdk-V2) * [Programa Raydium AMM](https://github.com/raydium-io/raydium-amm)