How to Swap Tokens with Custom Logic Using Metis

import { Connection, Keypair, VersionedTransaction } from '@solana/web3.js';
import fs from 'fs';

const API_KEY = 'YOUR_API_KEY';
const RPC_ENDPOINT = 'YOUR_RPC_ENDPOINT';
const API_BASE = 'https://api.jup.ag/swap/v1';

const wallet = Keypair.fromSecretKey(
  new Uint8Array(JSON.parse(fs.readFileSync('wallet.json', 'utf8')))
);
const connection = new Connection(RPC_ENDPOINT);

async function swap(inputMint, outputMint, amount, slippageBps) {
  // Get quote
  const quoteResponse = await (
    await fetch(
      `${API_BASE}/quote?` + new URLSearchParams({
        inputMint, outputMint, amount, slippageBps: slippageBps.toString(), instructionVersion: 'V2',
      }),
      { headers: { 'x-api-key': API_KEY } }
    )
  ).json();

  if (quoteResponse.error) throw new Error(`Quote failed: ${quoteResponse.error}`);

  console.log(JSON.stringify(quoteResponse, null, 2));
  console.log(`${quoteResponse.inputMint}: ${quoteResponse.inAmount}`);
  console.log(`${quoteResponse.outputMint}: ${quoteResponse.outAmount}`);
  console.log(`Price impact: ${(Number(quoteResponse.priceImpactPct) * 100).toFixed(4)}%`);

  // Build transaction
  const swapResponse = await (
    await fetch(`${API_BASE}/swap`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'x-api-key': API_KEY },
      body: JSON.stringify({
        quoteResponse,
        userPublicKey: wallet.publicKey.toString(),
        wrapAndUnwrapSol: true,
        dynamicComputeUnitLimit: true,
        prioritizationFeeLamports: {
          priorityLevelWithMaxLamports: { priorityLevel: 'veryHigh', maxLamports: 1000000 },
        },
      }),
    })
  ).json();

  if (swapResponse.error) throw new Error(`Swap failed: ${swapResponse.error}`);

  // Sign and send
  const transaction = VersionedTransaction.deserialize(
    Buffer.from(swapResponse.swapTransaction, 'base64')
  );
  transaction.sign([wallet]);

  const signature = await connection.sendRawTransaction(transaction.serialize(), {
    maxRetries: 0,
    skipPreflight: true,
  });

  console.log(`Sent: https://solscan.io/tx/${signature}`);

  const confirmation = await connection.confirmTransaction({ signature }, 'finalized');
  if (confirmation.value.err) throw new Error(`Failed: ${JSON.stringify(confirmation.value.err)}`);

  console.log('Swap confirmed.');
  return signature;
}

// Swap 1 SOL → USDC
swap(
  'So11111111111111111111111111111111111111112',
  'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
  '100000000',
  50
).catch(console.error);

async function swap(inputMint, outputMint, amount, slippageBps) {
  const quoteUrl = `https://api.jup.ag/swap/v1/quote?` + new URLSearchParams({
    inputMint, outputMint, amount, slippageBps: slippageBps.toString(), instructionVersion: 'V2',
  });

  // 1. Quote
  const quoteResponse = await (await fetch(quoteUrl, {
    headers: { 'x-api-key': 'YOUR_API_KEY' },
  })).json();

  console.log('Quote:', { url: quoteUrl, response: quoteResponse });

  if (quoteResponse.error) {
    throw new Error(`Quote failed: ${quoteResponse.error}`);
  }

  // 2. Build transaction
  const swapPayload = {
    quoteResponse,
    userPublicKey: wallet.publicKey.toString(),
    dynamicComputeUnitLimit: true,
    prioritizationFeeLamports: {
      priorityLevelWithMaxLamports: { priorityLevel: 'veryHigh', maxLamports: 1000000 },
    },
  };

  const swapResponse = await (await fetch('https://api.jup.ag/swap/v1/swap', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': 'YOUR_API_KEY' },
    body: JSON.stringify(swapPayload),
  })).json();

  console.log('Swap:', { payload: swapPayload, response: swapResponse });

  if (swapResponse.error) {
    throw new Error(`Swap build failed: ${swapResponse.error}`);
  }

  // 3. Sign and send -- always submit on-chain rather than simulating locally.
  //    On-chain transactions are logged by block explorers, which capture account
  //    state and make debugging far easier than a local simulation error.
  const transaction = VersionedTransaction.deserialize(
    Buffer.from(swapResponse.swapTransaction, 'base64')
  );
  transaction.sign([wallet]);

  const signature = await connection.sendRawTransaction(transaction.serialize(), {
    maxRetries: 0,
    skipPreflight: true,
  });

  console.log('Sent:', {
    signature,
    explorer: `https://solscan.io/tx/${signature}`,
  });

  const confirmation = await connection.confirmTransaction({ signature }, 'finalized');

  if (confirmation.value.err) {
    // Log everything needed to debug a failed on-chain transaction
    console.error('Transaction failed on-chain:', {
      signature,
      error: confirmation.value.err,
      quoteUrl,
      quoteResponse,
      swapTransaction: swapResponse.swapTransaction,
    });
    throw new Error(`Transaction failed: ${JSON.stringify(confirmation.value.err)}`);
  }

  console.log('Swap confirmed:', signature);
  return signature;
}