Swap Tokens

How to swap tokens using Vertigo pools

Overview

The SDK v2 provides a unified swap interface that automatically detects whether you're buying or selling:

swap() - Execute token swaps in one function call
getQuote() - Get swap quotes with slippage calculation
simulateSwap() - Simulate swaps before executing
buildSwapTransaction() - Build swap transactions manually for advanced use cases

When to use each method

swap() is the simplest approach and recommended for most use cases
getQuote() should be called before swapping to show users expected output
simulateSwap() is useful for testing and error checking
buildSwapTransaction() is for advanced users who need full control over transaction building

Prerequisites

The input token account must have sufficient balance
You must have a wallet configured (use Vertigo.load() instead of Vertigo.loadReadOnly())

Parameters

For getQuote():

inputMint - The public key of the input token
outputMint - The public key of the output token
amount - The amount of input tokens to swap (in base units)
slippageBps - (Optional) Slippage tolerance in basis points (default: 50 = 0.5%)

For swap():

inputMint - The public key of the input token
outputMint - The public key of the output token
amount - The amount of input tokens to swap (in base units)
options - (Optional) Configuration object:
- slippageBps - Slippage tolerance in basis points (default: 50 = 0.5%)
- priorityFee - Priority fee: "auto" for automatic calculation, or a specific number in micro-lamports
- wrapSol - Auto-wrap SOL if needed (default: true)
- simulateFirst - Simulate before executing (default: true)

Example: Basic swap with quote

This example shows how to get a quote and execute a swap from SOL to a custom token.

import { Vertigo } from "@vertigo-amm/vertigo-sdk";
import { Connection, LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";
import * as anchor from "@coral-xyz/anchor";
import { NATIVE_MINT } from "@solana/spl-token";

async function main() {
  // Connect to Solana
  const connection = new Connection("https://api.devnet.solana.com", "confirmed");

  // Load wallet
  const walletKeypair = anchor.Wallet.local();

  // Initialize Vertigo SDK
  const vertigo = await Vertigo.load({
    connection,
    wallet: walletKeypair,
    network: "devnet",
  });

  // Define the swap
  const inputMint = NATIVE_MINT; // SOL
  const outputMint = new PublicKey("<token-mint-address>");
  const amount = LAMPORTS_PER_SOL; // 1 SOL

  // Get a quote first
  const quote = await vertigo.swap.getQuote({
    inputMint,
    outputMint,
    amount,
    slippageBps: 50, // 0.5% slippage tolerance
  });

  console.log("Quote:");
  console.log(`  Input: ${quote.inputAmount} (${amount / LAMPORTS_PER_SOL} SOL)`);
  console.log(`  Expected output: ${quote.outputAmount}`);
  console.log(`  Minimum received: ${quote.minimumReceived}`);
  console.log(`  Price impact: ${quote.priceImpact}%`);

  // Execute the swap
  const result = await vertigo.swap.swap({
    inputMint,
    outputMint,
    amount,
    options: {
      slippageBps: 100, // 1% slippage for execution
      priorityFee: "auto", // Automatically calculate priority fee
      wrapSol: true, // Auto-wrap SOL if needed
    },
  });

  console.log(`Swap successful!`);
  console.log(`  Signature: ${result.signature}`);
  console.log(`  Input amount: ${result.inputAmount}`);
  console.log(`  Output amount: ${result.outputAmount}`);
}

main();

Example: Selling tokens back to SOL

The same swap() method works in reverse - just swap the input and output mints:

import { Vertigo } from "@vertigo-amm/vertigo-sdk";
import { Connection, PublicKey } from "@solana/web3.js";
import * as anchor from "@coral-xyz/anchor";
import { NATIVE_MINT } from "@solana/spl-token";

async function main() {
  const connection = new Connection("https://api.devnet.solana.com", "confirmed");
  const walletKeypair = anchor.Wallet.local();

  const vertigo = await Vertigo.load({
    connection,
    wallet: walletKeypair,
    network: "devnet",
  });

  const tokenMint = new PublicKey("<token-mint-address>");
  const DECIMALS = 6;
  
  // Sell 100,000 tokens
  const sellAmount = 100_000 * (10 ** DECIMALS);

  // Get quote
  const quote = await vertigo.swap.getQuote({
    inputMint: tokenMint,     // Selling tokens
    outputMint: NATIVE_MINT,  // For SOL
    amount: sellAmount,
    slippageBps: 50,
  });

  console.log(`Selling ${100_000} tokens for ~${quote.outputAmount / 1e9} SOL`);

  // Execute the swap
  const result = await vertigo.swap.swap({
    inputMint: tokenMint,
    outputMint: NATIVE_MINT,
    amount: sellAmount,
    options: {
      slippageBps: 100,
      priorityFee: "auto",
    },
  });

  console.log(`Sold tokens for ${result.outputAmount / 1e9} SOL`);
  console.log(`Transaction: ${result.signature}`);
}

main();

Example: Simulating a swap

Use simulateSwap() to test a swap before executing:

import { Vertigo } from "@vertigo-amm/vertigo-sdk";
import { Connection, LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";
import * as anchor from "@coral-xyz/anchor";
import { NATIVE_MINT } from "@solana/spl-token";

async function main() {
  const connection = new Connection("https://api.devnet.solana.com", "confirmed");
  const walletKeypair = anchor.Wallet.local();

  const vertigo = await Vertigo.load({
    connection,
    wallet: walletKeypair,
    network: "devnet",
  });

  const inputMint = NATIVE_MINT;
  const outputMint = new PublicKey("<token-mint-address>");
  const amount = LAMPORTS_PER_SOL;

  // Simulate first
  const simulation = await vertigo.swap.simulateSwap({
    inputMint,
    outputMint,
    amount,
    options: { slippageBps: 100 },
  });

  if (simulation.success) {
    console.log("Simulation successful!");
    console.log(`Expected output: ${simulation.outputAmount}`);
    
    // Proceed with actual swap
    const result = await vertigo.swap.swap({
      inputMint,
      outputMint,
      amount,
      options: { slippageBps: 100 },
    });
    
    console.log(`Swap completed: ${result.signature}`);
  } else {
    console.error(`Simulation failed: ${simulation.error}`);
  }
}

main();

Example: Advanced usage with buildSwapTransaction()

For advanced users who need full control over transaction building:

import { Vertigo } from "@vertigo-amm/vertigo-sdk";
import { Connection, LAMPORTS_PER_SOL, PublicKey, Transaction } from "@solana/web3.js";
import * as anchor from "@coral-xyz/anchor";
import { NATIVE_MINT } from "@solana/spl-token";

async function main() {
  const connection = new Connection("https://api.devnet.solana.com", "confirmed");
  const walletKeypair = anchor.Wallet.local();

  const vertigo = await Vertigo.load({
    connection,
    wallet: walletKeypair,
    network: "devnet",
  });

  // Get a quote first
  const quote = await vertigo.swap.getQuote({
    inputMint: NATIVE_MINT,
    outputMint: new PublicKey("<token-mint-address>"),
    amount: LAMPORTS_PER_SOL,
    slippageBps: 50,
  });

  // Build the transaction manually
  const swapTx = await vertigo.swap.buildSwapTransaction(quote, {
    priorityFee: "auto",
    computeUnits: 200_000,
  });

  // You can now add more instructions to the transaction
  // or modify it as needed before sending
  
  // Sign and send
  const signature = await connection.sendTransaction(swapTx, [walletKeypair.payer]);
  await connection.confirmTransaction(signature, "confirmed");

  console.log(`Transaction: ${signature}`);
}

main();

Error Handling

The SDK provides detailed error messages:

try {
  const result = await vertigo.swap.swap({
    inputMint,
    outputMint,
    amount,
    options: { slippageBps: 50 },
  });
  console.log(`Success: ${result.signature}`);
} catch (error) {
  if (error.code === "SLIPPAGE_EXCEEDED") {
    console.error("Price moved too much. Try increasing slippage tolerance.");
  } else if (error.code === "INSUFFICIENT_FUNDS") {
    console.error("Not enough tokens in your account.");
  } else if (error.code === "POOL_NOT_FOUND") {
    console.error("No pool exists for this token pair.");
  } else {
    console.error(`Swap failed: ${error.message}`);
  }
}

Tips

Always get a quote before swapping to show users expected output
Use appropriate slippage tolerance (50-100 bps for normal conditions, higher for volatile tokens)
Set priorityFee: "auto" to ensure your transaction gets processed quickly
Use simulateSwap() when testing or for important transactions
The SDK automatically handles token account creation and SOL wrapping

PreviousMigration Guide (v1 → v2)NextSell Tokens (Legacy)

Last updated 1 month ago