Demostraciones de código CPMM

Esta página fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.Ver versión en inglés →

Banner de versión. Todas las demostraciones de TypeScript apuntan a @raydium-io/raydium-sdk-v2@0.2.42-alpha contra Solana mainnet-beta, verificado en 2026-04. El esqueleto de Rust CPI apunta a raydium-cp-swap en la rama master, Anchor 0.30.x. Los ID de programa se extraen mediante constantes de reference/program-addresses.

Requisitos previos

npm install @raydium-io/raydium-sdk-v2 @solana/web3.js @solana/spl-token bn.js decimal.js

Cada demostración en esta página refleja un archivo en raydium-sdk-V2-demo/src/cpmm; el enlace de GitHub se encuentra junto a cada sección. El arranque sigue el config.ts.template del repositorio de demostración (fuente):

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",
  disableFeatureCheck: true,
  blockhashCommitment: "finalized",
});

La instancia Raydium es la fachada del SDK — cada demostración a continuación la utiliza. Obtiene de forma perezosa listas de tokens y configuraciones de comisiones desde api-v3.raydium.io; puedes inicializarla con tus propios datos en entornos sin conexión.

Crear un pool CPMM

Fuente: src/cpmm/createCpmmPool.ts

import { PublicKey } from "@solana/web3.js";
import BN from "bn.js";
import { getCpmmPdas, CREATE_CPMM_POOL_PROGRAM, CREATE_CPMM_POOL_FEE_ACC }
  from "@raydium-io/raydium-sdk-v2";

const mintA = new PublicKey("So11111111111111111111111111111111111111112"); // wSOL
const mintB = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"); // USDC

// 1. Elige una configuración de comisión. index=0 es el nivel de 0.25%.
const feeConfigs = await raydium.api.getCpmmConfigs();
const feeConfig  = feeConfigs.find((c) => c.index === 0)!;

// 2. Obtén los metadatos de mint para que el SDK pueda manejar extensiones de Token-2022.
const mintAInfo = await raydium.token.getTokenInfo(mintA);
const mintBInfo = await raydium.token.getTokenInfo(mintB);

// 3. Construye la transacción.
const { execute, extInfo } = await raydium.cpmm.createPool({
  programId:       CREATE_CPMM_POOL_PROGRAM,
  poolFeeAccount:  CREATE_CPMM_POOL_FEE_ACC,
  mintA:           mintAInfo,
  mintB:           mintBInfo,
  mintAAmount:     new BN(1_000_000_000),   // 1 SOL (asumiendo 9 decimales)
  mintBAmount:     new BN(   160_000_000),  // 160 USDC (a 160/SOL)
  startTime:       new BN(0),               // abierto inmediatamente
  feeConfig,
  associatedOnly:  false,
  ownerInfo:       { useSOLBalance: true },
  txVersion:       TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool creado en", extInfo.address.poolId.toBase58());
console.log("Tx:", txId);

Algunas cosas que el SDK maneja silenciosamente:

Ordena los mints en orden token0/token1 antes de derivar el PDA.
Paga la create_pool_fee única a poolFeeAccount.
Crea las cuentas de token asociadas del llamador si faltan.
Elige el programa de token correcto (SPL Token vs Token-2022) por lado.

Después de la confirmación, puedes obtener el estado del pool en vivo con:

const { poolKeys, poolInfo, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(
  extInfo.address.poolId,
);

Swap (entrada base)

Fuente: src/cpmm/swap.ts

import { CurveCalculator } from "@raydium-io/raydium-sdk-v2";

const poolId = new PublicKey("<POOL_ID>");

// 1. Carga el estado actual del pool directamente desde un RPC (no desde la API).
const { poolInfo, poolKeys, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(poolId);

const inputMint  = new PublicKey(poolInfo.mintA.address); // swap A → B
const amountIn   = new BN(100_000_000);                   // 0.1 SOL
const slippage   = 0.005;                                 // 0.5%

// 2. Cotiza localmente. El CurveCalculator del SDK refleja la matemática en cadena,
//    incluyendo comisiones de transferencia de Token-2022 en ambos lados.
const baseIn = inputMint.equals(new PublicKey(poolInfo.mintA.address));
const swapResult = CurveCalculator.swap(
  amountIn,
  baseIn ? rpcData.baseReserve : rpcData.quoteReserve,
  baseIn ? rpcData.quoteReserve : rpcData.baseReserve,
  rpcData.configInfo!.tradeFeeRate,
);
const minimumAmountOut =
  swapResult.destinationAmountSwapped.muln(1 - slippage * 100).divn(100);

// 3. Construye y envía.
const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: amountIn,
  swapResult,
  slippage,
  baseIn,
  txVersion: TxVersion.V0,
});

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

Nota: el SDK siempre vuelve a obtener el estado del pool desde un RPC dentro de getPoolInfoFromRpc. No cotes desde api-v3.raydium.io para una transacción que estés a punto de firmar — una cotización que está un bloque desactualizada puede deslizarse en ExceededSlippage en el momento de la ejecución.

Swap (salida base)

Fuente: src/cpmm/swapBaseOut.ts

const amountOutWanted = new BN(15_000_000);        // 15 USDC
const slippage        = 0.005;

const baseIn = false; // ¿B es entrada, A es salida? depende de tu dirección
const swapResult = CurveCalculator.swapBaseOutput(
  amountOutWanted,
  rpcData.baseReserve,
  rpcData.quoteReserve,
  rpcData.configInfo!.tradeFeeRate,
);
const maxAmountIn = swapResult.sourceAmountSwapped.muln(1 + slippage * 100).divn(100);

const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: maxAmountIn,
  fixedOut:    true,
  amountOut:   amountOutWanted,
  baseIn,
  slippage,
  txVersion:   TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Depositar liquidez

Fuente: src/cpmm/deposit.ts

const lpAmount = new BN(100_000);           // cantidad deseada de mint LP
const slippage = 0.01;

const { execute } = await raydium.cpmm.addLiquidity({
  poolInfo,
  poolKeys,
  lpAmount,
  slippage,
  baseIn: true,           // cotiza desde el lado de mintA
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

El SDK convierte lpAmount en needed_token_0 y needed_token_1 usando las reservas actuales del pool, infla cada una por 1 + slippage para los argumentos maximum_* de la instrucción, y construye las creaciones de ATA si es necesario.

Retirar liquidez

Fuente: src/cpmm/withdraw.ts

const lpAmount = new BN(100_000);           // LP a quemar
const slippage = 0.01;

const { execute } = await raydium.cpmm.withdrawLiquidity({
  poolInfo,
  poolKeys,
  lpAmount,
  slippage,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Cobrar comisiones de protocolo/fondo/creador

Fuente: src/cpmm/collectCreatorFee.ts, src/cpmm/collectAllCreatorFee.ts La recopilación de protocolo y fondo permanece protegida por autoridad. Las comisiones del creador tienen dos caminos: el CollectCreatorFee firmado por creador existente, y el aditivo CollectCreatorFeePermissionless, que cualquier pagador puede invocar pero que solo puede transferir a las ATA canónicas del creador. El SDK fijado expone los constructores sin procesar existentes:

import {
  makeCollectProtocolFeeInstruction,
  makeCollectFundFeeInstruction,
  makeCollectCreatorFeeInstruction,
} from "@raydium-io/raydium-sdk-v2";

// Los PDA y la autoridad se establecieron en la creación del pool; consulta reference/program-addresses
// para las semillas canónicas. El SDK expone ayudantes si lo prefieres.

@raydium-io/raydium-sdk-v2@0.2.42-alpha aún no expone un constructor para CollectCreatorFeePermissionless. Hasta que una versión del SDK lo agregue, construye desde el IDL CPMM actualizado o invoca el programa directamente. No reutilices makeCollectCreatorFeeInstruction: la nueva instrucción tiene un discriminador diferente y reemplaza las posiciones del firmante del creador / amm_config con cuentas separadas de payer y creator sin firma.

Fuera de la cadena, puedes leer las comisiones acumuladas directamente desde PoolState:

const pool = await raydium.cpmm.getRpcPoolInfo(poolId);
console.log("Comisión de protocolo acumulada token0:", pool.protocolFeesToken0.toString());
console.log("Comisión de protocolo acumulada token1:", pool.protocolFeesToken1.toString());

Esqueleto de Rust CPI

Si deseas invocar CPMM desde tu propio programa Anchor — por ejemplo, una bóveda que realiza swaps en nombre de sus depositantes — el contexto de CPI se ve así. El orden de cuentas sigue products/cpmm/instructions.

// Cargo.toml
// raydium-cp-swap = { git = "https://github.com/raydium-io/raydium-cp-swap" }
// anchor-spl       = "0.30"

use anchor_lang::prelude::*;
use anchor_spl::token_interface::{TokenAccount, TokenInterface, Mint};
use raydium_cp_swap::cpi::accounts::Swap;
use raydium_cp_swap::cpi;
use raydium_cp_swap::program::RaydiumCpSwap;

#[derive(Accounts)]
pub struct ProxySwap<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,

    /// CHECK: validado por el programa CPMM
    pub authority:     UncheckedAccount<'info>,
    /// CHECK:
    pub amm_config:    UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub pool_state:    UncheckedAccount<'info>,

    #[account(mut)]
    pub input_token_account:  InterfaceAccount<'info, TokenAccount>,
    #[account(mut)]
    pub output_token_account: InterfaceAccount<'info, TokenAccount>,

    #[account(mut)]
    pub input_vault:  InterfaceAccount<'info, TokenAccount>,
    #[account(mut)]
    pub output_vault: InterfaceAccount<'info, TokenAccount>,

    pub input_token_program:  Interface<'info, TokenInterface>,
    pub output_token_program: Interface<'info, TokenInterface>,

    pub input_token_mint:  InterfaceAccount<'info, Mint>,
    pub output_token_mint: InterfaceAccount<'info, Mint>,

    #[account(mut)]
    /// CHECK: búfer circular
    pub observation_state: UncheckedAccount<'info>,

    pub cpmm_program: Program<'info, RaydiumCpSwap>,
}

pub fn proxy_swap_base_input(
    ctx: Context<ProxySwap>,
    amount_in: u64,
    minimum_amount_out: u64,
) -> Result<()> {
    let cpi_accounts = Swap {
        payer:                ctx.accounts.payer.to_account_info(),
        authority:            ctx.accounts.authority.to_account_info(),
        amm_config:           ctx.accounts.amm_config.to_account_info(),
        pool_state:           ctx.accounts.pool_state.to_account_info(),
        input_token_account:  ctx.accounts.input_token_account.to_account_info(),
        output_token_account: ctx.accounts.output_token_account.to_account_info(),
        input_vault:          ctx.accounts.input_vault.to_account_info(),
        output_vault:         ctx.accounts.output_vault.to_account_info(),
        input_token_program:  ctx.accounts.input_token_program.to_account_info(),
        output_token_program: ctx.accounts.output_token_program.to_account_info(),
        input_token_mint:     ctx.accounts.input_token_mint.to_account_info(),
        output_token_mint:    ctx.accounts.output_token_mint.to_account_info(),
        observation_state:    ctx.accounts.observation_state.to_account_info(),
    };
    let cpi_ctx = CpiContext::new(
        ctx.accounts.cpmm_program.to_account_info(),
        cpi_accounts,
    );
    cpi::swap_base_input(cpi_ctx, amount_in, minimum_amount_out)
}

Si tu CPI firma como un PDA (por ejemplo, administras una bóveda en nombre de depositantes), reemplaza CpiContext::new con CpiContext::new_with_signer y pasa tus semillas.

Errores comunes

Una lista de verificación breve antes de abrir un ticket de soporte:

Mints ordenados. Si tu PDA poolState derivado no coincide con el pool en cadena, probablemente olvidaste ordenar los mints.
Cotización de API desactualizada. Nunca pases un valor de reserva de api-v3.raydium.io a CurveCalculator.swap. Obtén desde un RPC.
Programa de token incorrecto. El vault de un mint de Token-2022 es propiedad del programa Token-2022, no de SPL Token. Siempre usa los campos token_0_program / token_1_program del pool.
Slippage subestimado para mints con comisión de transferencia. Si cualquiera de los lados del pool es un mint de Token-2022 con comisión de transferencia, tu minimum_amount_out debe estar denominado en lo que el usuario realmente recibe, no en lo que el vault envía.
NotApproved en un swap. Verifica PoolState.status — el administrador puede haber pausado los swaps en ese pool. Consulta products/cpmm/instructions para la máscara de bits de estado.

Dónde ir a continuación

sdk-api/typescript-sdk — referencia completa del SDK.
sdk-api/rest-api — puntos finales de cotización y metadatos de pool.
user-flows/create-cpmm-pool — el recorrido sin código del mismo flujo.
integration-guides/aggregator — si estás enrutando CPMM como parte de una ruta de múltiples saltos.

Fuentes:

Productos

Algoritmos

Demostraciones de código CPMM

Requisitos previos

Crear un pool CPMM

Swap (entrada base)

Swap (salida base)

Depositar liquidez

Retirar liquidez

Cobrar comisiones de protocolo/fondo/creador

Esqueleto de Rust CPI

Errores comunes

Dónde ir a continuación

​Requisitos previos

​Crear un pool CPMM

​Swap (entrada base)

​Swap (salida base)

​Depositar liquidez

​Retirar liquidez

​Cobrar comisiones de protocolo/fondo/creador

​Esqueleto de Rust CPI

​Errores comunes

​Dónde ir a continuación

Requisitos previos

Crear un pool CPMM

Swap (entrada base)

Swap (salida base)

Depositar liquidez

Retirar liquidez

Cobrar comisiones de protocolo/fondo/creador

Esqueleto de Rust CPI

Errores comunes

Dónde ir a continuación