Stable AMM 程式碼示例

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

import { Raydium, TxVersion } from "@raydium-io/raydium-sdk-v2";
import { Connection, Keypair, clusterApiUrl } from "@solana/web3.js";
import BN from "bn.js";
import bs58 from "bs58";

const connection = new Connection(clusterApiUrl("mainnet-beta"));
const owner = Keypair.fromSecretKey(bs58.decode(process.env.PRIVATE_KEY!));

const raydium = await Raydium.load({ connection, owner, cluster: "mainnet" });

// 在任何 Stable 池報價之前必須執行。initLayout() 會將鏈上
// ModelDataInfo 查詢表取入 raydium.liquidity.stableLayout。
await raydium.liquidity.initLayout();

const isStable =
  pool.version === 5 ||
  pool.pooltype.includes("StablePool"); // SDK 內部使用此字串檢查

// 或者，按程式 ID：
const STABLE_AMM_PROGRAM_ID = "5quBtoiQqxF9Jv6KYKctB59NT3gtJD2Y65kdnB1Uev3h";
const isStableByProgram = pool.programId === STABLE_AMM_PROGRAM_ID;

import { PublicKey } from "@solana/web3.js";
import type { ApiV3PoolInfoStandardItem } from "@raydium-io/raydium-sdk-v2";

// 兩個常見的代幣作為範例
const mintA = new PublicKey("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"); // USDT — 參見 reference/program-addresses
const mintB = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"); // USDC

// fetchPoolByMints 返回分頁信封：{ count, data, hasNextPage }
const res = await raydium.api.fetchPoolByMints({
  mint1: mintA.toBase58(),
  mint2: mintB.toBase58(),
});

const stablePool = res.data.find(
  (p) => p.version === 5 || p.pooltype.includes("StablePool"),
) as ApiV3PoolInfoStandardItem | undefined;

if (!stablePool) {
  throw new Error("No Stable pool exists for this mint pair");
}

console.log("Stable pool id:", stablePool.id);
console.log("Stable pool programId:", stablePool.programId);
console.log("TVL:", stablePool.tvl);

import BN from "bn.js";

const amountIn = new BN(1_000_000); // 1 USDT（6 位小數），原始單位

// 即時準備金 + 狀態。在主網上你也可以從
// getAmmPoolKeys(poolId) 取得 poolKeys，從 getRpcPoolInfo(poolId) 取得準備金。
const rpcData  = await raydium.liquidity.getRpcPoolInfo(stablePool.id);
const poolKeys = await raydium.liquidity.getAmmPoolKeys(stablePool.id);

const out = raydium.liquidity.computeAmountOut({
  poolInfo: {
    ...stablePool,
    baseReserve:  rpcData.baseReserve,
    quoteReserve: rpcData.quoteReserve,
    status:       rpcData.status.toNumber(),
    version:      5, // 5 = Stable；曲線分支根據此選擇
  },
  amountIn,
  mintIn:  stablePool.mintA.address,
  mintOut: stablePool.mintB.address,
  slippage: 0.005, // 純數字：0.005 = 0.5%（範圍 1 ~ 0.0001）
});

// amountOut / minAmountOut 是原始單位的 BN，不是 TokenAmount。
console.log("Expected out:", out.amountOut.toString());
console.log("Minimum out:", out.minAmountOut.toString());

// 建構並簽署交換交易。`inputMint` 是必需的——沒有它 SDK
// 無法判斷你在池的哪一側出售。
const { transaction, execute } = await raydium.liquidity.swap({
  poolInfo:  stablePool,
  poolKeys,
  amountIn,
  amountOut: out.minAmountOut, // out.amountOut 是滑點前的數字
  inputMint: stablePool.mintA.address,
  fixedSide: "in",
  txVersion: TxVersion.V0,
});

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

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

const inputAmount = "100"; // 100 USDT，以人類單位——computePairAmount 接受十進位字串

// 計算曲線對此大小 A 所需的匹配 B 金額。
// 注意：computePairAmount 的 slippage 是 Percent（與 computeAmountOut 的不同）。
const r = raydium.liquidity.computePairAmount({
  poolInfo: stablePool,
  amount:   inputAmount,
  baseIn:   true,
  slippage: new Percent(50, 10_000), // 0.5%
});

const { execute } = await raydium.liquidity.addLiquidity({
  poolInfo: stablePool,
  poolKeys,
  amountInA: new TokenAmount(
    toToken(stablePool.mintA),
    new Decimal(inputAmount).mul(10 ** stablePool.mintA.decimals).toFixed(0),
  ),
  amountInB: new TokenAmount(
    toToken(stablePool.mintB),
    new Decimal(r.maxAnotherAmount.toExact()).mul(10 ** stablePool.mintB.decimals).toFixed(0),
  ),
  otherAmountMin: r.minAnotherAmount,
  fixedSide:      "a",
  txVersion:      TxVersion.V0,
});

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

import {
  getStablePrice,
  getDxByDyBaseIn,
  getDyByDxBaseIn,
} from "@raydium-io/raydium-sdk-v2";

// 在使用這些之前必須呼叫 initLayout() 一次（將鏈上
// `ModelDataInfo` PDA 載入 SDK 的 StableLayout 快取）。
await raydium.liquidity.initLayout();

// initLayout() 填充 StableLayout 實例；下面三個輔助函式
// 期望的純資料物件是其 `stableModelData` getter，不是實例。
const modelData = raydium.liquidity.stableLayout.stableModelData;

// 準備金以人類單位的純數字傳遞（不是 BN，不是原始單位）。
const coinReserve = 1_200_000; // 池的 coin 側準備金
const pcReserve   = 1_150_000; // 池的 pc 側準備金

// 池當前準備金處的現貨價格。第 4 個引數是 `baseCoin`：
// true 返回 coin-per-pc，false 返回倒數。
const price = getStablePrice(modelData, coinReserve, pcReserve, true);
console.log("Spot price:", price);

// 報價：給定 dx 輸入，輸出多少 dy（未應用費用）？
const dyOut = getDyByDxBaseIn(modelData, coinReserve, pcReserve, 1_000);

// 報價：給定 dy 輸出目標，需要多少 dx 輸入？
const dxIn  = getDxByDyBaseIn(modelData, coinReserve, pcReserve, 1_000);

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

const poolData = await raydium.tradeV2.fetchRoutePoolBasicInfo(); // 快取此項
const routes   = raydium.tradeV2.getAllRoute({ inputMint: mintA, outputMint: mintB, ...poolData });
const ctx      = await raydium.tradeV2.fetchSwapRoutesData({ routes, inputMint: mintA, outputMint: mintB });
const quotes   = raydium.tradeV2.getAllRouteComputeAmountOut({ /* ...ctx, amount, slippage, ... */ });

const best = quotes[0]; // 排序最佳優先
if (!best) throw new Error("no swap routes were found");

// best.poolInfoList 項目帶有 `version` — 5 標記路徑中的 Stable 池。
console.log(best.routeType, best.poolInfoList.map((p) => p.version));

const poolKeys = await raydium.tradeV2.computePoolToPoolKeys({
  pools: best.poolInfoList,
  ammRpcData:  ctx.ammPoolsRpcInfo,
  clmmRpcData: ctx.clmmPoolsRpcInfo,
});

const { execute } = await raydium.tradeV2.swap({
  routeProgram: Router,
  swapInfo:     best,
  swapPoolKeys: poolKeys,
  ownerInfo:    { associatedOnly: true, checkCreateATAOwner: true },
  txVersion:    TxVersion.V0,
});

// tradeV2.swap 可以返回多個交易；第一個建立中間 ATA。
const { txIds } = await execute({ sequentially: true });