Quickstart

npm install @solana/web3.js tweetnacl

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

const VANISH_URL  = 'https://core-api.vanish.trade';
const connection  = new Connection(process.env.SOLANA_RPC_URL!);
const userKeypair = Keypair.fromSecretKey(
  Uint8Array.from(JSON.parse(process.env.SOLANA_KEYPAIR!))
);

async function vanish(path: string, options?: RequestInit) {
  const res = await fetch(`${VANISH_URL}${path}`, {
    ...options,
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': process.env.VANISH_API_KEY!,
      ...options?.headers,
    },
  });
  if (!res.ok) {
    throw new Error(`Vanish ${res.status}: ${await res.text()}`);
  }
  return res.json();
}

import * as nacl from 'tweetnacl';
import { Keypair } from '@solana/web3.js';

function signMessage(message: string, keypair: Keypair): string {
  const sig = nacl.sign.detached(new TextEncoder().encode(message), keypair.secretKey);
  return Buffer.from(sig).toString('base64');
}

// timestamp must be Date.now().toString() — milliseconds, not seconds
function readSignature(timestamp: string, keypair: Keypair): string {
  return signMessage(
    `By signing, I hereby agree to Vanish's Terms of Service and agree to be bound by them (docs.vanish.trade/legal/TOS)\n\nDetails: read:${timestamp}`,
    keypair
  );
}

// all args must match exactly what you pass to /trade/create
function tradeSignature(
  source: string, target: string, amount: string,
  loanSol: string, timestamp: string, jitoTip: string,
  keypair: Keypair
): string {
  return signMessage(
    `By signing, I hereby agree to Vanish's Terms of Service and agree to be bound by them (docs.vanish.trade/legal/TOS)\n\nDetails: trade:${source}:${target}:${amount}:${loanSol}:${timestamp}:${jitoTip}`,
    keypair
  );
}

const SOL_MINT  = '11111111111111111111111111111111';
const LOAN_SOL  = '12000000'; // recommended loan_additional_sol — unused amount is refunded
const JITO_TIP  = '1000000';  // 0.001 SOL — minimum recommended tip

const timestamp     = Date.now().toString();
const userSignature = tradeSignature(
  SOL_MINT, TARGET_MINT, AMOUNT,
  LOAN_SOL, timestamp, JITO_TIP,
  userKeypair
);

const trade = await vanish('/trade/create', {
  method: 'POST',
  body: JSON.stringify({
    user_address:         userKeypair.publicKey.toBase58(),
    source_token_address: SOL_MINT,
    target_token_address: TARGET_MINT,
    amount:               AMOUNT,
    swap_transaction:     swapTransaction,  // base64-encoded unsigned tx from your aggregator
    one_time_wallet:      oneTimeWallet,
    loan_additional_sol:  LOAN_SOL,
    jito_tip_amount:      JITO_TIP,
    split_repay:          1,
    timestamp,
    user_signature:       userSignature,
    // omit prefer_non_jito to route via Jito (default)
  }),
});

console.log('Trade submitted. tx_id:', trade.tx_id);

const commit = await vanish('/commit', {
  method: 'POST',
  body: JSON.stringify({ tx_id: trade.tx_id }),
});

console.log('Status:', commit.status);
console.log('Balance changes:', commit.balance_changes);

import { VersionedTransaction } from '@solana/web3.js';

// trade.transaction is the fully signed tx returned by Vanish — broadcast it yourself
const txBytes = Buffer.from(trade.transaction, 'base64');
const tx      = VersionedTransaction.deserialize(txBytes);
const txId    = await connection.sendRawTransaction(tx.serialize(), {
  skipPreflight: false, // simulate on RPC before submitting — catches obvious failures early
  maxRetries:    3,
});
await connection.confirmTransaction(txId, 'confirmed');

// Then commit as normal using txId
const commit = await vanish('/commit', {
  method: 'POST',
  body: JSON.stringify({ tx_id: txId }),
});

const timestamp = Date.now().toString();
const signature = readSignature(timestamp, userKeypair);

const balances = await vanish('/account/balances', {
  method: 'POST',
  body: JSON.stringify({
    user_address: userKeypair.publicKey.toBase58(),
    timestamp,
    signature,
  }),
});

// [{ token_address, balance, program_id }, ...]
// balance is in lamports for SOL, base units for SPL tokens
console.log(balances);

async function recoverPendingCommits(userKeypair: Keypair) {
  const timestamp = Date.now().toString();
  const signature = readSignature(timestamp, userKeypair);

  const pending = await vanish('/account/pending', {
    method: 'POST',
    body: JSON.stringify({
      user_address: userKeypair.publicKey.toBase58(),
      timestamp,
      signature,
    }),
  });

  for (const action of pending) {
    const commit = await vanish('/commit', {
      method: 'POST',
      body: JSON.stringify({ tx_id: action.tx_id }),
    });
    if (!commit.already_processed) {
      console.log(`Resolved ${action.action_type}:`, commit.status);
    }
  }
}