gavindiaz/sol-trade-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge commit 'b3338114837482c5d17b53d347b283959c0f5e45' into feat/pumpswap

Browse Source
This commit is contained in:
sgxiang
2025-06-10 00:54:59 +08:00
parent 651789b553 b333811483
commit 7617b4b82b
7 changed files with 318 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.toml
+2
View File
@@ -87,6 +87,8 @@ tokio-tungstenite = { version = "0.26.1", features = ["native-tls"] }
indicatif = "0.17.11"
toml = "0.8.20"
pumpfun_program = { version = "4.2.0", package = "pumpfun" }
src/constants/pumpfun/mod.rs
+8
View File
@@ -172,3 +172,11 @@ pub struct Symbol;
impl Symbol {
pub const SOLANA: &'static str = "solana";
}
pub mod trade_type {
pub const COPY_BUY: &'static str = "copy_buy";
pub const COPY_SELL: &'static str = "copy_sell";
pub const SNIPER_BUY: &'static str = "sniper_buy";
pub const SNIPER_SELL: &'static str = "sniper_sell";
}
src/lib.rs
+137 -4
View File
@@ -9,6 +9,7 @@ pub mod swqos;
pub mod pumpfun;
use std::sync::Arc;
use std::sync::Mutex;
use swqos::{FeeClient, JitoClient, NextBlockClient, NozomiClient, SolRpcClient, ZeroSlotClient};
use rustls::crypto::{ring::default_provider, CryptoProvider};
@@ -23,6 +24,8 @@ use common::{pumpfun::logs_data::TradeInfo, pumpfun::logs_events::PumpfunEvent,
use common::pumpfun::logs_subscribe::SubscriptionHandle;
use ipfs::TokenMetadataIPFS;
use constants::pumpfun::trade_type::{COPY_BUY, SNIPER_BUY};
pub struct PumpFun {
pub payer: Arc<Keypair>,
pub rpc: Arc<SolanaRpcClient>,
@@ -31,6 +34,8 @@ pub struct PumpFun {
pub cluster: Cluster,
}
static INSTANCE: Mutex<Option<Arc<PumpFun>>> = Mutex::new(None);
impl Clone for PumpFun {
fn clone(&self) -> Self {
Self {
@@ -105,13 +110,29 @@ impl PumpFun {
fee_clients.push(Arc::new(rpc_client));
}
Self {
let instance = Self {
payer,
rpc,
fee_clients,
priority_fee: cluster.clone().priority_fee,
cluster: cluster.clone(),
}
};
let mut current = INSTANCE.lock().unwrap();
*current = Some(Arc::new(instance.clone()));
instance
}
/// Get the RPC client instance
pub fn get_rpc(&self) -> &Arc<SolanaRpcClient> {
&self.rpc
}
/// Get the current instance
pub fn get_instance() -> Arc<Self> {
let instance = INSTANCE.lock().unwrap();
instance.as_ref().expect("PumpFun instance not initialized. Please call new() first.").clone()
}
/// Create a new token
@@ -172,7 +193,7 @@ impl PumpFun {
}
/// Buy tokens
pub async fn buy(
pub async fn sniper_buy(
&self,
mint: Pubkey,
creator: Pubkey,
@@ -194,11 +215,38 @@ impl PumpFun {
self.priority_fee.clone(),
self.cluster.clone().lookup_table_key,
recent_blockhash,
SNIPER_BUY.to_string(),
).await
}
pub async fn copy_buy(
&self,
mint: Pubkey,
creator: Pubkey,
dev_buy_token: u64,
dev_sol_cost: u64,
buy_sol_cost: u64,
slippage_basis_points: Option<u64>,
recent_blockhash: Hash,
) -> Result<(), anyhow::Error> {
pumpfun::buy::buy(
self.rpc.clone(),
self.payer.clone(),
mint,
creator,
dev_buy_token,
dev_sol_cost,
buy_sol_cost,
slippage_basis_points,
self.priority_fee.clone(),
self.cluster.clone().lookup_table_key,
recent_blockhash,
COPY_BUY.to_string(),
).await
}
/// Buy tokens using Jito
pub async fn buy_with_tip(
pub async fn sniper_buy_with_tip(
&self,
mint: Pubkey,
creator: Pubkey,
@@ -220,6 +268,33 @@ impl PumpFun {
self.priority_fee.clone(),
self.cluster.clone().lookup_table_key,
recent_blockhash,
SNIPER_BUY.to_string(),
).await
}
pub async fn copy_buy_with_tip(
&self,
mint: Pubkey,
creator: Pubkey,
dev_buy_token: u64,
dev_sol_cost: u64,
buy_sol_cost: u64,
slippage_basis_points: Option<u64>,
recent_blockhash: Hash,
) -> Result<(), anyhow::Error> {
pumpfun::buy::buy_with_tip(
self.fee_clients.clone(),
self.payer.clone(),
mint,
creator,
dev_buy_token,
dev_sol_cost,
buy_sol_cost,
slippage_basis_points,
self.priority_fee.clone(),
self.cluster.clone().lookup_table_key,
recent_blockhash,
COPY_BUY.to_string(),
).await
}
@@ -265,6 +340,26 @@ impl PumpFun {
).await
}
/// Sell tokens by amount
pub async fn sell_by_amount(
&self,
mint: Pubkey,
creator: Pubkey,
amount: u64,
recent_blockhash: Hash,
) -> Result<(), anyhow::Error> {
pumpfun::sell::sell_by_amount(
self.rpc.clone(),
self.payer.clone(),
mint.clone(),
creator,
amount,
self.priority_fee.clone(),
self.cluster.clone().lookup_table_key,
recent_blockhash,
).await
}
pub async fn sell_by_percent_with_tip(
&self,
mint: Pubkey,
@@ -286,6 +381,25 @@ impl PumpFun {
).await
}
pub async fn sell_by_amount_with_tip(
&self,
mint: Pubkey,
creator: Pubkey,
amount: u64,
recent_blockhash: Hash,
) -> Result<(), anyhow::Error> {
pumpfun::sell::sell_by_amount_with_tip(
self.fee_clients.clone(),
self.payer.clone(),
mint,
creator,
amount,
self.priority_fee.clone(),
self.cluster.clone().lookup_table_key,
recent_blockhash,
).await
}
/// Sell tokens using Jito
pub async fn sell_with_tip(
&self,
@@ -375,4 +489,23 @@ impl PumpFun {
pub async fn close_token_account(&self, mint: &Pubkey) -> Result<(), anyhow::Error> {
pumpfun::common::close_token_account(&self.rpc, self.payer.as_ref(), mint).await
}
#[inline]
pub async fn get_current_price(&self, mint: &Pubkey) -> Result<f64, anyhow::Error> {
let (bonding_curve, _) = pumpfun::common::get_bonding_curve_account_v2(&self.rpc, mint).await?;
let virtual_sol_reserves = bonding_curve.virtual_sol_reserves;
let virtual_token_reserves = bonding_curve.virtual_token_reserves;
Ok(pumpfun::common::get_token_price(virtual_sol_reserves, virtual_token_reserves))
}
#[inline]
pub async fn get_real_sol_reserves(&self, mint: &Pubkey) -> Result<u64, anyhow::Error> {
let (bonding_curve, _) = pumpfun::common::get_bonding_curve_account_v2(&self.rpc, mint).await?;
let actual_sol_reserves = bonding_curve.real_sol_reserves;
Ok(actual_sol_reserves)
}
}
src/main.rs
+91 -8
View File
@@ -5,14 +5,16 @@ use solana_sdk::{commitment_config::CommitmentConfig, transaction::VersionedTran
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// test_pumpfun().await?;
test_pumpswap().await?;
// test_pumpfun_with_shreds().await?;
// test_pumpfun_with_grpc().await?;
// test_pumpswap_with_shreds().await?;
test_pumpswap_with_grpc().await?;
Ok(())
}
async fn test_pumpfun() -> Result<(), Box<dyn std::error::Error>> {
async fn test_pumpfun_with_shreds() -> Result<(), Box<dyn std::error::Error>> {
let grpc = ShredStreamGrpc::new(
"http://127.0.0.1:10800".to_string(),
"http://127.0.0.1:10000".to_string(),
).await?;
let callback = |event: PumpfunEvent| {
@@ -52,12 +54,44 @@ async fn test_pumpfun() -> Result<(), Box<dyn std::error::Error>> {
Ok(())
}
async fn test_pumpswap() -> Result<(), Box<dyn std::error::Error>> {
// 使用 GRPC 客户端订阅 PumpSwap 事件
println!("正在订阅 PumpSwap GRPC 事件...");
async fn test_pumpfun_with_grpc() -> Result<(), Box<dyn std::error::Error>> {
let grpc = YellowstoneGrpc::new(
"https://solana-yellowstone-grpc.publicnode.com:443".to_string(),
None,
)?;
let callback = |event: PumpfunEvent| {
match event {
PumpfunEvent::NewDevTrade(trade_info) => {
println!("Received new dev trade event: {:?}", trade_info);
},
PumpfunEvent::NewToken(token_info) => {
println!("Received new token event: {:?}", token_info);
},
PumpfunEvent::NewUserTrade(trade_info) => {
println!("Received new trade event: {:?}", trade_info);
},
PumpfunEvent::NewBotTrade(trade_info) => {
println!("Received new bot trade event: {:?}", trade_info);
},
PumpfunEvent::Error(err) => {
println!("Received error: {}", err);
}
}
};
grpc.subscribe_pumpfun(callback, None).await?;
Ok(())
}
async fn test_pumpswap_with_shreds() -> Result<(), Box<dyn std::error::Error>> {
// 使用 ShredStream 客户端订阅 PumpSwap 事件
println!("正在订阅 PumpSwap ShredStream 事件...");
let grpc_client = ShredStreamGrpc::new(
"http://127.0.0.1:10800".to_string(),
"http://127.0.0.1:10000".to_string(),
).await?;
// 定义回调函数处理 PumpSwap 事件
@@ -100,6 +134,55 @@ async fn test_pumpswap() -> Result<(), Box<dyn std::error::Error>> {
Ok(())
}
async fn test_pumpswap_with_grpc() -> Result<(), Box<dyn std::error::Error>> {
// 使用 GRPC 客户端订阅 PumpSwap 事件
println!("正在订阅 PumpSwap GRPC 事件...");
let grpc = YellowstoneGrpc::new(
"https://solana-yellowstone-grpc.publicnode.com:443".to_string(),
None
)?;
// 定义回调函数处理 PumpSwap 事件
let callback = |event: PumpSwapEvent| {
match event {
PumpSwapEvent::Buy(buy_event) => {
println!("buy_event: {:?}", buy_event);
},
PumpSwapEvent::Sell(sell_event) => {
println!("sell_event: {:?}", sell_event);
},
PumpSwapEvent::CreatePool(create_event) => {
println!("create_event: {:?}", create_event);
},
PumpSwapEvent::Deposit(deposit_event) => {
println!("deposit_event: {:?}", deposit_event);
},
PumpSwapEvent::Withdraw(withdraw_event) => {
println!("withdraw_event: {:?}", withdraw_event);
},
PumpSwapEvent::Disable(disable_event) => {
println!("disable_event: {:?}", disable_event);
},
PumpSwapEvent::UpdateAdmin(update_admin_event) => {
println!("update_admin_event: {:?}", update_admin_event);
},
PumpSwapEvent::UpdateFeeConfig(update_fee_event) => {
println!("update_fee_event: {:?}", update_fee_event);
},
PumpSwapEvent::Error(err) => {
println!("error: {}", err);
}
}
};
// 订阅 PumpSwap 事件
println!("开始监听 PumpSwap 事件，按 Ctrl+C 停止...");
grpc.subscribe_pumpswap(callback).await?;
Ok(())
}
async fn test_wss() -> AnyResult<()> {
println!("Starting token subscription\n");
src/pumpfun/buy.rs
+25 -5
View File
@@ -22,7 +22,9 @@ use crate::{
const MAX_LOADED_ACCOUNTS_DATA_SIZE_LIMIT: u32 = 250000;
use super::common::{calculate_with_slippage_buy, get_buy_token_amount_from_sol_amount, init_bonding_curve_account};
use super::common::{calculate_with_slippage_buy, get_buy_token_amount_from_sol_amount, init_bonding_curve_account, get_bonding_curve_account_v2, get_bonding_curve_pda};
use crate::constants::pumpfun::trade_type::{SNIPER_BUY};
use crate::PumpFun;
/// 添加nonce消费指令到指令集合中
///
@@ -76,10 +78,11 @@ pub async fn buy(
priority_fee: PriorityFee,
lookup_table_key: Option<Pubkey>,
recent_blockhash: Hash,
trade_type: String,
) -> Result<(), anyhow::Error> {
let start_time = Instant::now();
let mint = Arc::new(mint.clone());
let instructions = build_buy_instructions(payer.clone(), mint.clone(), creator, dev_buy_token, dev_sol_cost, buy_sol_cost, slippage_basis_points).await?;
let instructions = build_buy_instructions(payer.clone(), mint.clone(), creator, dev_buy_token, dev_sol_cost, buy_sol_cost, slippage_basis_points, trade_type).await?;
println!(" 买入交易指令: {:?}", start_time.elapsed());
let start_time = Instant::now();
@@ -191,10 +194,11 @@ pub async fn buy_with_tip(
priority_fee: PriorityFee,
lookup_table_key: Option<Pubkey>,
recent_blockhash: Hash,
trade_type: String,
) -> Result<(), anyhow::Error> {
let start_time = Instant::now();
let mint = Arc::new(mint.clone());
let instructions = build_buy_instructions(payer.clone(), mint.clone(), creator, dev_buy_token, dev_sol_cost, buy_sol_cost, slippage_basis_points).await?;
let instructions = build_buy_instructions(payer.clone(), mint.clone(), creator, dev_buy_token, dev_sol_cost, buy_sol_cost, slippage_basis_points, trade_type).await?;
println!(" 买入交易指令: {:?}", start_time.elapsed());
let start_time = Instant::now();
@@ -356,7 +360,6 @@ pub async fn build_buy_transaction_with_tip(
}
pub async fn build_buy_instructions(
// rpc: Arc<SolanaRpcClient>,
payer: Arc<Keypair>,
mint: Arc<Pubkey>,
creator: Pubkey,
@@ -364,12 +367,29 @@ pub async fn build_buy_instructions(
dev_sol_cost: u64,
buy_sol_cost: u64,
slippage_basis_points: Option<u64>,
trade_type: String,
) -> Result<Vec<Instruction>, anyhow::Error> {
if buy_sol_cost == 0 {
return Err(anyhow!("Amount cannot be zero"));
}
let bonding_curve = init_bonding_curve_account(&mint, dev_buy_token, dev_sol_cost, creator).await?;
let bonding_curve = if trade_type == SNIPER_BUY {
init_bonding_curve_account(&mint, dev_buy_token, dev_sol_cost, creator).await?
} else {
let (bonding_curve, _) = get_bonding_curve_account_v2(&PumpFun::get_instance().get_rpc(), &mint).await?;
Arc::new(crate::accounts::BondingCurveAccount {
discriminator: bonding_curve.discriminator,
account: get_bonding_curve_pda(&mint).unwrap(),
virtual_token_reserves: bonding_curve.virtual_token_reserves,
virtual_sol_reserves: bonding_curve.virtual_sol_reserves,
real_token_reserves: bonding_curve.real_token_reserves,
real_sol_reserves: bonding_curve.real_sol_reserves,
token_total_supply: bonding_curve.token_total_supply,
complete: bonding_curve.complete,
creator: creator,
})
};
let max_sol_cost = calculate_with_slippage_buy(buy_sol_cost, slippage_basis_points.unwrap_or(100));
let creator_vault_pda = bonding_curve.get_creator_vault_pda();
src/pumpfun/common.rs
+20
View File
@@ -7,6 +7,7 @@ use solana_sdk::{
compute_budget::ComputeBudgetInstruction, instruction::Instruction, pubkey::Pubkey, signature::Keypair, signer::Signer, system_instruction, transaction::Transaction
};
use spl_associated_token_account::get_associated_token_address;
use pumpfun_program::accounts::BondingCurveAccount as PumpfunBondingCurveAccount;
use crate::{accounts::{self, BondingCurveAccount}, common::{pumpfun::logs_data::TradeInfo, PriorityFee, SolanaRpcClient}, constants::{self, pumpfun::{self, global_constants::{CREATOR_FEE, FEE_BASIS_POINTS}, trade::DEFAULT_SLIPPAGE}}};
lazy_static::lazy_static! {
@@ -224,6 +225,25 @@ pub async fn get_bonding_curve_account(
Ok((bonding_curve, bonding_curve_pda))
}
#[inline]
pub async fn get_bonding_curve_account_v2(
rpc: &SolanaRpcClient,
mint: &Pubkey,
) -> Result<(Arc<PumpfunBondingCurveAccount>, Pubkey), anyhow::Error> {
let bonding_curve_pda = get_bonding_curve_pda(mint)
.ok_or(anyhow!("Bonding curve not found"))?;
let account = rpc.get_account(&bonding_curve_pda).await?;
if account.data.is_empty() {
return Err(anyhow!("Bonding curve not found"));
}
let bonding_curve = solana_sdk::borsh1::try_from_slice_unchecked::<PumpfunBondingCurveAccount>(&account.data)
.map_err(|e| anyhow::anyhow!("Failed to deserialize bonding curve account: {}", e))?;
Ok((Arc::new(bonding_curve), bonding_curve_pda))
}
// #[inline]
// pub fn get_buy_token_amount(
// mint: &Pubkey,
src/pumpfun/sell.rs
+35
View File
@@ -56,6 +56,24 @@ pub async fn sell_by_percent(
sell(rpc, payer, mint, creator, amount, priority_fee, lookup_table_key, recent_blockhash).await
}
/// Sell tokens by amount
pub async fn sell_by_amount(
rpc: Arc<SolanaRpcClient>,
payer: Arc<Keypair>,
mint: Pubkey,
creator: Pubkey,
amount: u64,
priority_fee: PriorityFee,
lookup_table_key: Option<Pubkey>,
recent_blockhash: Hash,
) -> Result<(), anyhow::Error> {
if amount == 0 {
return Err(anyhow!("Amount must be greater than 0"));
}
sell(rpc, payer, mint, creator, amount, priority_fee, lookup_table_key, recent_blockhash).await
}
pub async fn sell_by_percent_with_tip(
fee_clients: Vec<Arc<FeeClient>>,
payer: Arc<Keypair>,
@@ -75,6 +93,23 @@ pub async fn sell_by_percent_with_tip(
sell_with_tip(fee_clients, payer, mint, creator, amount, priority_fee, lookup_table_key, recent_blockhash).await
}
pub async fn sell_by_amount_with_tip(
fee_clients: Vec<Arc<FeeClient>>,
payer: Arc<Keypair>,
mint: Pubkey,
creator: Pubkey,
amount: u64,
priority_fee: PriorityFee,
lookup_table_key: Option<Pubkey>,
recent_blockhash: Hash,
) -> Result<(), anyhow::Error> {
if amount == 0 {
return Err(anyhow!("Amount must be greater than 0"));
}
sell_with_tip(fee_clients, payer, mint, creator, amount, priority_fee, lookup_table_key, recent_blockhash).await
}
/// Sell tokens using Jito
pub async fn sell_with_tip(
fee_clients: Vec<Arc<FeeClient>>,