Pumpfun

https://docs.rs/pumpfun/latest/pumpfun/
Admin
Pumpfun is a Rust SDK for interacting with the Pump.fun Solana program, enabling users to create...
Tokens:174,314
Snippets:1,150
Trust Score:9.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### Rust Example: Constructing Solana Transactions with get_transaction

Source: https://docs.rs/pumpfun/latest/pumpfun/utils/transaction/fn.get_transaction_search=

Demonstrates how to use the get_transaction function to create signed Solana transactions. Examples cover transactions with multiple signers, only the payer as signer, and versioned transactions using address lookup tables.

```rust
// Create a transaction with multiple signers
let transaction = get_transaction(
    client.rpc.clone(),
    client.payer.clone(),
    &instructions,
    Some(&[&custom_signer]),
)
.await?;

// Or with just the payer as signer
let transaction = get_transaction(
    client.rpc.clone(),
    client.payer.clone(),
    &instructions,
    None,
)
.await?;

// Create a versioned transaction with address lookup tables (when "versioned-tx" feature is enabled)
let lookup_tables: Vec<AddressLookupTableAccount> = Vec::new();
let transaction = get_transaction(
    client.rpc.clone(),
    client.payer.clone(),
    &instructions,
    None,
    Some(&lookup_tables),
)
.await?;
Ok(())
```

--------------------------------

### Get Priority Fee Instructions

Source: https://docs.rs/pumpfun/latest/pumpfun/struct.PumpFun_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Generates Solana compute budget instructions for priority fees. This allows users to set a maximum compute unit limit and price per unit to prioritize their transactions during network congestion.

```APIDOC
## POST /get_priority_fee_instructions

### Description
Creates compute budget instructions for priority fees. Generates Solana compute budget instructions based on the provided priority fee configuration. These instructions are used to set the maximum compute units a transaction can consume and the price per compute unit, which helps prioritize transaction processing during network congestion.

### Method
POST

### Endpoint
/get_priority_fee_instructions

### Parameters
#### Request Body
- **priority_fee** (object) - Required - Priority fee configuration containing optional unit limit and unit price.
  - **unit_limit** (number) - Optional - The maximum number of compute units for the transaction.
  - **unit_price** (number) - Optional - The price per compute unit in micro-lamports.

### Request Example
```rust
// Set both compute unit limit and price
let priority_fee = PriorityFee {
    unit_limit: Some(200_000),
    unit_price: Some(1_000), // 1000 micro-lamports per compute unit
};

let compute_instructions: Vec<Instruction> = PumpFun::get_priority_fee_instructions(&priority_fee);
```

### Response
#### Success Response (200)
- **instructions** (array) - A vector of instructions to set compute budget parameters. This can be empty if no priority fee parameters are provided.

#### Response Example
```json
[
  {
    "program_id": "ComputeBudget111111111111111111111111111111",
    "data": "...",
    "accounts": []
  }
]
```
```

--------------------------------

### Pump.fun Solana Program SDK Usage in Rust

Source: https://docs.rs/pumpfun/latest/pumpfun/index_search=std%3A%3Avec

Example demonstrating the core functionalities of the PumpFun SDK in Rust. It covers client initialization, token creation with metadata, buying and selling tokens, retrieving bonding curve data, and subscribing to real-time events. The SDK handles Associated Token Account creation automatically for buy transactions.

```rust
use pumpfun::{
    accounts::BondingCurveAccount,
    common::types::{Cluster, PriorityFee},
    utils::CreateTokenMetadata,
    PumpFun,
};
use solana_sdk::{
    commitment_config::CommitmentConfig,
    native_token::sol_to_lamports,
    native_token::LAMPORTS_PER_SOL,
    signature::{Keypair, Signature},
    signer::Signer,
};
use std::sync::Arc;

// Create a new PumpFun client
let payer = Arc::new(Keypair::new());
let client = PumpFun::new(
    payer.clone(),
    Cluster::localnet(CommitmentConfig::finalized(), PriorityFee::default()),
);

// Mint keypair
let mint = Keypair::new();

// Token metadata
let metadata = CreateTokenMetadata {
    name: "Lorem ipsum".to_string(),
    symbol: "LIP".to_string(),
    description: "Lorem ipsum dolor, sit amet consectetur adipisicing elit. Quam, nisi.".to_string(),
    file: "/path/to/image.png".to_string(),
    twitter: None,
    telegram: None,
    website: Some("https://example.com".to_string()),
};


// Track volume
let track_volume = Some(true);

// Optional priority fee to expedite transaction processing (e.g., 100 LAMPORTS per compute unit, equivalent to a 0.01 SOL priority fee)
let fee = Some(PriorityFee {
    unit_limit: Some(100_000),
    unit_price: Some(100_000_000),
});

// Create token with metadata
let signature = client.create(mint.insecure_clone(), metadata.clone(), fee).await.unwrap();
println!("Create signature: {}", signature);

// Create and buy tokens with metadata
let signature = client.create_and_buy(mint.insecure_clone(), metadata.clone(), sol_to_lamports(1f64), track_volume, None, fee).await.unwrap();
println!("Created and buy signature: {}", signature);

// Print the curve
let curve = client.get_bonding_curve_account(&mint.pubkey()).await.unwrap();
println!("Bonding curve: {:#?}", curve);

// Buy tokens (ATA will be created automatically if needed)
let signature = client.buy(mint.pubkey(), sol_to_lamports(1f64), track_volume, None, fee).await.unwrap();
println!("Buy signature: {}", signature);

// Sell tokens (sell all tokens)
let signature = client.sell(mint.pubkey(), None, None, fee).await.unwrap();
println!("Sell signature: {}", signature);

// Subscribe to real-time events with the stream feature
use pumpfun::common::stream::PumpFunEvent;

// Subscribe to Pump.fun events
let subscription = client.subscribe(None, None, |signature, event, error, _response| {
    match event {
        Some(PumpFunEvent::Create(create_event)) => {
            println!("New token created: {} ({})", create_event.name, create_event.symbol);
            println!("Mint address: {}", create_event.mint);
            println!("Created by: {}", create_event.creator);
        },
        Some(PumpFunEvent::Trade(trade_event)) => {
            let action = if trade_event.is_buy { "bought" } else { "sold" };
            println!(
                "User {} {} {} tokens for {} SOL",
                trade_event.user,
                action,
                trade_event.token_amount,
                trade_event.sol_amount as f64 / 1_000_000_000.0
            );
        },
        Some(event) => println!("Other event received: {:#?}", event),
        None => {
            if let Some(err) = error {
                eprintln!("Error parsing event in tx {}: {}", signature, err);
            }
        }
    }
}).await.unwrap();

// Keep subscription active as long as needed
// The subscription will automatically unsubscribe when dropped

```

--------------------------------

### Get Priority Fee Instructions API

Source: https://docs.rs/pumpfun/latest/pumpfun/struct.PumpFun

Generates Solana compute budget instructions based on the provided priority fee configuration. These instructions are used to set the maximum compute units a transaction can consume and the price per compute unit, which helps prioritize transaction processing during network congestion.

```APIDOC
## POST /get_priority_fee_instructions

### Description
Creates compute budget instructions for priority fees. Generates Solana compute budget instructions based on the provided priority fee configuration. These instructions are used to set the maximum compute units a transaction can consume and the price per compute unit, which helps prioritize transaction processing during network congestion.

### Method
POST

### Endpoint
/get_priority_fee_instructions

### Parameters
#### Request Body
- **priority_fee** (PriorityFee) - Required - Priority fee configuration containing optional unit limit and unit price
  - **unit_limit** (Option<u64>) - Optional - The maximum compute units for the transaction.
  - **unit_price** (Option<u64>) - Optional - The price per compute unit in micro-lamports.

### Response
#### Success Response (200)
- **instructions** (Vec<Instruction>) - A vector of instructions to set compute budget parameters, which can be empty if no priority fee parameters are provided.

### Request Example
```rust
let priority_fee = PriorityFee {
    unit_limit: Some(200_000),
    unit_price: Some(1_000), // 1000 micro-lamports per compute unit
};

let compute_instructions: Vec<Instruction> = PumpFun::get_priority_fee_instructions(&priority_fee);
```
```

--------------------------------

### Create Token and Buy Initial Liquidity (Rust)

Source: https://docs.rs/pumpfun/latest/pumpfun/struct.PumpFun_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use the `create_and_buy` method to atomically create a new token and make an initial purchase in a single transaction. This method ensures liquidity is established immediately upon token creation, making the creator the first holder.

```rust
let mint = Keypair::new();
let metadata = CreateTokenMetadata {
    name: "My Token".to_string(),
    symbol: "MYTKN".to_string(),
    description: "A test token created with Pump.fun".to_string(),
    file: "path/to/image.png".to_string(),
    twitter: None,
    telegram: None,
    website: Some("https://example.com".to_string()),
};

// Example of calling create_and_buy (actual parameters would be more detailed)
let signature = client.create_and_buy(mint, metadata, 1000000, None, None, None).await?;
```

--------------------------------

### Get Global PDA

Source: https://docs.rs/pumpfun/latest/pumpfun/struct.PumpFun_search=u32+-%3E+bool

Gets the Program Derived Address (PDA) for the global state account. This account contains program-wide configuration.

```APIDOC
## GET /pda/global

### Description
Retrieves the Program Derived Address (PDA) for the global state account, which stores program-wide configuration.

### Method
GET

### Endpoint
/pda/global

### Parameters
None

### Response
#### Success Response (200)
- **pda** (string) - The public key of the global state account PDA.

#### Response Example
```json
{
  "pda": "GlobalStatePda11111111111111111111111111"
}
```
```

--------------------------------

### Get Mint Authority PDA

Source: https://docs.rs/pumpfun/latest/pumpfun/struct.PumpFun_search=u32+-%3E+bool

Gets the Program Derived Address (PDA) for the mint authority. This authority can mint new tokens for any token created through the Pump.fun program.

```APIDOC
## GET /pda/mint-authority

### Description
Retrieves the Program Derived Address (PDA) for the mint authority, which is authorized to mint new tokens created via Pump.fun.

### Method
GET

### Endpoint
/pda/mint-authority

### Parameters
None

### Response
#### Success Response (200)
- **pda** (string) - The public key of the mint authority PDA.

#### Response Example
```json
{
  "pda": "MintAuthorityPda11111111111111111111111111"
}
```
```
Tokens:
Raw