pumpdotfun-sdk

Install the SDK using npm to interact with the Pump.fun decentralized application on the Solana blockchain.

npm i pumpdotfun-sdk

The program uses several key data structures for state management:

global

Stores the program-wide configuration:

• initialized: bool
• authority: pubkey
• feeRecipient: pubkey
• initialVirtualTokenReserves: u64
• initialVirtualSolReserves: u64
• initialRealTokenReserves: u64
• tokenTotalSupply: u64
• feeBasisPoints: u64

bondingCurve

Stores the state for an individual token's bonding curve:

• virtualTokenReserves: u64
• virtualSolReserves: u64
• realTokenReserves: u64
• realSolReserves: u64
• tokenTotalSupply: u64
• complete: bool

To use the SDK, instantiate the PumpFunSDK class by passing an Anchor Provider. The SDK will automatically initialize the underlying program using the internal IDL and set up the connection via the provider.

import { PumpFunSDK } from "pumpdotfun-sdk";
import { AnchorProvider, Connection, Keypair } from "@solana/web3.js";

const connection = new Connection("https://api.mainnet-beta.solana.com");
const wallet = Keypair.generate(); // Use your actual wallet
const provider = new AnchorProvider(connection, wallet as any, {});

const sdk = new PumpFunSDK(provider);

To test the event listener functionality, run the event subscription script:

npx ts-node example/events/events.ts

To run the full lifecycle example (creating, buying, and selling tokens), follow these steps:

1. Configure Environment: Create a .env file and set your HELIUS_RPC_URL.
2. Fund Account: Ensure you have an account with at least 0.004 SOL.
3. Execute: Run the following command:

npx ts-node example/basic/index.ts

The SDK allows you to listen to real-time protocol events using addEventListener. You can subscribe to specific event types and provide a callback function that receives the event data, the slot, and the transaction signature.

Event Types

Supported event types include:

• createEvent
• tradeEvent
• completeEvent

Managing Listeners

• Use addEventListener to start listening. It returns a numeric eventId.
• Use removeEventListener(eventId: number) to stop listening to a specific event.

const createEventId = sdk.addEventListener("createEvent", (event, slot, signature) => {
  console.log("createEvent", event, slot, signature);
});

// To stop listening:
sdk.removeEventListener(createEventId);

The Pump.fun program exposes several instructions for managing the lifecycle of tokens and bonding curves.

• create: Creates a new coin and its associated bonding curve. Requires name, symbol, uri, and creator (pubkey).
• buy: Buys tokens from a bonding curve. Requires amount (u64) and maxSolCost (u64) to handle slippage.
• sell: Sells tokens back into a bonding curve. Requires amount (u64) and minSolOutput (u64) to handle slippage.
• withdraw: Allows an admin to withdraw liquidity for migration once a bonding curve is complete.
• initialize: Creates the global state.
• setParams: Sets the global state parameters (e.g., fee recipient, reserves, and fee basis points).

The SDK provides an addEventListener method to subscribe to real-time on-chain events emitted by the PumpFun program. Supported event types are:

• createEvent
• tradeEvent
• completeEvent
• setParamsEvent

Usage: Pass the event type and a callback function that receives the processed event, the slot, and the transaction signature.

sdk.addEventListener("tradeEvent", (event, slot, signature) => {
  console.log(`Trade detected at slot ${slot}:`, event);
  console.log(`Signature: ${signature}`);
});

// To stop listening:
// const eventId = sdk.addEventListener(...);
// sdk.removeEventListener(eventId);

The src/events.ts module provides utility functions to transform raw program event data into structured, typed objects. These functions convert string-based addresses into @solana/web3.js PublicKey instances and convert numeric strings or raw values into BigInt or Number types. This is useful when processing logs from a Solana RPC or websocket to ensure data types are correct for your application logic.

import { toCreateEvent, toTradeEvent } from 'pumpdotfun-sdk';

// Example: Transforming a raw CreateEvent
const rawCreateEvent = {
  name: "Token Name",
  symbol: "TKN",
  uri: "https://uri.com",
  mint: "Address1...",
  bondingCurve: "Address2...",
  user: "Address3..."
};

const event = toCreateEvent(rawCreateEvent);
// event.mint is now a PublicKey object

The pumpdotfun-sdk package exports its core functionality through a single entrypoint. You can access the main SDK class, utility functions, type definitions, event handlers, and account-specific logic by importing from the root package. The primary interface for interacting with the protocol is the PumpDotFunSDK class (exported from ./pumpfun.js).

import { PumpDotFunSDK, ... } from 'pumpdotfun-sdk';