Landing transactions on pump.fun

1use anyhow::Result;
2use futures::StreamExt;
3use yellowstone_grpc_client::GeyserGrpcClient;
4use yellowstone_grpc_proto::prelude::*;
5use std::collections::HashMap;
6 
7const PUMP_PROGRAM: &str = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";
8 
9/// Watch for new mints at the source.
10///
11/// This is where the race is actually won or lost. Polling an RPC for new
12/// pools costs you hundreds of milliseconds of staleness before you have done
13/// anything at all; by the time a poll returns, the transaction you are
14/// reacting to is old news and forty other bots already saw it.
15///
16/// A Geyser stream pushes account and transaction updates as the validator
17/// processes them. The difference is not incremental, it is the difference
18/// between competing and not.
19pub async fn watch_new_mints(endpoint: String, token: Option<String>) -> Result<()> {
20    let mut client = GeyserGrpcClient::build_from_shared(endpoint)?
21        .x_token(token)?
22        .connect()
23        .await?;
24 
25    let mut transactions = HashMap::new();
26    transactions.insert(
27        "pump".to_string(),
28        SubscribeRequestFilterTransactions {
29            vote: Some(false),
30            failed: Some(false),
31            account_include: vec![PUMP_PROGRAM.to_string()],
32            ..Default::default()
33        },
34    );
35 
36    let request = SubscribeRequest {
37        transactions,
38        // "processed" is the earliest you can see anything. Waiting for
39        // confirmed adds a slot you cannot afford.
40        commitment: Some(CommitmentLevel::Processed as i32),
41        ..Default::default()
42    };
43 
44    let (_sink, mut stream) = client.subscribe_with_request(Some(request)).await?;
45 
46    while let Some(message) = stream.next().await {
47        let Ok(update) = message else { continue };
48        if let Some(UpdateOneof::Transaction(tx)) = update.update_oneof {
49            // Decode, look for a create instruction, extract the mint, and
50            // hand it to the builder. Every microsecond spent in here is
51            // a microsecond your competitors are not spending.
52            handle_transaction(tx).await?;
53        }
54    }
55    Ok(())
56}

1import {
2  Connection, Keypair, PublicKey, TransactionInstruction,
3  TransactionMessage, VersionedTransaction, ComputeBudgetProgram,
4} from "@solana/web3.js";
5 
6/**
7 * Pre-build everything that does not depend on the mint.
8 *
9 * When a mint appears you have a few hundred milliseconds before the
10 * opportunity is gone. Anything you can compute in advance should already be
11 * computed: budget instructions, your own account keys, the program IDs, the
12 * serialization scaffolding. The only work left at the moment of truth should
13 * be deriving the mint-specific addresses and signing.
14 */
15export class PumpBuyer {
16  private budgetIxs: TransactionInstruction[];
17 
18  constructor(
19    private rpc: Connection,
20    private payer: Keypair,
21    private program: PublicKey,
22    opts: { computeUnits: number; microLamports: number },
23  ) {
24    // Built once. These never change per mint.
25    this.budgetIxs = [
26      ComputeBudgetProgram.setComputeUnitLimit({ units: opts.computeUnits }),
27      ComputeBudgetProgram.setComputeUnitPrice({ microLamports: opts.microLamports }),
28    ];
29  }
30 
31  /** Everything mint-specific, derived synchronously. No await, no RPC. */
32  private derive(mint: PublicKey) {
33    const [bondingCurve] = PublicKey.findProgramAddressSync(
34      [Buffer.from("bonding-curve"), mint.toBuffer()],
35      this.program,
36    );
37    const [associatedCurve] = PublicKey.findProgramAddressSync(
38      [bondingCurve.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mint.toBuffer()],
39      ASSOCIATED_TOKEN_PROGRAM_ID,
40    );
41    const [userAta] = PublicKey.findProgramAddressSync(
42      [this.payer.publicKey.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mint.toBuffer()],
43      ASSOCIATED_TOKEN_PROGRAM_ID,
44    );
45    return { bondingCurve, associatedCurve, userAta };
46  }
47 
48  /**
49   * Build and sign. The blockhash comes from a cache that a background task
50   * keeps fresh, so this function never touches the network.
51   */
52  build(mint: PublicKey, blockhash: string, solIn: bigint, maxSolCost: bigint) {
53    const { bondingCurve, associatedCurve, userAta } = this.derive(mint);
54 
55    const message = new TransactionMessage({
56      payerKey: this.payer.publicKey,
57      recentBlockhash: blockhash,
58      instructions: [
59        ...this.budgetIxs,
60        createAssociatedTokenAccountIdempotentInstruction(
61          this.payer.publicKey, userAta, this.payer.publicKey, mint,
62        ),
63        buyInstruction({
64          program: this.program,
65          mint, bondingCurve, associatedCurve, userAta,
66          user: this.payer.publicKey,
67          amount: solIn,
68          maxSolCost,
69        }),
70      ],
71    }).compileToV0Message();
72 
73    const tx = new VersionedTransaction(message);
74    tx.sign([this.payer]);
75    return tx;
76  }
77}

1/**
2 * Slippage on a bonding curve is not the same problem as slippage on an AMM.
3 *
4 * The curve is deterministic: given the reserves at the moment your
5 * transaction executes, the price is exactly computable. The uncertainty is
6 * not about the maths, it is about how many buys land ahead of you.
7 *
8 * So the right way to think about maxSolCost is "how many competitors am I
9 * willing to be behind", not "what percentage feels safe".
10 */
11export function priceAfterBuys(
12  virtualSolReserves: bigint,
13  virtualTokenReserves: bigint,
14  tokensOut: bigint,
15): bigint {
16  // Constant product: solIn = (reserveSol * tokensOut) / (reserveTokens - tokensOut)
17  return (virtualSolReserves * tokensOut) / (virtualTokenReserves - tokensOut);
18}
19 
20/**
21 * Work out what you would pay if N competitors of a typical size land first.
22 * That number, not a percentage, is what maxSolCost should be.
23 */
24export function maxCostBehind(
25  virtualSolReserves: bigint,
26  virtualTokenReserves: bigint,
27  yourTokens: bigint,
28  competitorsAhead: number,
29  typicalCompetitorTokens: bigint,
30): bigint {
31  let sol = virtualSolReserves;
32  let tokens = virtualTokenReserves;
33 
34  for (let i = 0; i < competitorsAhead; i += 1) {
35    const cost = priceAfterBuys(sol, tokens, typicalCompetitorTokens);
36    sol += cost;
37    tokens -= typicalCompetitorTokens;
38  }
39 
40  return priceAfterBuys(sol, tokens, yourTokens);
41}
42 
43// Being explicit beats a percentage:
44//   "I will pay up to what it costs if 8 buys of 0.5 SOL land ahead of me"
45// is a decision. "5% slippage" is a number somebody picked.