pump-rust-client

Rust SDK for the pump and pump_amm Solana programs. Three things in one crate:

1. Instruction builders for buy / sell / create on both the bonding curve (pump) and the AMM (pump_amm), with auto-routing across the two.
2. Quoting for both venues, with slippage applied — drives UI prices and the *_threshold arguments that the trade builders need.
3. Transaction building (AsyncPumpClient, behind the client feature): fetches on-chain state, prepends compute-budget, signs, simulates, and sends.

Canonical sources:

• Bonding-curve builders: src/sdk/pump_v2.rs
• AMM builders: src/sdk/pump_amm_ix.rs
• Auto-routed trade + quote: src/sdk/trade_tx.rs
• Quote helpers: src/sdk/mod.rs
• RPC wrapper: src/async_client.rs
• Runnable end-to-end code: examples/

Quickstart — buy

Adapted from examples/buy_v2.rs:

use solana_sdk::compute_budget::ComputeBudgetInstruction;
use solana_sdk::native_token::LAMPORTS_PER_SOL;
use solana_sdk::signature::{Keypair, Signer};

use pump_rust_client::{constants, AsyncPumpClient, PumpSdk};

let sdk = PumpSdk::new();
let client = AsyncPumpClient::new(rpc.clone()); // requires the `client` feature

let global = client.fetch_global().await?;
let bonding_curve = client.fetch_bonding_curve(&mint).await?;

// `buy_v2_instructions` returns idempotent ATA creates + the trade ix.
let mut ixs = vec![ComputeBudgetInstruction::set_compute_unit_limit(400_000)];
ixs.extend(
    sdk.buy_v2_instructions(
        &global,
        &bonding_curve,
        mint,
        constants::SPL_TOKEN_PROGRAM_ID, // quote token program
        user.pubkey(),
        300_000_000,        // base tokens to buy
        LAMPORTS_PER_SOL,   // max quote spent
    )
    .expect("buy_v2_instructions"),
);

The other examples follow the same shape: examples/sell_v2.rs, examples/create_v2_and_buy.rs, examples/buy_amm.rs, and examples/sell_amm.rs.

Quoting

Every trade builder takes a *_threshold (max quote spent on a buy, min quote out on a sell). The quote helpers compute that threshold from a slippage in basis points:

use pump_rust_client::PumpSdk;

let sdk = PumpSdk::new();
let global = client.fetch_global().await?;
let fee_config = client.fetch_fee_config().await?;
let bonding_curve = client.fetch_bonding_curve(&mint).await?;

let quote = sdk.buy_quote_bonding_curve_sol_in(
    &global,
    Some(&fee_config),
    &bonding_curve,
    mint_supply,        // base mint supply
    LAMPORTS_PER_SOL,   // sol_amount in
    100,                // 1% slippage
)?;
// quote.amount    — tokens out at the current curve
// quote.min_out   — slippage-protected floor; pass to sell builders
// quote.max_input — slippage-protected ceiling; pass to buy builders

For code that doesn't know yet whether the curve has graduated, use the auto-routed quote_trade — it dispatches to bonding-curve or AMM math based on bonding_curve.complete, mirroring trade_tx_instructions:

use pump_rust_client::{PumpSdk, TradeQuoteParams};

let quote = sdk.quote_trade(TradeQuoteParams {
    is_buy: true,
    base_amount: 300_000_000,
    slippage_bps: 100,
    base_mint_supply: mint_supply,
    pump_global: &global,
    pump_fee_config: Some(&fee_config),
    bonding_curve: &bonding_curve,
    pump_pool: None, // Some(PumpPoolQuoteCtx { … }) required when curve.complete
}); // returns None if the curve is complete and pump_pool was not supplied

Instruction reference

All builders live on PumpSdk. Prefer the *_instructions (plural) variants — they prepend the idempotent ATA creates the user needs. The singular *_instruction returns only the trade ix, for callers that manage ATAs themselves.

Bonding curve (pump_v2) — src/sdk/pump_v2.rs:

AMM (pump_amm, post-graduation) — src/sdk/pump_amm_ix.rs:

Auto-routed trade — src/sdk/trade_tx.rs:

The auto-routed builders take TradeTxParams / TradeTxWithVenueParams (both re-exported at the crate root, see src/lib.rs) and handle ATA creation and wSOL wrap/unwrap themselves — the caller only assembles compute-budget plus signers.

The bonding-curve *_instructions plural builders take a fetched Global and BondingCurve so the SDK can pick the correct fee recipients and quote layout. create_v2_and_buy_instruction synthesises a bonding-curve preview internally from the supplied quote_mint (Pubkey::default() → wSOL), so a fetch is not required before the curve exists.

Building, signing, and sending — AsyncPumpClient

With the client feature, AsyncPumpClient wraps solana_client::nonblocking::rpc_client::RpcClient and handles the full buy lifecycle:

use std::sync::Arc;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_sdk::{native_token::LAMPORTS_PER_SOL, signature::{Keypair, Signer}};
use pump_rust_client::{constants, AsyncPumpClient, ComputeBudget};

let rpc = Arc::new(RpcClient::new(rpc_url));
let client = AsyncPumpClient::new(rpc);
let user = Keypair::new();

// 1. Fetch live state.
let global = client.fetch_global().await?;
let bonding_curve = client.fetch_bonding_curve(&mint).await?;

// 2. Build instructions via the inner SDK.
let ixs = client.sdk().buy_v2_instructions(
    &global,
    &bonding_curve,
    mint,
    constants::SPL_TOKEN_PROGRAM_ID,
    user.pubkey(),
    300_000_000,
    LAMPORTS_PER_SOL,
).expect("buy_v2_instructions");

// 3. Sign — compute-budget instructions are prepended automatically.
let tx = client.build_transaction(
    &ixs,
    &user.pubkey(),
    &[&user],
    Some(ComputeBudget {
        units: Some(400_000),
        micro_lamports_per_unit: Some(1_000),
    }),
).await?;

// 4. Simulate, then send.
let _sim = client.simulate_transaction(&tx).await?;
let sig = client.send_and_confirm_transaction(&tx).await?;

Account initialization

The trade instructions pull in 25+ accounts. You do not need to pre-create most of them — the SDK derives every PDA and ATA inside V2TradeAccounts::derive (see src/sdk/pump_v2.rs). The only ATAs the caller is responsible for are the user's own base/quote ATAs, and those are auto-prepended by the *_instructions variants.

The exact rules for which user ATAs are created when are encoded in fn user_trade_atas in src/sdk/pump_v2.rs. Summary:

• Base ATA: created on buy, skipped on sell (the user already holds the base balance to spend).
• Quote ATA: created only when the curve's quote_mint is non-default (i.e. non-wSOL curves). Legacy SOL-only curves skip the quote ATA.

trade_tx_instructions additionally handles wSOL wrap/unwrap for native-quote AMM trades, so callers using the auto-routed path do not need a separate setup transaction.

If you need different behavior (e.g. you manage user ATAs upstream), call the singular *_instruction builders directly.

Examples

Features

• client — enables AsyncPumpClient and the solana-sdk / solana-client dependencies. Required to call fetch_global / fetch_bonding_curve and the transaction-building helpers.

Without client, the SDK still exposes every *_instruction / *_instructions builder and every quoter — only the RPC wrapper is gated. The base crate (no features) only needs anchor-lang and solana-program, so it stays buildable inside on-chain programs that depend on the SDK for PDA / account-meta derivation.

CPI from another program

If you want to CPI into pump's buy_v2 / sell_v2 from your own Anchor program and reuse this SDK to derive the account metas, see CPI_README.md.