Documentation

// Launch a new token (v1.36 createV2AndBuyInstructions)
const mint   = Keypair.generate();
const global = await pumpOnline.fetchGlobal();
const solBn  = new BN(Math.floor(devBuySol * 1e9));

const amount = getBuyTokenAmountFromSolAmount({
  global, feeConfig: null, mintSupply: null,
  bondingCurve: null, amount: solBn, quoteMint: NATIVE_MINT,
});

const ix = await pumpOffline.createV2AndBuyInstructions({
  global, mint: mint.publicKey,
  name, symbol, uri,            // uri = uploaded metadata
  creator: user, user,
  amount, solAmount: solBn,
  mayhemMode: false,
});

// user signs in the browser, mint keypair co-signs
await sendTransaction(new Transaction().add(...ix), connection, { signers: [mint] });

import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";
import { TOKEN_2022_PROGRAM_ID, createBurnInstruction } from "@solana/spl-token";
import { OnlinePumpSdk, PumpSdk, getBuyTokenAmountFromSolAmount } from "@pump-fun/pump-sdk";
import { OnlinePumpAmmSdk, PumpAmmSdk, canonicalPumpPoolPda } from "@pump-fun/pump-swap-sdk";
import BN from "bn.js";
import bs58 from "bs58";

const connection   = new Connection(process.env.RPC_URL, "confirmed");
const agent        = Keypair.fromSecretKey(bs58.decode(process.env.AGENT_PRIVATE_KEY));
const mint         = new PublicKey(process.env.MINT_ADDRESS);

const pumpOnline     = new OnlinePumpSdk(connection);
const pumpOffline    = new PumpSdk();
const pumpAmmOnline  = new OnlinePumpAmmSdk(connection);
const pumpAmmOffline = new PumpAmmSdk();

// check vault balance across both programs
const lamports = await pumpOnline
  .getCreatorVaultBalanceBothPrograms(agent.publicKey);

if (lamports.toNumber() / LAMPORTS_PER_SOL < 0.05) return; // wait

// claim all accumulated creator fees
const solBefore = await connection.getBalance(agent.publicKey);

const claimIx = await pumpOnline
  .collectCoinCreatorFeeInstructions(agent.publicKey, agent.publicKey);

await sendAndConfirm(connection, new Transaction().add(...claimIx), agent);

const solAfter = await connection.getBalance(agent.publicKey);
const claimed  = (solAfter - solBefore) / LAMPORTS_PER_SOL;

// fetch on-chain bonding curve state
const global = await pumpOnline.fetchGlobal();
const { bondingCurveAccountInfo, bondingCurve, associatedUserAccountInfo } =
  await pumpOnline.fetchBuyState(mint, agent.publicKey, TOKEN_2022_PROGRAM_ID);

// calculate how many tokens we get for our SOL (v1.36, quoteMint required)
const solBn  = new BN(Math.floor(solAmount * 1e9));
const amount = getBuyTokenAmountFromSolAmount({
  global,
  feeConfig: null,
  mintSupply: bondingCurve.tokenTotalSupply,
  bondingCurve,
  amount: solBn,
  quoteMint: NATIVE_MINT,
});

// execute buy through bonding curve program (pre-migration)
const buyIx = await pumpOffline.buyInstructions({
  global, bondingCurveAccountInfo, bondingCurve, associatedUserAccountInfo,
  mint, user: agent.publicKey, solAmount: solBn, amount,
  slippage: 2, tokenProgram: TOKEN_2022_PROGRAM_ID,
});

await sendAndConfirm(connection, new Transaction().add(...buyIx), agent);

// Post-migration: buy on the AMM, then burn (no LP, supply only shrinks)
const poolKey   = canonicalPumpPoolPda(mint);
const swapState = await pumpAmmOnline.swapSolanaState(poolKey, agent.publicKey);
const buyIx     = await pumpAmmOffline.buyQuoteInput(swapState, solBn, 5);
await sendAndConfirm(connection, new Transaction().add(...buyIx), agent);

await new Promise(r => setTimeout(r, 4000));

// then burn the whole token balance (see "Burn" section)
await burnAll(mint);

// After buying, the agent holds the freshly-bought tokens in its ATA.
// Burn 100% of them. Straight to zero, permanently off the supply.
const ata = getAgentTokenAta(agent.publicKey, mint);
const balance = await getTokenBalance(connection, ata); // bigint

if (balance > 0n) {
  const burnIx = createBurnInstruction(
    ata,                    // token account to burn from
    mint,                   // mint
    agent.publicKey,        // owner / authority
    balance,                // burn everything
    [],
    TOKEN_2022_PROGRAM_ID,
  );

  const sig = await sendAndConfirm(connection, new Transaction().add(burnIx), agent);
  console.log(`Burned ${balance} tokens, tx: ${sig}`);
}

while (true) {
  const vault = await checkVaultBalance();
  if (vault < 0.05) { await sleep(60_000); continue; }

  await claimFees();
  const migrated = await isTokenMigrated();

  if (!migrated) await doBuyback(claimed);  // bonding curve buy
  else           await doAmmBuy(claimed);    // AMM buy

  await burnAll();                           // torch every bought token
  await logCycle();                          // save to supabase
  await sleep(60_000);
}