CPMM 코드 데모

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

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",
});

import { PublicKey } from "@solana/web3.js";
import BN from "bn.js";
import { CREATE_CPMM_POOL_PROGRAM, CREATE_CPMM_POOL_FEE_ACC }
  from "@raydium-io/raydium-sdk-v2";
// (모든 풀 PDA를 한 번에 필요로 하면 내보낸 헬퍼는 `getCreatePoolKeys`입니다.
//  `getCpmmPdas`는 없습니다.)

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

// 1. 수수료 구성을 선택합니다. index=0은 0.25% 계층입니다.
const feeConfigs = await raydium.api.getCpmmConfigs();
const feeConfig  = feeConfigs.find((c) => c.index === 0)!;

// 2. 민트 메타데이터를 가져와서 SDK가 Token-2022 확장을 처리할 수 있도록 합니다.
const mintAInfo = await raydium.token.getTokenInfo(mintA);
const mintBInfo = await raydium.token.getTokenInfo(mintB);

// 3. 트랜잭션을 구성합니다.
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 (9자리 소수점 가정)
  mintBAmount:     new BN(   160_000_000),  // 160 USDC (160/SOL)
  startTime:       new BN(0),               // 즉시 개시
  feeConfig,
  associatedOnly:  false,
  ownerInfo:       { useSOLBalance: true },
  txVersion:       TxVersion.V0,
});

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

// getPoolInfoFromRpc는 PublicKey가 아닌 위치 base58 문자열을 사용하고 객체도 아닙니다.
const { poolKeys, poolInfo, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(
  extInfo.address.poolId.toBase58(),
);

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

const POOL_ID = "<POOL_ID>";   // base58 문자열

// 1. RPC에서 직접 현재 풀 상태를 로드합니다 (API에서 아님).
const { poolInfo, poolKeys, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(POOL_ID);

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

// 2. 로컬에서 견적을 받습니다. CurveCalculator는 온체인 수학을 반영하며,
//    양쪽의 Token-2022 전송 수수료를 포함합니다. 8개 인수 모두 필수입니다.
const baseIn = inputMint === poolInfo.mintA.address;
const swapResult = CurveCalculator.swapBaseInput(
  amountIn,
  baseIn ? rpcData.baseReserve : rpcData.quoteReserve,
  baseIn ? rpcData.quoteReserve : rpcData.baseReserve,
  rpcData.configInfo!.tradeFeeRate,
  rpcData.configInfo!.creatorFeeRate,
  rpcData.configInfo!.protocolFeeRate,
  rpcData.configInfo!.fundFeeRate,
  rpcData.feeOn === FeeOn.BothToken || rpcData.feeOn === FeeOn.OnlyTokenB,
);
// swapResult 필드는 inputAmount / outputAmount / tradeFee / protocolFee /
// fundFee / creatorFee / newInputVaultAmount / newOutputVaultAmount입니다.
// destinationAmountSwapped 또는 sourceAmountSwapped는 없습니다.

// 3. 구성하고 전송합니다. 여기서 `slippage`를 전달하는 것이 바운드를 적용하는 것입니다 —
//    수동 최소 출력 산술이 필요하지 않습니다.
const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: amountIn,
  swapResult,
  slippage,
  baseIn,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Swap tx:", txId);

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

const baseIn = false; // false → mintB는 입력 측입니다
const swapResult = CurveCalculator.swapBaseOutput(
  amountOutWanted,
  baseIn ? rpcData.baseReserve : rpcData.quoteReserve,
  baseIn ? rpcData.quoteReserve : rpcData.baseReserve,
  rpcData.configInfo!.tradeFeeRate,
  rpcData.configInfo!.creatorFeeRate,
  rpcData.configInfo!.protocolFeeRate,
  rpcData.configInfo!.fundFeeRate,
  rpcData.feeOn === FeeOn.BothToken || rpcData.feeOn === FeeOn.OnlyTokenB,
);
// swapResult.inputAmount는 필요한 입력입니다. sourceAmountSwapped는 없습니다.

const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: new BN(0),   // fixedOut일 때 미사용 — 금액은 swapResult에서 옵니다
  fixedOut:    true,
  swapResult,               // 필수이며 대상 출력 금액을 전달합니다
  baseIn,
  slippage,
  txVersion:   TxVersion.V0,
});

await execute({ sendAndConfirm: true });

import { Percent } from "@raydium-io/raydium-sdk-v2";
import Decimal from "decimal.js";

// addLiquidity는 LP 금액이 아닌 INPUT 금액으로 구동됩니다.
const uiInputAmount = "0.0001";
const inputAmount = new BN(
  new Decimal(uiInputAmount).mul(10 ** poolInfo.mintA.decimals).toFixed(0),
);
const slippage = new Percent(1, 100);   // 숫자가 아닌 Percent

const { execute } = await raydium.cpmm.addLiquidity({
  poolInfo,
  poolKeys,
  inputAmount,
  baseIn: true,           // inputAmount는 mintA로 표시됩니다
  slippage,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

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

const lpAmount = new BN(100_000);           // 소각할 LP
const slippage = new Percent(1, 100);       // 숫자가 아닌 Percent

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

await execute({ sendAndConfirm: true });

// 크리에이터 서명
const { execute } = await raydium.cpmm.collectCreatorFees({
  poolInfo,
  poolKeys,
  txVersion: TxVersion.V0,
});

// 권한 없음 — 모든 지불자; 수익은 크리에이터의 정규 ATA로 이동합니다
const { execute } = await raydium.cpmm.collectCreatorFeesPermissionless({
  poolInfo,
  poolKeys,
  txVersion: TxVersion.V0,
});

// 한 번에 여러 풀, 크리에이터 서명
await raydium.cpmm.collectMultiCreatorFees({ poolInfoList, txVersion: TxVersion.V0 });

const pool = await raydium.cpmm.getRpcPoolInfo(POOL_ID);   // base58 문자열
console.log("Accrued protocol fee mintA:", pool.protocolFeesMintA.toString());
console.log("Accrued protocol fee mintB:", pool.protocolFeesMintB.toString());
// CpmmPoolInfoLayout 필드는 protocolFeesMintA/B, fundFeesMintA/B 및
// creatorFeesMintA/B입니다 — ...Token0/...Token1 필드는 없습니다.
//
// creatorFeesMintA/B는 *총* 발생액입니다. 크리에이터는 수집 시간에 해결된
// 프로토콜 공유를 뺀 것을 받습니다. protocolFeesMintA/B는 해당 공유를 받으므로
// 스왑뿐만 아니라 크리에이터 수수료 수집에서도 증가합니다.
// products/cpmm/fees#protocol-share-of-the-creator-fee를 참조하세요.

// Cargo.toml — 브랜치가 중요합니다: `master`는 여전히 anchor-lang 0.32.1을 고정합니다.
// raydium-cp-swap = { git = "https://github.com/raydium-io/raydium-cp-swap",
//                     branch = "chore/upgrade-anchor", features = ["cpi"] }
// anchor-lang      = "=1.0.2"   // raydium-cp-swap이 고정하는 것과 일치해야 합니다
// anchor-spl       = "=1.0.2"
//
// `cpi` 기능이 필수입니다 — `raydium_cp_swap::cpi` 모듈은
// 이 기능 아래에서만 존재합니다. products/clmm/code-demos의 CLMM 샘플은
// 자신의 `chore/upgrade-anchor` 브랜치에서 동일한 =1.0.2를 고정하므로
// 두 프로그램이 프로그램을 공유할 수 있습니다.

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: 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: 링 버퍼
    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(),
    };
    // Anchor 1.0은 여기서 프로그램의 Pubkey를 사용하며, AccountInfo는 아닙니다.
    let cpi_ctx = CpiContext::new(
        *ctx.accounts.cpmm_program.key,
        cpi_accounts,
    );
    cpi::swap_base_input(cpi_ctx, amount_in, minimum_amount_out)
}