Swap Examples

import * as anchor from "@coral-xyz/anchor";
import { Program, AnchorProvider } from "@coral-xyz/anchor";
import { PublicKey } from "@solana/web3.js";
import {
  TOKEN_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID,
  getAssociatedTokenAddress,
  getAccount,
  createAssociatedTokenAccountInstruction,
} from "@solana/spl-token";
import idl from "./custom_stablecoins.json";

// Devnet addresses
const PROGRAM_ID        = new PublicKey("9vDwZVJXw5nxymWmUcgmNpemDH5EBcJwLNhtsznrgJDH");
const USDC_MINT         = new PublicKey("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU");
const CUSTOM_TOKEN_MINT = new PublicKey("5P6MkoaCd9byPxH4X99kgKtS6SiuCQ67ZPCJzpXGkpCe"); // CBTUSD

const provider = anchor.AnchorProvider.env();
anchor.setProvider(provider);
// @ts-ignore - IDL type compatibility
const program = new Program(idl, provider);

async function swapUsdcForCustomToken() {
  const swapAmount   = new anchor.BN(0.1 * 10 ** 6);   // 0.1 USDC (6 decimals)
  const minAmountOut = new anchor.BN(0.09 * 10 ** 6);  // Allow up to 10% for fees/slippage

  // Derive PDAs
  const [pool] = PublicKey.findProgramAddressSync(
    [Buffer.from("liquidity_pool")],
    PROGRAM_ID
  );

  const [usdcVault] = PublicKey.findProgramAddressSync(
    [Buffer.from("token_vault"), pool.toBuffer(), USDC_MINT.toBuffer()],
    PROGRAM_ID
  );

  const [customTokenVault] = PublicKey.findProgramAddressSync(
    [Buffer.from("token_vault"), pool.toBuffer(), CUSTOM_TOKEN_MINT.toBuffer()],
    PROGRAM_ID
  );

  const [usdcVaultTokenAccount] = PublicKey.findProgramAddressSync(
    [Buffer.from("vault_token_account"), usdcVault.toBuffer()],
    PROGRAM_ID
  );

  const [customTokenVaultTokenAccount] = PublicKey.findProgramAddressSync(
    [Buffer.from("vault_token_account"), customTokenVault.toBuffer()],
    PROGRAM_ID
  );

  // User token accounts
  const userUsdcAccount = await getAssociatedTokenAddress(
    USDC_MINT,
    provider.wallet.publicKey
  );

  const userCustomTokenAccount = await getAssociatedTokenAddress(
    CUSTOM_TOKEN_MINT,
    provider.wallet.publicKey
  );

  // Fetch pool to get fee recipient
  const poolAccount = await (program.account as any).liquidityPool.fetch(pool);

  const feeRecipientUsdcAccount = await getAssociatedTokenAddress(
    USDC_MINT,
    poolAccount.feeRecipient
  );

  // Create destination ATA if it doesn't exist
  let needsAccountCreation = false;
  try {
    await getAccount(provider.connection, userCustomTokenAccount);
  } catch {
    needsAccountCreation = true;
  }

  // Build swap instruction
  const swapIx = await program.methods
    .swap(swapAmount, minAmountOut)
    .accounts({
      pool,
      inVault: usdcVault,
      outVault: customTokenVault,
      inVaultTokenAccount: usdcVaultTokenAccount,
      outVaultTokenAccount: customTokenVaultTokenAccount,
      userFromTokenAccount: userUsdcAccount,
      toTokenAccount: userCustomTokenAccount,
      feeRecipientTokenAccount: feeRecipientUsdcAccount,
      feeRecipient: poolAccount.feeRecipient,
      fromMint: USDC_MINT,
      toMint: CUSTOM_TOKEN_MINT,
      user: provider.wallet.publicKey,
      tokenProgram: TOKEN_PROGRAM_ID,
      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
      systemProgram: anchor.web3.SystemProgram.programId,
    } as any)
    .instruction();

  // Optionally prepend ATA creation
  const transaction = new anchor.web3.Transaction();
  if (needsAccountCreation) {
    transaction.add(
      createAssociatedTokenAccountInstruction(
        provider.wallet.publicKey,
        userCustomTokenAccount,
        provider.wallet.publicKey,
        CUSTOM_TOKEN_MINT
      )
    );
  }
  transaction.add(swapIx);

  const tx = await provider.sendAndConfirm(transaction);
  console.log("Swap successful:", tx);
}

async function swapCustomTokenForUsdc() {
  const swapAmount   = new anchor.BN(0.1 * 10 ** 6);   // 0.1 custom tokens (6 decimals)
  const minAmountOut = new anchor.BN(0.09 * 10 ** 6);  // Allow up to 10% for fees/slippage

  // Derive PDAs
  const [pool] = PublicKey.findProgramAddressSync(
    [Buffer.from("liquidity_pool")],
    PROGRAM_ID
  );

  const [customTokenVault] = PublicKey.findProgramAddressSync(
    [Buffer.from("token_vault"), pool.toBuffer(), CUSTOM_TOKEN_MINT.toBuffer()],
    PROGRAM_ID
  );

  const [usdcVault] = PublicKey.findProgramAddressSync(
    [Buffer.from("token_vault"), pool.toBuffer(), USDC_MINT.toBuffer()],
    PROGRAM_ID
  );

  const [customTokenVaultTokenAccount] = PublicKey.findProgramAddressSync(
    [Buffer.from("vault_token_account"), customTokenVault.toBuffer()],
    PROGRAM_ID
  );

  const [usdcVaultTokenAccount] = PublicKey.findProgramAddressSync(
    [Buffer.from("vault_token_account"), usdcVault.toBuffer()],
    PROGRAM_ID
  );

  // User token accounts
  const userCustomTokenAccount = await getAssociatedTokenAddress(
    CUSTOM_TOKEN_MINT,
    provider.wallet.publicKey
  );

  const userUsdcAccount = await getAssociatedTokenAddress(
    USDC_MINT,
    provider.wallet.publicKey
  );

  // Fetch pool to get fee recipient
  const poolAccount = await (program.account as any).liquidityPool.fetch(pool);

  const feeRecipientCustomTokenAccount = await getAssociatedTokenAddress(
    CUSTOM_TOKEN_MINT,
    poolAccount.feeRecipient
  );

  // Build and send swap
  const swapIx = await program.methods
    .swap(swapAmount, minAmountOut)
    .accounts({
      pool,
      inVault: customTokenVault,
      outVault: usdcVault,
      inVaultTokenAccount: customTokenVaultTokenAccount,
      outVaultTokenAccount: usdcVaultTokenAccount,
      userFromTokenAccount: userCustomTokenAccount,
      toTokenAccount: userUsdcAccount,
      feeRecipientTokenAccount: feeRecipientCustomTokenAccount,
      feeRecipient: poolAccount.feeRecipient,
      fromMint: CUSTOM_TOKEN_MINT,
      toMint: USDC_MINT,
      user: provider.wallet.publicKey,
      tokenProgram: TOKEN_PROGRAM_ID,
      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
      systemProgram: anchor.web3.SystemProgram.programId,
    } as any)
    .instruction();

  const transaction = new anchor.web3.Transaction();
  transaction.add(swapIx);

  const tx = await provider.sendAndConfirm(transaction);
  console.log("Swap successful:", tx);
}

// Available output-token liquidity: current balance of the output vault token account
async function getAvailableLiquidity(outVaultTokenAccount: PublicKey): Promise<bigint> {
  const account = await getAccount(provider.connection, outVaultTokenAccount);
  return account.amount; // bigint, in the output token's base units
}

// Normalize an amount between two decimal precisions (input <-> output token)
function convertDecimals(amount: bigint, fromDecimals: number, toDecimals: number): bigint {
  if (fromDecimals === toDecimals) return amount;
  if (toDecimals > fromDecimals) return amount * 10n ** BigInt(toDecimals - fromDecimals);
  return amount / 10n ** BigInt(fromDecimals - toDecimals);
}

// Anchor puts the program's #[msg] text in both err.message and err.logs — scan both.
function errorText(err: any): string {
  const logs = Array.isArray(err?.logs) ? err.logs.join(" ") : "";
  return `${err?.message ?? ""} ${logs}`;
}

// Validation errors won't succeed on retry — match the program's error messages.
function isNonRetryable(err: any): boolean {
  const msg = errorText(err);
  return [
    "Swaps are paused",
    "Token not supported",
    "Cannot swap same token",
    "Token is disabled",
    "Invalid amount",
  ].some((m) => msg.includes(m));
}

// Liquidity shortfall is not fatal — the pool is replenished over time, so we wait,
// re-read liquidity, resize the chunk, and retry rather than failing the request.
function isLiquidityShortfall(err: any): boolean {
  return errorText(err).includes("Insufficient liquidity");
}

// The blockhash expired before the tx landed — it can never execute now, so rebuilding is safe.
function isBlockhashExpired(err: any): boolean {
  return /block height exceeded|blockhash.*expired|TransactionExpired/i.test(errorText(err));
}

// Send one swap instruction SAFELY: sign once, broadcast idempotently, confirm by signature.
// Re-sending the identical signed tx cannot double-swap (same signature — the cluster dedupes).
async function sendSwapChunk(swapIx: anchor.web3.TransactionInstruction): Promise<string> {
  const { blockhash, lastValidBlockHeight } = await provider.connection.getLatestBlockhash("confirmed");
  const tx = new anchor.web3.Transaction({ feePayer: provider.wallet.publicKey, blockhash, lastValidBlockHeight }).add(swapIx);
  const signed = await provider.wallet.signTransaction(tx); // sign ONCE
  const raw = signed.serialize();

  // Broadcast (retry-safe: identical raw tx). A preflight-caught program error never landed —
  // rethrow so the caller can classify it.
  let signature = "";
  for (let attempt = 1; attempt <= 3; attempt++) {
    try {
      signature = await provider.connection.sendRawTransaction(raw, { skipPreflight: false, maxRetries: 0 });
      break;
    } catch (err: any) {
      if (isNonRetryable(err) || isLiquidityShortfall(err)) throw err;
      if (attempt >= 3) throw err;
      await new Promise((r) => setTimeout(r, 1000 * attempt));
    }
  }

  // Confirm within the blockhash window; rejects on expiry (tx definitively didn't land).
  const res = await provider.connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, "confirmed");
  if (res.value.err) {
    // Landed but failed — recover the reason from the tx logs so we can classify it.
    const parsed = await provider.connection.getTransaction(signature, { maxSupportedTransactionVersion: 0 });
    throw Object.assign(new Error(`swap ${signature} failed on-chain`), { logs: parsed?.meta?.logMessages ?? [] });
  }
  return signature;
}

async function swapLargeAmount(totalAmountIn: anchor.BN) {
  const IN_DECIMALS  = 6; // USDC
  const OUT_DECIMALS = 6; // custom token — adjust if your token uses different precision

  // Derive PDAs (USDC -> custom token direction)
  const [pool] = PublicKey.findProgramAddressSync([Buffer.from("liquidity_pool")], PROGRAM_ID);
  const [usdcVault] = PublicKey.findProgramAddressSync(
    [Buffer.from("token_vault"), pool.toBuffer(), USDC_MINT.toBuffer()], PROGRAM_ID);
  const [customTokenVault] = PublicKey.findProgramAddressSync(
    [Buffer.from("token_vault"), pool.toBuffer(), CUSTOM_TOKEN_MINT.toBuffer()], PROGRAM_ID);
  const [usdcVaultTokenAccount] = PublicKey.findProgramAddressSync(
    [Buffer.from("vault_token_account"), usdcVault.toBuffer()], PROGRAM_ID);
  const [customTokenVaultTokenAccount] = PublicKey.findProgramAddressSync(
    [Buffer.from("vault_token_account"), customTokenVault.toBuffer()], PROGRAM_ID);

  const userUsdcAccount = await getAssociatedTokenAddress(USDC_MINT, provider.wallet.publicKey);
  const userCustomTokenAccount = await getAssociatedTokenAddress(CUSTOM_TOKEN_MINT, provider.wallet.publicKey);

  const poolAccount = await (program.account as any).liquidityPool.fetch(pool);
  const feeRecipientUsdcAccount = await getAssociatedTokenAddress(USDC_MINT, poolAccount.feeRecipient);

  // Ensure the destination ATA exists once, up front
  try {
    await getAccount(provider.connection, userCustomTokenAccount);
  } catch {
    const createIx = createAssociatedTokenAccountInstruction(
      provider.wallet.publicKey, userCustomTokenAccount, provider.wallet.publicKey, CUSTOM_TOKEN_MINT);
    await provider.sendAndConfirm(new anchor.web3.Transaction().add(createIx));
  }

  const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
  const REFILL_POLL_MS = 5000; // how long to wait before re-checking liquidity

  let remaining = BigInt(totalAmountIn.toString());
  let swapCount = 0;

  while (remaining > 0n) {
    // Re-read liquidity before each chunk — it changes as others swap and as the pool refills
    const available = await getAvailableLiquidity(customTokenVaultTokenAccount);
    const availableAsInput = convertDecimals(available, OUT_DECIMALS, IN_DECIMALS);

    // Cap each chunk at a share of available liquidity so one tx never drains the pool
    // (leaves headroom for concurrent swappers). Tune CHUNK_BPS — see the tip above.
    const CHUNK_BPS = 5000n; // 50%
    const maxChunk = (availableAsInput * CHUNK_BPS) / 10000n;
    if (maxChunk === 0n) {
      // Pool is dry — wait for it to be replenished, then re-check.
      console.log(`No available liquidity; waiting ${REFILL_POLL_MS}ms for refill...`);
      await sleep(REFILL_POLL_MS);
      continue;
    }

    const chunk = remaining > maxChunk ? maxChunk : remaining;
    const swapAmount = new anchor.BN(chunk.toString());
    // Deduct the fee before applying slippage tolerance (same model as EVM). The pool's
    // fee_rate (basis points) lives on the pool account fetched above.
    const feeBps = BigInt(poolAccount.feeRate.toString());
    const fee = (chunk * feeBps + 9999n) / 10000n; // ceil(chunk * feeRate / 10000)
    const expectedOut = convertDecimals(chunk - fee, IN_DECIMALS, OUT_DECIMALS);
    const minAmountOut = new anchor.BN(((expectedOut * 9950n) / 10000n).toString()); // 0.5% tolerance

    try {
      const swapIx = await program.methods
        .swap(swapAmount, minAmountOut)
        .accounts({
          pool,
          inVault: usdcVault,
          outVault: customTokenVault,
          inVaultTokenAccount: usdcVaultTokenAccount,
          outVaultTokenAccount: customTokenVaultTokenAccount,
          userFromTokenAccount: userUsdcAccount,
          toTokenAccount: userCustomTokenAccount,
          feeRecipientTokenAccount: feeRecipientUsdcAccount,
          feeRecipient: poolAccount.feeRecipient,
          fromMint: USDC_MINT,
          toMint: CUSTOM_TOKEN_MINT,
          user: provider.wallet.publicKey,
          tokenProgram: TOKEN_PROGRAM_ID,
          associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
          systemProgram: anchor.web3.SystemProgram.programId,
        } as any)
        .instruction();

      const signature = await sendSwapChunk(swapIx);
      swapCount++;
      console.log(`Chunk ${swapCount} (${Number(chunk) / 10 ** IN_DECIMALS}) swapped: ${signature}`);
      remaining -= chunk;
      console.log(`Remaining: ${Number(remaining) / 10 ** IN_DECIMALS}`);
    } catch (err: any) {
      if (isNonRetryable(err)) throw err;        // validation error — fatal, don't wait/retry
      if (isBlockhashExpired(err)) continue;     // tx never landed — rebuild & resend (no wait)
      // Race: the pool was drained between our read and the tx landing. Not fatal —
      // wait for refill, then loop back to re-read liquidity and resize the chunk.
      if (isLiquidityShortfall(err)) {
        console.log(`Liquidity shortfall; waiting ${REFILL_POLL_MS}ms for refill...`);
        await sleep(REFILL_POLL_MS);
        continue;
      }
      throw err; // some other on-chain failure, or a transient error that couldn't confirm
    }
  }

  console.log(`Done — ${swapCount} swap(s) completed`);
}

// Example: swap 10,000 USDC for the custom token, split across available liquidity
await swapLargeAmount(new anchor.BN(10000 * 10 ** 6));