Demos de código AMM v4

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

Banner de versão. Todos os demos visam @raydium-io/raydium-sdk-v2@0.2.64-alpha contra Solana mainnet-beta, verificado em 2026-09-09 — cada nome de builder, nome de parâmetro e tipo de parâmetro abaixo foi verificado contra o código-fonte dessa versão e contra raydium-sdk-V2-demo/src/amm. ID do programa: 675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8 (veja reference/program-addresses).Duas armadilhas que pegam a maioria das primeiras integrações: o slippage de computeAmountOut é um número simples (0.005 = 0,5%), não um Percent; e liquidity.swap requer inputMint como uma string base58.

A criação de novos pools não é mostrada aqui. A interface do Raydium não oferece mais criação de pools AMM v4 — novos pares usam CPMM por padrão. O próprio programa AMM v4 ainda aceita Initialize2 on-chain; apenas 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

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

import { PublicKey } from "@solana/web3.js";

// `liquidity.getPoolInfoFromRpc` recebe o ID do pool como uma STRING base58, não uma PublicKey.
const poolId = "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"; // SOL-USDC, veja reference/program-addresses

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);       // já é uma string base58

poolKeys é a struct que os construtores de instruções consomem. Ela carrega cada conta AMM v4 na ordem que o programa espera, mais os campos de mercado legados que o programa atual aceita posicionalmente mas não lê mais.

Swap (base-in)

import BN from "bn.js";

const amountIn = new BN(1_000_000);            // 1 USDC (quote 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: poolInfo.mintB.address,   // uma STRING base58, e é obrigatório
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Tx de swap:", txId);

O SDK roteia swaps AMM v4 através dos pontos de entrada V2, que não carregam as contas OpenBook. (Após a atualização de 2026-07, as contas de mercado não são mais validadas nem no caminho legado v1.)

Swap (base-out)

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: poolInfo.mintB.address,   // string base58, não uma PublicKey
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Adicionar liquidez

import { Percent, TokenAmount, toToken } from "@raydium-io/raydium-sdk-v2";

const amountARaw = new BN(100_000_000);        // 0.1 SOL, em unidades base

// computePairAmount recebe uma string decimal de UI (ou Decimal) e um Percent —
// não um BN e não um número — e é síncrono.
const { anotherAmount, maxAnotherAmount, minAnotherAmount } =
  raydium.liquidity.computePairAmount({
    poolInfo,
    amount: "0.1",
    baseIn: true,
    slippage: new Percent(1, 100),
  });

// addLiquidity recebe TRÊS TokenAmounts; otherAmountMin é obrigatório.
const { execute } = await raydium.liquidity.addLiquidity({
  poolInfo,
  poolKeys,
  amountInA: new TokenAmount(toToken(poolInfo.mintA), amountARaw),
  amountInB: maxAnotherAmount,
  otherAmountMin: minAnotherAmount,
  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 matemática pro-rata é executada fora dos saldos do cofre menos PnL acumulado — não há mais nenhum componente on-book para liquidar primeiro.

Remover liquidez

const lpAmount = new BN(50_000);               // LP para 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

Desde a remoção do OpenBook, um swap AMM v4 não valida mais nenhum estado de mercado, então um SwapBaseIn v1 é notavelmente mais barato do que costumava ser — e SwapBaseInV2 (8 contas, sem placeholders de mercado) é ainda mais barato. Meça seu próprio caminho em vez de orçar com base em números históricos, e sempre passe um limite de unidade de computação explícito:

const { execute, transaction } = await raydium.liquidity.swap({
  /* ...params... */
  computeBudgetConfig: {
    units: 400_000,
    microLamports: 50_000,       // taxa de prioridade por CU
  },
});

Se você omitir computeBudgetConfig, o SDK ainda pode usar seu próprio padrão; inspecione a transaction retornada para confirmar. Veja integration-guides/priority-fee-tuning.

CPI Rust direto

Se você deve fazer CPI para AMM v4 a partir de seu próprio programa Anchor, você precisará modelar a lista de contas de SwapBaseIn verbatim. Um esboço mínimo:

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<ProxyAmmV4Swap>,
    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 uma crate Anchor para CPI. O esboço acima usa uma Instruction construída manualmente.

O esboço de CPI acima usa o layout legado v1 SwapBaseIn (tag 9, 17 contas) para ler/reproduzir transações existentes. Desde a atualização de 2026-07, as contas de mercado são aceitas mas ignoradas. Para novo código, prefira SwapBaseInV2 / SwapBaseOutV2 (tags 16 / 17), que eliminam as contas de mercado (e amm_open_orders) inteiramente — passe apenas 8 contas: token_program, amm, amm_authority, os dois cofres do pool, as duas contas de token do usuário, e user_owner.

Armadilhas

Contagem de contas errada em swaps v1. O SwapBaseIn / SwapBaseOut legado ainda requer a lista completa de 17 contas (ou 18 contas) — uma contagem incompatível reverte com WrongAccountsNumber. O conteúdo das contas de mercado não é mais validado, mas você ainda deve ocupar seus slots. Prefira os pontos de entrada V2 para evitar isso.
Leitura de saldos brutos do cofre. As reservas agora são apenas do cofre; subtraia PnL acumulado (need_take_pnl_*). A cotação do SDK ou api-v3.raydium.io/pools/info/ids faz isso para você.
Chamada de instruções removidas. MonitorStep, MigrateToOpenBook, WithdrawSrm, SimulateInfo, AdminCancelOrders, e Initialize / PreInitialize legado agora revertam. Use Initialize2 para criação de pool; não há crank para chamar.
Mints Token-2022. Não suportados. 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óximos passos

products/amm-v4/instructions — a superfície em nível de instrução por trás desses demos.
user-flows/migrate-amm-v4-to-cpmm — se você é um LP considerando migração.
integration-guides/priority-fee-tuning — dimensionamento de taxa de prioridade para swaps AMM v4 pesados.

Fontes:

Products

Algorithms

Demos de código AMM v4

Configuração

Buscar um pool por ID

Swap (base-in)

Swap (base-out)

Adicionar liquidez

Remover liquidez

Ajuste de unidade de computação / taxa de prioridade

CPI Rust direto

Armadilhas

Próximos passos

​Configuração

​Buscar um pool por ID

​Swap (base-in)

​Swap (base-out)

​Adicionar liquidez

​Remover liquidez

​Ajuste de unidade de computação / taxa de prioridade

​CPI Rust direto

​Armadilhas

​Próximos passos

Configuração

Buscar um pool por ID

Swap (base-in)

Swap (base-out)

Adicionar liquidez

Remover liquidez

Ajuste de unidade de computação / taxa de prioridade

CPI Rust direto

Armadilhas

Próximos passos