Launch a pool

Use Vertigo SDK v2 to launch a liquidity pool

Recommended Approach: For most use cases, use the Factory Client which provides launchTokenWithPool() to create both a token and pool in one operation. Direct pool creation is for advanced users who already have a token mint.

Overview

The SDK v2 provides simplified pool creation:

createPool() - Create a liquidity pool for an existing token
launchTokenWithPool() - Create token and pool together (recommended, see Token Factories)

When to use direct pool creation

Use createPool() when:

You already have an existing token that you want to create a pool for
You need advanced control over pool parameters
You're integrating Vertigo pools into an existing token ecosystem

For new token launches, use launchTokenWithPool() from the Factory Client instead.

Prerequisites

An existing token mint (mintB) that you want to create a pool for
Sufficient SOL to pay for transaction fees and rent
A wallet configured with the SDK

Parameters

For createPool():

mintA - Base token (usually NATIVE_MINT for SOL)
mintB - The token you want to create a pool for
initialMarketCap - Starting market cap in lamports (for SOL)
royaltiesBps - Trading fee in basis points (e.g., 250 = 2.5%)
launchTime - (Optional) Unix timestamp for scheduled launch
privilegedSwapper - (Optional) Address that can swap without fees

Example: Create a pool for an existing 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",
  });

  // Your existing token mint
  const tokenMint = new PublicKey("<your-token-mint-address>");

  // Create a pool for your token
  const { signature, poolAddress } = await vertigo.pools.createPool({
    mintA: NATIVE_MINT, // SOL as base token
    mintB: tokenMint,   // Your token
    initialMarketCap: 50 * LAMPORTS_PER_SOL, // 50 SOL initial market cap
    royaltiesBps: 250, // 2.5% trading fees
  });

  console.log(`Pool created: ${poolAddress.toBase58()}`);
  console.log(`Transaction: ${signature}`);
}

main();

Example: Create pool with scheduled launch

Launch the pool at a specific time:

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 tokenMint = new PublicKey("<your-token-mint-address>");

  // Launch 24 hours from now
  const launchTime = new anchor.BN(Math.floor(Date.now() / 1000) + 86400);

  const { signature, poolAddress } = await vertigo.pools.createPool({
    mintA: NATIVE_MINT,
    mintB: tokenMint,
    initialMarketCap: 100 * LAMPORTS_PER_SOL,
    royaltiesBps: 100, // 1% fees
    launchTime, // Scheduled launch time
  });

  console.log(`Pool created: ${poolAddress.toBase58()}`);
  console.log(`Launch time: ${new Date(launchTime.toNumber() * 1000)}`);
  console.log(`Transaction: ${signature}`);
}

main();

Example: Create pool with privileged swapper

Allow a specific address to swap without fees:

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 tokenMint = new PublicKey("<your-token-mint-address>");
  const privilegedAddress = new PublicKey("<address-for-fee-free-swaps>");

  const { signature, poolAddress } = await vertigo.pools.createPool({
    mintA: NATIVE_MINT,
    mintB: tokenMint,
    initialMarketCap: 50 * LAMPORTS_PER_SOL,
    royaltiesBps: 250,
    privilegedSwapper: privilegedAddress, // This address pays no fees
  });

  console.log(`Pool created: ${poolAddress.toBase58()}`);
  console.log(`Privileged swapper: ${privilegedAddress.toBase58()}`);
  console.log(`Transaction: ${signature}`);
}

main();

Recommended: Use Factory Client Instead

For most use cases, it's better to use the Factory Client's launchTokenWithPool():

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

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

  // This creates BOTH the token AND the pool
  const result = await vertigo.factory.launchTokenWithPool({
    metadata: {
      name: "My Token",
      symbol: "MTK",
      decimals: 9,
      uri: "https://example.com/metadata.json",
    },
    supply: 1_000_000_000, // 1 billion tokens
    initialMarketCap: 50 * LAMPORTS_PER_SOL, // 50 SOL
    royaltiesBps: 250, // 2.5% fees
  });

  console.log(`Token created: ${result.mintAddress.toBase58()}`);
  console.log(`Pool created: ${result.poolAddress.toBase58()}`);
  console.log(`Token tx: ${result.tokenSignature}`);
  console.log(`Pool tx: ${result.poolSignature}`);
}

main();

See Token Factories for complete documentation.

Migration from v1

v1 (Old) - Complex setup required

import { VertigoSDK } from "@vertigo-amm/vertigo-sdk";
import * as anchor from "@coral-xyz/anchor";

// Manual setup of all components
const provider = new anchor.AnchorProvider(connection, wallet);
const vertigo = new VertigoSDK(provider);

const owner = Keypair.generate();
const tokenWalletAuthority = Keypair.generate();
const mintAuthority = Keypair.generate();

// Create mint manually
const mintB = await createMint(/* ... many parameters ... */);

// Create token wallet manually
const tokenWallet = await createAssociatedTokenAccount(/* ... */);

// Mint tokens manually
await mintTo(/* ... */);

// Finally launch pool
const { deploySignature, poolAddress } = await vertigo.launchPool({
  params: {
    shift: new anchor.BN(LAMPORTS_PER_SOL * 100),
    initialTokenBReserves: new anchor.BN(1_000_000_000),
    feeParams: {
      normalizationPeriod: new anchor.BN(20),
      decay: 10,
      royaltiesBps: 100,
      reference: new anchor.BN(0),
      privilegedSwapper: null,
    },
  },
  payer: owner,
  owner,
  tokenWalletAuthority,
  tokenWalletB: tokenWallet,
  mintA: NATIVE_MINT,
  mintB,
  tokenProgramA: TOKEN_PROGRAM_ID,
  tokenProgramB: TOKEN_2022_PROGRAM_ID,
});

v2 (New) - Simple and clean

import { Vertigo } from "@vertigo-amm/vertigo-sdk";

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

// Create pool for existing token (simple)
const { signature, poolAddress } = await vertigo.pools.createPool({
  mintA: NATIVE_MINT,
  mintB: existingTokenMint,
  initialMarketCap: 50 * LAMPORTS_PER_SOL,
  royaltiesBps: 250,
});

// Or launch token + pool (even simpler)
const result = await vertigo.factory.launchTokenWithPool({
  metadata: { name: "My Token", symbol: "MTK" },
  supply: 1_000_000_000,
  initialMarketCap: 50 * LAMPORTS_PER_SOL,
  royaltiesBps: 250,
});

Key Improvements in v2

Simplified interface - No need to manage owners, authorities, or token wallets
Automatic setup - SDK handles all account creation and initialization
Unified token programs - Automatically detects SPL vs Token-2022
Better defaults - Sensible defaults for all optional parameters
Type safety - Full TypeScript support with helpful IntelliSense
Error handling - Clear, actionable error messages

Understanding Pool Parameters

initialMarketCap: The starting "virtual" SOL value backing the pool. A higher market cap means a higher starting price for the token.
royaltiesBps: Trading fee percentage in basis points (100 bps = 1%). These fees accumulate for the pool owner.
launchTime: Unix timestamp when trading becomes active. Swaps before this time will fail.
privilegedSwapper: An address that can swap without paying fees (useful for initial liquidity or market makers).

Tips

Always test on devnet before deploying to mainnet
Consider your initial market cap carefully - it determines the starting price
Trading fees typically range from 0.5% to 5% (50-500 bps)
Use privilegedSwapper for your initial liquidity provision to avoid fees
The SDK automatically handles all token account creation and rent
For new tokens, use launchTokenWithPool() instead of manual pool creation

Error Handling

try {
  const { signature, poolAddress } = await vertigo.pools.createPool({
    mintA: NATIVE_MINT,
    mintB: tokenMint,
    initialMarketCap: 50 * LAMPORTS_PER_SOL,
    royaltiesBps: 250,
  });
  console.log(`Success: ${poolAddress.toBase58()}`);
} catch (error) {
  if (error.message.includes("Wallet not connected")) {
    console.error("Please connect a wallet first");
  } else if (error.message.includes("Insufficient funds")) {
    console.error("Not enough SOL to create the pool");
  } else {
    console.error(`Pool creation failed: ${error.message}`);
  }
}

Token Factories - Recommended way to launch tokens with pools
Swap Tokens - Trading in your pool
Claim Royalty Fees - Collecting accumulated fees
Getting Started - SDK initialization

PreviousDesigning Token Factories NextCoingecko

Last updated 1 month ago

Overview

When to use direct pool creation

Prerequisites

Parameters

Example: Create a pool for an existing token

Example: Create pool with scheduled launch

Example: Create pool with privileged swapper

Recommended: Use Factory Client Instead

Migration from v1

v1 (Old) - Complex setup required

v2 (New) - Simple and clean

Key Improvements in v2

Understanding Pool Parameters

Tips

Error Handling

Related Documentation