exile-sdk

pnpm add exile-sdk @solana/web3.js

import { Connection, Keypair, PublicKey } from "@solana/web3.js";
import {
  DEFAULT_LAUNCH_FEE_LAMPORTS,
  DEFAULT_LOCK_BPS,
  DEFAULT_NEW_SUPPLY,
  ExileClient,
  buildAirdropLaunchTransaction,
  deriveExilePlatformConfig,
  fetchLookupTables,
  lockedAmountFor,
  resolveAirdropVenue,
} from "exile-sdk";

const authority = Keypair.fromSecretKey(platformSecretKey); // seal base, vesting beneficiary, vault owner
const launcher = new PublicKey(launcherWallet); // fee payer and pool creator: pays rent, earns the creator fee

const mainnet = new Connection(MAINNET_RPC_URL);
const exile = new ExileClient({
  snapshotConnection: mainnet, // pump.fun lives on mainnet
  launchConnection: mainnet, // and so does Raydium LaunchLab
  authority: authority.publicKey,
  heliusApiKey: process.env.HELIUS_API_KEY,
});

// 1. Read the pump.fun coin. A coin whose seal exists was exiled before.
const coin = await exile.getPumpCoin(pumpMint);
if (await exile.isAlreadyExiled(coin.mint)) throw new Error("This coin already had its exile");

// 2. Snapshot every holder, then flag the dev, snipers, bundles and dev-linked wallets.
const snapshot = await exile.snapshot(coin.mint);
const insiders = await exile.detectInsiders(coin, snapshot);

// 3. The holders' share: their 1:1 bags, capped at 20% of the supply.
const { targetTotal } = exile.planAllocation(snapshot, insiders, { tokensAvailable: 0n });
const wanted = lockedAmountFor({
  targetTotal,
  supply: DEFAULT_NEW_SUPPLY,
  lockBps: DEFAULT_LOCK_BPS,
  maxLocked: DEFAULT_NEW_SUPPLY, // the venue's own cap applies below
});

// 4. Where it launches: StonkFun's platform once its curve rule allows a lock, else Exile's own.
const unlockPeriod = 86_400n; // linear unlock from graduation
const { venue, reason } = await resolveAirdropVenue({
  connection: mainnet,
  exilePlatformId: deriveExilePlatformConfig(authority.publicKey),
  wants: { lockedAmount: wanted, unlockPeriod },
});
if (!venue) throw new Error(reason);
const lockedAmount = wanted < venue.maxLocked ? wanted : venue.maxLocked;
const plan = exile.planAllocation(snapshot, insiders, { tokensAvailable: lockedAmount });

// 5. One v0 transaction: seal + create on LaunchLab with the lock + the holders' vesting record
//    + the launch fee (which carries the origin mint, so getSignaturesForAddress(origin) finds it).
const mint = Keypair.generate();
const launch = await buildAirdropLaunchTransaction({
  connection: mainnet,
  venue,
  launcher,
  authority: authority.publicKey,
  treasury,
  launchFeeLamports: DEFAULT_LAUNCH_FEE_LAMPORTS,
  originMint: coin.mint,
  name: coin.name,
  symbol: coin.symbol,
  uri: `https://your.app/api/meta/${mint.publicKey.toBase58()}`,
  lockedAmount,
  unlockPeriod,
  mintKeypair: mint,
  lookupTables: await fetchLookupTables(mainnet, [EXILE_LOOKUP_TABLE]),
});
launch.tx.sign([authority, mint]); // the launcher's wallet signs as fee payer and creator, then sends
console.log(`opens at ${launch.shape.startMarketCapQuote} SOL, costs at most ${launch.launcherCostLamports} lamports`);

import { addLauncherShare, DEFAULT_LAUNCHER_CUT_BPS } from "exile-sdk";

// StonkFun's exact standard curve, and what the launcher's budget buys at its very bottom.
const pricing = await exile.fetchPricing(); // validated, cached ~60s
const firstBuyLamports = 5_000_000_000n; // 5 SOL
const quote = await exile.quoteFirstBuy(pricing, firstBuyLamports);

// The launcher keeps a cut of the buy; holders split the rest pro rata, capped at 1:1.
const cut = (quote.tokensOut * BigInt(DEFAULT_LAUNCHER_CUT_BPS)) / 10_000n;
const holders = exile.planAllocation(snapshot, insiders, { tokensAvailable: quote.tokensOut - cut });
const plan = addLauncherShare(holders, launcher.toBase58(), cut); // one leaf per owner, new merkle root

// Seal + create on StonkFun + the holders' first buy into the vault + the launch fee.
const launch = await exile.buildLaunchTransaction({
  pricing,
  launcher, // fee payer, and the pool creator StonkFun forwards its creator fee to
  originMint: coin.mint,
  name: coin.name,
  symbol: coin.symbol,
  uri,
  firstBuyLamports,
  mintKeypair: mint,
});
launch.tx.sign([authority, mint]);

import { allocationLeaf, computeMerkleRoot, merkleProof, verifyMerkleProof } from "exile-sdk";

const leaves = plan.entries.map((e) => allocationLeaf(e));
computeMerkleRoot(leaves) === plan.merkleRoot; // true

const entry = plan.entries[42];
const proof = merkleProof(leaves, entry.index); // hex sibling hashes
verifyMerkleProof(allocationLeaf(entry), proof, plan.merkleRoot); // true

import {
  AIRDROP_MIGRATE_AMOUNT,
  AIRDROP_RAISE_LAMPORTS,
  DEFAULT_NEW_SUPPLY,
  airdropCurveShape,
  curveFromShape,
  lockedAmountFor,
  maxLockedAmount,
  quoteFirstBuy,
} from "exile-sdk/lite";

const supply = DEFAULT_NEW_SUPPLY;
const migrateAmount = AIRDROP_MIGRATE_AMOUNT; // 206.9M, like StonkFun: same graduation price
const raise = AIRDROP_RAISE_LAMPORTS; // 85 SOL

const maxLocked = maxLockedAmount({ supply, migrateAmount, raise }); // ~586M, LaunchLab's limit
const lockedAmount = lockedAmountFor({ targetTotal: plan.targetTotal, supply, lockBps: 2000, maxLocked });

const shape = airdropCurveShape({ supply, migrateAmount, lockedAmount, raise });
shape.totalSellA; // supply - migrateAmount - lockedAmount, sold on the curve
shape.startMarketCapQuote; // ~50 SOL at a 20% lock (StonkFun's standard opens at ~28)
shape.graduationMarketCapQuote; // ~411 SOL, whatever the lock

// Quote an optional dev buy on the fresh curve, at the venue's on-chain fee rate.
const devBuy = quoteFirstBuy(curveFromShape(shape, venue.feeRate), 1_000_000_000n);

import { budgetForTokens, curveFromPricing, curveProgressBps, quoteFirstBuy } from "exile-sdk/lite";

const feeRate = await exile.fetchFeeRate(pricing); // ppm, read once from LaunchLab + StonkFun configs
const curve = curveFromPricing(pricing, feeRate); // realA = realB = 0: the launch's opening state

const quote = quoteFirstBuy(curve, 2_000_000_000n); // 2 SOL in
quote.tokensOut; // exactly what buy_exact_in pays out, safe as its minimum out
quote.fee; // the curve fee inside the budget (1.25% on StonkFun's SOL curve, read from chain)
quote.curveProgressBps; // how much of the raise the first buy already fills

// Budget that gives every eligible holder exactly 1:1 (what the wizard offers as "full bags")
const fullBags = budgetForTokens(curve, plan.targetTotal);

curveProgressBps(state.realB, state.totalFundRaisingB); // 0..10000

import { checkLaunchAgainstCurveRule, decodePlatformCurveRule, derivePlatformCurveRule, findAirdropShape } from "exile-sdk";

// StonkFun pins every curve with an on-chain rule: groups are OR'ed, constraints within a group AND'ed.
const info = await connection.getAccountInfo(derivePlatformCurveRule(stonkfunPlatform, configId));
const rule = decodePlatformCurveRule(info!.data);

checkLaunchAgainstCurveRule(rule, launchShape); // { ok, groupId?, unsatisfied }

// The airdrop shape the rule accepts with the biggest lock, or null while StonkFun allows none.
const found = findAirdropShape(rule, { supply, raise, lockedAmount, unlockPeriod: 86_400n });
if (found) console.log(`StonkFun group ${found.groupId} accepts a lock of ${found.shape.totalLockedAmount}`);

import { buildExileLookupTableTxs } from "exile-sdk";

// Once per operator: the launch-invariant accounts go into one address lookup table.
const { txs } = await buildExileLookupTableTxs({ connection, authority: authority.publicKey, pricing, treasury });
for (const tx of txs) {
  tx.sign(authority);
  await connection.sendRawTransaction(tx.serialize()); // in order; usable from the next slot
}

// One getMultipleAccountsInfo for the whole board.
const states = await exile.fetchCurveStates(pools);
for (const s of states) {
  if (!s) continue; // not created yet, or not a LaunchLab pool
  console.log(s.mint, s.status, s.progressBps / 100, "%", s.marketCapQuote, "SOL");
  if (s.status === "graduated") console.log("Raydium CPMM pool", s.cpmmPool);
}

const trades = await exile.fetchRecentTrades(pool, 50); // newest first

import { vestedAmount, vestedBps, vestingWindow } from "exile-sdk/lite";

const window = vestingWindow({
  launchedAt, // unix seconds
  graduatedAt, // null while the coin is still on its curve
  durationSeconds: 86_400, // linear unlock after graduation
  fallbackUnlockSeconds: 604_800, // vesting starts anyway 7 days after launch
});

const now = Math.floor(Date.now() / 1000);
vestedBps(window, now); // share of every bag unlocked right now
const claimable = vestedAmount(entry.amount, window, now) - alreadyClaimed;

import { launchLabVestedAmount } from "exile-sdk/lite";

// Airdrop mode runs on LaunchLab's own clock: it starts at the buy that completes the curve,
// and nothing unlocks before the pool migrates. No fallback.
const state = await exile.fetchCurveState(pool);
const vested = launchLabVestedAmount({
  share: entry.amount,
  startTime: Number(state.vesting.startTime),
  unlockPeriod: Number(state.vesting.unlockPeriod),
  now: Math.floor(Date.now() / 1000),
  migrated: state.migrated,
});

import { checkVamp, deriveExileSeal, deriveExileSeed, fingerprintCoin, isAlreadyExiled } from "exile-sdk";

deriveExileSeed(originMint); // 32 chars, identical on every call
const seal = await deriveExileSeal(authority, originMint); // createWithSeed(authority, seed, SystemProgram)
await isAlreadyExiled(connection, authority, originMint); // true once a launch created the seal

// registry: RegistryEntry[] for every existing relaunch
const result = checkVamp(fingerprintCoin({ originMint, name: "PR0JECT K1MCH1", symbol: "$K1MCH1" }), registry);
if (!result.ok) {
  for (const m of result.matches) console.log(m.kind, m.existing.symbol, m.detail);
}

import { PublicKey } from "@solana/web3.js";
import { buildClaimTransaction, claimMemo, findSignatureByMemo } from "exile-sdk";

export async function prepareClaim(claimant: PublicKey, amount: bigint, nonce: string) {
  // amount: what has vested and is still unclaimed; partial claims are fine
  const memo = claimMemo(mint.toBase58(), claimant.toBase58(), nonce);

  // A landed claim is findable by its memo, so a retry never pays out twice.
  const landed = await findSignatureByMemo(connection, claimant, memo);
  if (landed) return { landed };

  const { tx, lastValidBlockHeight } = await buildClaimTransaction({
    connection,
    authority: authority.publicKey,
    mint,
    claimant,
    amount,
    decimals,
    memo,
    // Airdrop mode: pull newly vested tokens from LaunchLab into the vault first (claim_vested_token).
    pullVestedFrom: newlyVested ? pool : undefined,
  });
  tx.partialSign(authority); // the holder's wallet signs as fee payer and sends
  return { tx: tx.serialize({ requireAllSignatures: false }).toString("base64"), lastValidBlockHeight };
}

import { Transaction } from "@solana/web3.js";
import { NATIVE_MINT, createCloseAccountInstruction, getAssociatedTokenAddressSync } from "@solana/spl-token";
import { claimCreatorFeeInstruction, fetchCreatorFeeClaimable } from "exile-sdk";

// LaunchLab keeps one creator fee vault per (creator, quote mint): one claim covers every coin.
const claimable = await fetchCreatorFeeClaimable(connection, launcher); // lamports
if (claimable > 0n) {
  const wsol = getAssociatedTokenAddressSync(NATIVE_MINT, launcher);
  const tx = new Transaction().add(
    claimCreatorFeeInstruction({ creator: launcher }), // vault -> the launcher's WSOL account, created if missing
    createCloseAccountInstruction(wsol, launcher, launcher), // unwrap to SOL
  );
  // The launcher's wallet is the fee payer and the only signer.
}

import { isExileError } from "exile-sdk";

try {
  await exile.fetchPricing();
} catch (e) {
  if (isExileError(e) && e.code === "STONKFUN_API") {
    // StonkFun is down or answered something a launch can't rely on: don't launch now
  } else {
    throw e;
  }
}