Documentation

import { createRequire } from "node:module";
import { Connection, Keypair, LAMPORTS_PER_SOL } from "@solana/web3.js";
import { TOKEN_2022_PROGRAM_ID } from "@solana/spl-token";

const require = createRequire(import.meta.url);
const { OnlinePumpSdk, PumpSdk, getBuyTokenAmountFromSolAmount } = require("@pump-fun/pump-sdk");
const { OnlinePumpAmmSdk, PumpAmmSdk, canonicalPumpPoolPda }     = require("@pump-fun/pump-swap-sdk");

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.01) 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;

// primary: check graduation status via SDK
let isMigrated = false;
try {
  const feeResult = await pumpOnline.getMinimumDistributableFee(mint);
  isMigrated = feeResult.isGraduated;
} catch {
  // fallback: check if canonical AMM pool exists on-chain
  const poolKey  = canonicalPumpPoolPda(mint);
  const poolInfo = await connection.getAccountInfo(poolKey);
  if (poolInfo) isMigrated = true;
}

// 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
const solBn  = new BN(Math.floor(solAmount * 1e9));
const amount = getBuyTokenAmountFromSolAmount({
  global,
  feeConfig: null,
  mintSupply: bondingCurve.tokenTotalSupply,
  bondingCurve,
  amount: solBn,
});

// execute buy through bonding curve program
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);

// Tx 1 — buy tokens with 65% of SOL
const buySolBn  = new BN(Math.floor(solAmount * 0.65 * 1e9));
const poolKey   = canonicalPumpPoolPda(mint);
const swapState = await pumpAmmOnline.swapSolanaState(poolKey, agent.publicKey);

const buyIx = await pumpAmmOffline.buyQuoteInput(swapState, buySolBn, 5);
await sendAndConfirm(connection, new Transaction().add(...buyIx), agent);

// wait for tokens to land on-chain
await new Promise(r => setTimeout(r, 4000));

// Tx 2 — deposit SOL + tokens as LP (35% of SOL)
const depositSolBn   = new BN(Math.floor(solAmount * 0.35 * 1e9));
const liquidityState = await pumpAmmOnline
  .liquiditySolanaState(poolKey, agent.publicKey);

const { lpToken } = pumpAmmOffline
  .depositAutocompleteBaseAndLpTokenFromQuote(liquidityState, depositSolBn, 10);

const depositIx = await pumpAmmOffline
  .depositInstructions(liquidityState, lpToken, 10);

// deposit needs manual v2 PDA (SDK doesn't add it for deposits)
for (const ix of depositIx) {
  if (ix.programId.equals(PUMP_AMM_PROGRAM_ID)) {
    ix.keys.push({
      pubkey: poolV2Pda(mint),
      isSigner: false,
      isWritable: false,
    });
  }
}

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

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

  await claimFees();

  const migrated = await isTokenMigrated();

  if (!migrated) {
    await doBuyback(claimed);            // bonding curve buy
  } else {
    await doAddLp(claimed);              // 65% buy + 35% LP deposit
  }

  await logCycle();                      // save to supabase
  await sleep(60_000);
}