rebuild sdk dir

2025-07-10 02:38:06 +08:00
parent 1540fb6469
commit 8f79c3bfd9
24 changed files with 348 additions and 195 deletions
@@ -0,0 +1,284 @@
+use anyhow::{anyhow, Result};
+use solana_sdk::{instruction::Instruction, pubkey::Pubkey, signer::Signer};
+use spl_associated_token_account::instruction::create_associated_token_account_idempotent;
+
+use crate::{
+    constants::bonk::{
+        accounts, trade::DEFAULT_SLIPPAGE, BUY_EXECT_IN_DISCRIMINATOR, SELL_EXECT_IN_DISCRIMINATOR,
+    },
+    trading::bonk::{
+        common::{get_amount_out, get_pool_pda, get_token_balance, get_vault_pda},
+        pool::Pool,
+    },
+    trading::core::{
+        params::{BuyParams, BonkParams, SellParams},
+        traits::InstructionBuilder,
+    },
+};
+
+/// Bonk协议的指令构建器
+pub struct BonkInstructionBuilder;
+
+#[async_trait::async_trait]
+impl InstructionBuilder for BonkInstructionBuilder {
+    async fn build_buy_instructions(&self, params: &BuyParams) -> Result<Vec<Instruction>> {
+        if params.amount_sol == 0 {
+            return Err(anyhow!("Amount cannot be zero"));
+        }
+        self.build_buy_instructions_with_accounts(params).await
+    }
+
+    async fn build_sell_instructions(&self, params: &SellParams) -> Result<Vec<Instruction>> {
+        self.build_sell_instructions_with_accounts(params).await
+    }
+}
+
+impl BonkInstructionBuilder {
+    /// 使用提供的账户信息构建买入指令
+    async fn build_buy_instructions_with_accounts(
+        &self,
+        params: &BuyParams,
+    ) -> Result<Vec<Instruction>> {
+        let protocol_params = params
+            .protocol_params
+            .as_any()
+            .downcast_ref::<BonkParams>()
+            .ok_or_else(|| anyhow!("Invalid protocol params for Bonk"))?;
+
+        let pool_state = get_pool_pda(&params.mint, &accounts::WSOL_TOKEN_ACCOUNT).unwrap();
+
+        // 创建用户代币账户
+        let user_base_token_account = spl_associated_token_account::get_associated_token_address(
+            &params.payer.pubkey(),
+            &params.mint,
+        );
+        let user_quote_token_account = spl_associated_token_account::get_associated_token_address(
+            &params.payer.pubkey(),
+            &accounts::WSOL_TOKEN_ACCOUNT,
+        );
+
+        // 获取池的代币账户
+        let base_vault_account = get_vault_pda(&pool_state, &params.mint).unwrap();
+        let quote_vault_account =
+            get_vault_pda(&pool_state, &accounts::WSOL_TOKEN_ACCOUNT).unwrap();
+
+        let mut virtual_base = protocol_params.virtual_base.unwrap_or(0);
+        let mut virtual_quote = protocol_params.virtual_quote.unwrap_or(0);
+        let mut real_base_before = protocol_params.real_base_before.unwrap_or(0);
+        let mut real_quote_before = protocol_params.real_quote_before.unwrap_or(0);
+
+        if virtual_base == 0
+            || virtual_quote == 0
+            || real_base_before == 0
+            || real_quote_before == 0
+        {
+            let pool = Pool::fetch(params.rpc.as_ref().unwrap(), &pool_state).await?;
+            virtual_base = pool.virtual_base as u128;
+            virtual_quote = pool.virtual_quote as u128;
+            real_base_before = pool.real_base as u128;
+            real_quote_before = pool.real_quote as u128;
+        }
+
+        let amount_in: u64 = params.amount_sol;
+        let share_fee_rate: u64 = 0;
+        let minimum_amount_out: u64 = get_amount_out(
+            amount_in,
+            accounts::PROTOCOL_FEE_RATE,
+            accounts::PLATFORM_FEE_RATE,
+            accounts::SHARE_FEE_RATE,
+            virtual_base,
+            virtual_quote,
+            real_base_before,
+            real_quote_before,
+            params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE) as u128,
+        );
+
+        let mut instructions = vec![];
+
+        if protocol_params.auto_handle_wsol {
+            // 插入wsol
+            instructions.push(
+                // 创建wSOL ATA账户，如果不存在
+                create_associated_token_account_idempotent(
+                    &params.payer.pubkey(),
+                    &params.payer.pubkey(),
+                    &accounts::WSOL_TOKEN_ACCOUNT,
+                    &accounts::TOKEN_PROGRAM,
+                ),
+            );
+            instructions.push(
+                // 将SOL转入wSOL ATA账户
+                solana_sdk::system_instruction::transfer(
+                    &params.payer.pubkey(),
+                    &user_quote_token_account,
+                    amount_in,
+                ),
+            );
+
+            // 同步wSOL余额
+            instructions.push(
+                spl_token::instruction::sync_native(
+                    &accounts::TOKEN_PROGRAM,
+                    &user_quote_token_account,
+                )
+                .unwrap(),
+            );
+        }
+
+        // 创建用户的基础代币账户
+        instructions.push(create_associated_token_account_idempotent(
+            &params.payer.pubkey(),
+            &params.payer.pubkey(),
+            &params.mint,
+            &accounts::TOKEN_PROGRAM,
+        ));
+
+        // 创建买入指令
+        let accounts = vec![
+            solana_sdk::instruction::AccountMeta::new(params.payer.pubkey(), true), // Payer (signer)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::AUTHORITY, false), // Authority (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::GLOBAL_CONFIG, false), // Global Config (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::PLATFORM_CONFIG, false), // Platform Config (readonly)
+            solana_sdk::instruction::AccountMeta::new(pool_state, false), // Pool State
+            solana_sdk::instruction::AccountMeta::new(user_base_token_account, false), // User Base Token
+            solana_sdk::instruction::AccountMeta::new(user_quote_token_account, false), // User Quote Token
+            solana_sdk::instruction::AccountMeta::new(base_vault_account, false), // Base Vault
+            solana_sdk::instruction::AccountMeta::new(quote_vault_account, false), // Quote Vault
+            solana_sdk::instruction::AccountMeta::new(params.mint, false), // Base Token Mint (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::WSOL_TOKEN_ACCOUNT, false), // Quote Token Mint (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::TOKEN_PROGRAM, false), // Base Token Program (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::TOKEN_PROGRAM, false), // Quote Token Program (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::EVENT_AUTHORITY, false), // Event Authority (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::BONK, false), // Program (readonly)
+        ];
+        // 创建指令数据
+        let mut data = vec![];
+        data.extend_from_slice(&BUY_EXECT_IN_DISCRIMINATOR);
+        data.extend_from_slice(&amount_in.to_le_bytes());
+        data.extend_from_slice(&minimum_amount_out.to_le_bytes());
+        data.extend_from_slice(&share_fee_rate.to_le_bytes());
+
+        instructions.push(Instruction {
+            program_id: accounts::BONK,
+            accounts,
+            data,
+        });
+
+        if protocol_params.auto_handle_wsol {
+            // 关闭wSOL ATA账户，回收租金
+            instructions.push(
+                spl_token::instruction::close_account(
+                    &accounts::TOKEN_PROGRAM,
+                    &user_quote_token_account,
+                    &params.payer.pubkey(),
+                    &params.payer.pubkey(),
+                    &[],
+                )
+                .unwrap(),
+            );
+        }
+
+        Ok(instructions)
+    }
+
+    /// 使用提供的账户信息构建卖出指令
+    async fn build_sell_instructions_with_accounts(
+        &self,
+        params: &SellParams,
+    ) -> Result<Vec<Instruction>> {
+        if params.rpc.is_none() {
+            return Err(anyhow!("RPC is not set"));
+        }
+        let rpc = params.rpc.as_ref().unwrap().clone();
+
+        // 获取代币余额
+        let mut amount = params.amount_token;
+        if params.amount_token.is_none() || params.amount_token.unwrap_or(0) == 0 {
+            let balance_u64 =
+                get_token_balance(rpc.as_ref(), &params.payer.pubkey(), &params.mint).await?;
+            amount = Some(balance_u64);
+        }
+        let amount = amount.unwrap_or(0);
+
+        if amount == 0 {
+            return Err(anyhow!("Amount cannot be zero"));
+        }
+
+        // 计算预期的SOL数量
+        let minimum_amount_out: u64 = 1;
+
+        let pool_state = get_pool_pda(&params.mint, &accounts::WSOL_TOKEN_ACCOUNT).unwrap();
+
+        // 创建用户代币账户
+        let user_base_token_account = spl_associated_token_account::get_associated_token_address(
+            &params.payer.pubkey(),
+            &params.mint,
+        );
+        let user_quote_token_account = spl_associated_token_account::get_associated_token_address(
+            &params.payer.pubkey(),
+            &accounts::WSOL_TOKEN_ACCOUNT,
+        );
+
+        // 获取池的代币账户
+        let base_vault_account = get_vault_pda(&pool_state, &params.mint).unwrap();
+        let quote_vault_account =
+            get_vault_pda(&pool_state, &accounts::WSOL_TOKEN_ACCOUNT).unwrap();
+
+        let share_fee_rate: u64 = 0;
+
+        let mut instructions = vec![];
+
+        // 插入wsol
+        instructions.push(
+            // 创建wSOL ATA账户，如果不存在
+            create_associated_token_account_idempotent(
+                &params.payer.pubkey(),
+                &params.payer.pubkey(),
+                &accounts::WSOL_TOKEN_ACCOUNT,
+                &accounts::TOKEN_PROGRAM,
+            ),
+        );
+
+        // 创建用户的代币账户
+        instructions.push(create_associated_token_account_idempotent(
+            &params.payer.pubkey(),
+            &params.payer.pubkey(),
+            &params.mint,
+            &accounts::TOKEN_PROGRAM,
+        ));
+
+        // 创建卖出指令
+        let accounts = vec![
+            solana_sdk::instruction::AccountMeta::new(params.payer.pubkey(), true), // Payer (signer)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::AUTHORITY, false), // Authority (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::GLOBAL_CONFIG, false), // Global Config (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::PLATFORM_CONFIG, false), // Platform Config (readonly)
+            solana_sdk::instruction::AccountMeta::new(pool_state, false), // Pool State
+            solana_sdk::instruction::AccountMeta::new(user_base_token_account, false), // User Base Token
+            solana_sdk::instruction::AccountMeta::new(user_quote_token_account, false), // User Quote Token
+            solana_sdk::instruction::AccountMeta::new(base_vault_account, false), // Base Vault
+            solana_sdk::instruction::AccountMeta::new(quote_vault_account, false), // Quote Vault
+            solana_sdk::instruction::AccountMeta::new(params.mint, false), // Base Token Mint (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::WSOL_TOKEN_ACCOUNT, false), // Quote Token Mint (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::TOKEN_PROGRAM, false), // Base Token Program (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::TOKEN_PROGRAM, false), // Quote Token Program (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::EVENT_AUTHORITY, false), // Event Authority (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::BONK, false), // Program (readonly)
+        ];
+
+        // 创建指令数据
+        let mut data = vec![];
+        data.extend_from_slice(&SELL_EXECT_IN_DISCRIMINATOR);
+        data.extend_from_slice(&amount.to_le_bytes());
+        data.extend_from_slice(&minimum_amount_out.to_le_bytes());
+        data.extend_from_slice(&share_fee_rate.to_le_bytes());
+
+        instructions.push(Instruction {
+            program_id: accounts::BONK,
+            accounts,
+            data,
+        });
+
+        Ok(instructions)
+    }
+}
@@ -11,7 +11,7 @@
 //! - `sell`: Instruction to sell tokens back to the bonding curve in exchange for SOL.
 use crate::{
    constants, 
-    pumpfun::common::{
+    trading::pumpfun::common::{
        get_bonding_curve_pda, get_global_pda, get_metadata_pda, get_mint_authority_pda
    },
 };
@@ -24,6 +24,10 @@ use solana_sdk::{
    signer::Signer,
 };

+pub mod pumpfun;
+pub mod pumpswap;
+pub mod bonk;
+
 pub struct Create {
    pub _name: String,
    pub _symbol: String,
@@ -0,0 +1,298 @@
+use anyhow::{anyhow, Result};
+use solana_sdk::{
+    instruction::Instruction, native_token::sol_to_lamports,
+};
+use spl_associated_token_account::{
+    get_associated_token_address, instruction::create_associated_token_account,
+};
+use spl_token::instruction::close_account;
+
+use crate::{
+    constants, trading::pumpfun::common::{
+        get_bonding_curve_pda, get_global_pda, get_metadata_pda, get_mint_authority_pda
+    }
+};
+
+use solana_sdk::{
+    instruction::AccountMeta,
+    pubkey::Pubkey,
+    signature::Keypair,
+    signer::Signer,
+};
+
+use crate::{
+    constants::pumpfun::{global_constants::FEE_RECIPIENT, trade::DEFAULT_SLIPPAGE},
+    trading::pumpfun::common::{
+        calculate_with_slippage_buy, get_buy_token_amount_from_sol_amount, get_creator_vault_pda,
+    },
+    trading::core::{
+        params::{BuyParams, PumpFunParams, SellParams},
+        traits::InstructionBuilder,
+    },
+};
+
+/// PumpFun协议的指令构建器
+pub struct PumpFunInstructionBuilder;
+
+#[async_trait::async_trait]
+impl InstructionBuilder for PumpFunInstructionBuilder {
+    async fn build_buy_instructions(&self, params: &BuyParams) -> Result<Vec<Instruction>> {
+        // 获取PumpFun特定参数
+        let protocol_params = params
+            .protocol_params
+            .as_any()
+            .downcast_ref::<PumpFunParams>()
+            .ok_or_else(|| anyhow!("Invalid protocol params for PumpFun"))?;
+
+        if params.amount_sol == 0 {
+            return Err(anyhow!("Amount cannot be zero"));
+        }
+
+        let bonding_curve = if protocol_params.bonding_curve.is_some() {
+            protocol_params.bonding_curve.clone().unwrap()
+        } else {
+            return Err(anyhow!("Bonding curve not found"));
+        };
+
+        let max_sol_cost = calculate_with_slippage_buy(
+            params.amount_sol,
+            params
+                .slippage_basis_points
+                .unwrap_or(DEFAULT_SLIPPAGE),
+        );
+        let creator_vault_pda = bonding_curve.get_creator_vault_pda();
+
+        let mut buy_token_amount =
+            get_buy_token_amount_from_sol_amount(&bonding_curve, params.amount_sol);
+        if buy_token_amount <= 100 * 1_000_000_u64 {
+            buy_token_amount = if max_sol_cost > sol_to_lamports(0.01) {
+                25547619 * 1_000_000_u64
+            } else {
+                255476 * 1_000_000_u64
+            };
+        }
+
+        let mut instructions = vec![];
+
+        // 创建关联代币账户
+        instructions.push(create_associated_token_account(
+            &params.payer.pubkey(),
+            &params.payer.pubkey(),
+            &params.mint,
+            &constants::pumpfun::accounts::TOKEN_PROGRAM,
+        ));
+
+        // 创建买入指令
+        instructions.push(buy(
+            params.payer.as_ref(),
+            &params.mint,
+            &bonding_curve.account,
+            &creator_vault_pda,
+            &FEE_RECIPIENT,
+            Buy {
+                _amount: buy_token_amount,
+                _max_sol_cost: max_sol_cost,
+            },
+        ));
+
+        Ok(instructions)
+    }
+
+    async fn build_sell_instructions(&self, params: &SellParams) -> Result<Vec<Instruction>> {
+        let amount_token = if let Some(amount) = params.amount_token {
+            if amount == 0 {
+                return Err(anyhow!("Amount cannot be zero"));
+            }
+            amount
+        } else {
+            return Err(anyhow!("Amount token is required"));
+        };
+        let creator_vault_pda = get_creator_vault_pda(&params.creator).unwrap();
+        let ata = get_associated_token_address(&params.payer.pubkey(), &params.mint);
+
+        // 获取代币余额
+        let balance_u64 = if let Some(rpc) = &params.rpc {
+            let balance = rpc.get_token_account_balance(&ata).await?;
+            balance
+                .amount
+                .parse::<u64>()
+                .map_err(|_| anyhow!("Failed to parse token balance"))?
+        } else {
+            return Err(anyhow!("RPC client is required to get token balance"));
+        };
+
+        let mut amount_token = amount_token;
+        if amount_token > balance_u64 {
+            amount_token = balance_u64;
+        }
+
+        let mut instructions = vec![sell(
+            params.payer.as_ref(),
+            &params.mint,
+            &creator_vault_pda,
+            &FEE_RECIPIENT,
+            Sell {
+                _amount: amount_token,
+                _min_sol_output: 1,
+            },
+        )];
+
+        // 如果卖出全部代币，关闭账户
+        if amount_token >= balance_u64 {
+            instructions.push(close_account(
+                &spl_token::ID,
+                &ata,
+                &params.payer.pubkey(),
+                &params.payer.pubkey(),
+                &[&params.payer.pubkey()],
+            )?);
+        }
+
+        Ok(instructions)
+    }
+}
+
+pub struct Create {
+    pub _name: String,
+    pub _symbol: String,
+    pub _uri: String,
+    pub _creator: Pubkey,
+}
+
+impl Create {
+    pub fn data(&self) -> Vec<u8> {
+        let mut data = Vec::with_capacity(8 + 4 + self._name.len() + 4 + self._symbol.len() + 4 + self._uri.len() + 32);
+
+        // 追加 discriminator
+        data.extend_from_slice(&[24, 30, 200, 40, 5, 28, 7, 119]); // discriminator
+
+        // 添加 name 字符串长度和内容
+        data.extend_from_slice(&(self._name.len() as u32).to_le_bytes());  // 添加 name 长度
+        data.extend_from_slice(self._name.as_bytes());  // 添加 name 内容
+
+        // 添加 symbol 字符串长度和内容
+        data.extend_from_slice(&(self._symbol.len() as u32).to_le_bytes());  // 添加 symbol 长度
+        data.extend_from_slice(self._symbol.as_bytes());  // 添加 symbol 内容
+
+        // 添加 uri 字符串长度和内容
+        data.extend_from_slice(&(self._uri.len() as u32).to_le_bytes());  // 添加 uri 长度
+        data.extend_from_slice(self._uri.as_bytes());  // 添加 uri 内容
+
+        data.extend_from_slice(&self._creator.to_bytes());
+
+        data
+    }
+}
+
+pub struct Buy {
+    pub _amount: u64,
+    pub _max_sol_cost: u64,
+}
+
+impl Buy {
+    pub fn data(&self) -> Vec<u8> {
+        let mut data = Vec::with_capacity(8 + 8 + 8);
+        data.extend_from_slice(&[102, 6, 61, 18, 1, 218, 235, 234]); // discriminator
+        data.extend_from_slice(&self._amount.to_le_bytes());
+        data.extend_from_slice(&self._max_sol_cost.to_le_bytes());
+        data
+    }
+}
+
+pub struct Sell {
+    pub _amount: u64,
+    pub _min_sol_output: u64,
+}
+
+impl Sell {
+    pub fn data(&self) -> Vec<u8> {
+        let mut data = Vec::with_capacity(8 + 8 + 8);
+        data.extend_from_slice(&[51, 230, 133, 164, 1, 127, 131, 173]); // discriminator
+        data.extend_from_slice(&self._amount.to_le_bytes());
+        data.extend_from_slice(&self._min_sol_output.to_le_bytes());
+        data
+    }
+}
+
+pub fn create(payer: &Keypair, mint: &Keypair, args: Create) -> Instruction {
+    let bonding_curve: Pubkey = get_bonding_curve_pda(&mint.pubkey()).unwrap();
+    Instruction::new_with_bytes(
+        constants::pumpfun::accounts::PUMPFUN,
+        &args.data(),
+        vec![
+            AccountMeta::new(mint.pubkey(), true),
+            AccountMeta::new(get_mint_authority_pda(), false),
+            AccountMeta::new(bonding_curve, false),
+            AccountMeta::new(
+                get_associated_token_address(&bonding_curve, &mint.pubkey()),
+                false,
+            ),
+            AccountMeta::new_readonly(get_global_pda(), false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::MPL_TOKEN_METADATA, false),
+            AccountMeta::new(get_metadata_pda(&mint.pubkey()), false),
+            AccountMeta::new(payer.pubkey(), true),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::SYSTEM_PROGRAM, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::TOKEN_PROGRAM, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::ASSOCIATED_TOKEN_PROGRAM, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::RENT, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::EVENT_AUTHORITY, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::PUMPFUN, false),
+        ],
+    )
+}
+
+pub fn buy(
+    payer: &Keypair,
+    mint: &Pubkey,
+    bonding_curve_pda: &Pubkey,
+    creator_vault_pda: &Pubkey,
+    fee_recipient: &Pubkey,
+    args: Buy,
+) -> Instruction {
+    Instruction::new_with_bytes(
+        constants::pumpfun::accounts::PUMPFUN,
+        &args.data(),
+        vec![
+            AccountMeta::new_readonly(constants::pumpfun::global_constants::GLOBAL_ACCOUNT, false),
+            AccountMeta::new(*fee_recipient, false),
+            AccountMeta::new_readonly(*mint, false),
+            AccountMeta::new(*bonding_curve_pda, false),
+            AccountMeta::new(get_associated_token_address(bonding_curve_pda, mint), false),
+            AccountMeta::new(get_associated_token_address(&payer.pubkey(), mint), false),
+            AccountMeta::new(payer.pubkey(), true),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::SYSTEM_PROGRAM, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::TOKEN_PROGRAM, false),
+            AccountMeta::new(*creator_vault_pda, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::EVENT_AUTHORITY, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::PUMPFUN, false),
+        ],
+    )
+}
+
+pub fn sell(
+    payer: &Keypair,
+    mint: &Pubkey,
+    creator_vault_pda: &Pubkey,
+    fee_recipient: &Pubkey,
+    args: Sell,
+) -> Instruction {
+    let bonding_curve: Pubkey = get_bonding_curve_pda(mint).unwrap();
+    Instruction::new_with_bytes(
+        constants::pumpfun::accounts::PUMPFUN,
+        &args.data(),
+        vec![
+            AccountMeta::new_readonly(constants::pumpfun::global_constants::GLOBAL_ACCOUNT, false),
+            AccountMeta::new(*fee_recipient, false),
+            AccountMeta::new_readonly(*mint, false),
+            AccountMeta::new(bonding_curve, false),
+            AccountMeta::new(get_associated_token_address(&bonding_curve, mint), false),
+            AccountMeta::new(get_associated_token_address(&payer.pubkey(), mint), false),
+            AccountMeta::new(payer.pubkey(), true),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::SYSTEM_PROGRAM, false),
+            AccountMeta::new(*creator_vault_pda, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::TOKEN_PROGRAM, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::EVENT_AUTHORITY, false),
+            AccountMeta::new_readonly(constants::pumpfun::accounts::PUMPFUN, false),
+        ],
+    )
+}
@@ -0,0 +1,427 @@
+use anyhow::{anyhow, Result};
+use solana_sdk::{instruction::Instruction, pubkey::Pubkey, signer::Signer};
+use spl_associated_token_account::instruction::create_associated_token_account_idempotent;
+
+use crate::{
+    constants::pumpswap::{
+        accounts, trade::DEFAULT_SLIPPAGE, BUY_DISCRIMINATOR, SELL_DISCRIMINATOR,
+    },
+    trading::pumpswap::common::{
+        calculate_with_slippage_buy, calculate_with_slippage_sell, coin_creator_vault_ata,
+        coin_creator_vault_authority, find_pool, get_buy_token_amount, get_sell_sol_amount,
+        get_token_balance,
+    },
+    trading::core::{
+        params::{BuyParams, PumpSwapParams, SellParams},
+        traits::InstructionBuilder,
+    },
+};
+
+/// PumpSwap协议的指令构建器
+pub struct PumpSwapInstructionBuilder;
+
+#[async_trait::async_trait]
+impl InstructionBuilder for PumpSwapInstructionBuilder {
+    async fn build_buy_instructions(&self, params: &BuyParams) -> Result<Vec<Instruction>> {
+        // 获取PumpSwap特定参数
+        let protocol_params = params
+            .protocol_params
+            .as_any()
+            .downcast_ref::<PumpSwapParams>()
+            .ok_or_else(|| anyhow!("Invalid protocol params for PumpSwap"))?;
+
+        if params.amount_sol == 0 {
+            return Err(anyhow!("Amount cannot be zero"));
+        }
+
+        // 根据是否提供了账户信息来构建指令
+        match (
+            &protocol_params.pool,
+            &protocol_params.pool_base_token_account,
+            &protocol_params.pool_quote_token_account,
+            &protocol_params.user_base_token_account,
+            &protocol_params.user_quote_token_account,
+        ) {
+            (
+                Some(pool),
+                Some(pool_base_token_account),
+                Some(pool_quote_token_account),
+                Some(user_base_token_account),
+                Some(user_quote_token_account),
+            ) => {
+                self.build_buy_instructions_with_accounts(
+                    params,
+                    *pool,
+                    *pool_base_token_account,
+                    *pool_quote_token_account,
+                    *user_base_token_account,
+                    *user_quote_token_account,
+                    protocol_params.auto_handle_wsol,
+                )
+                .await
+            }
+            _ => self.build_buy_instructions_auto_discover(params).await,
+        }
+    }
+
+    async fn build_sell_instructions(&self, params: &SellParams) -> Result<Vec<Instruction>> {
+        // 获取PumpSwap特定参数
+        let protocol_params = params
+            .protocol_params
+            .as_any()
+            .downcast_ref::<PumpSwapParams>()
+            .ok_or_else(|| anyhow!("Invalid protocol params for PumpSwap"))?;
+
+        // 根据是否提供了账户信息来构建指令
+        match (
+            &protocol_params.pool,
+            &protocol_params.pool_base_token_account,
+            &protocol_params.pool_quote_token_account,
+            &protocol_params.user_base_token_account,
+            &protocol_params.user_quote_token_account,
+        ) {
+            (
+                Some(pool),
+                Some(pool_base_token_account),
+                Some(pool_quote_token_account),
+                Some(user_base_token_account),
+                Some(user_quote_token_account),
+            ) => {
+                self.build_sell_instructions_with_accounts(
+                    params,
+                    *pool,
+                    *pool_base_token_account,
+                    *pool_quote_token_account,
+                    *user_base_token_account,
+                    *user_quote_token_account,
+                )
+                .await
+            }
+            _ => self.build_sell_instructions_auto_discover(params).await,
+        }
+    }
+}
+
+impl PumpSwapInstructionBuilder {
+    /// 自动发现池和账户信息并构建买入指令
+    async fn build_buy_instructions_auto_discover(
+        &self,
+        params: &BuyParams,
+    ) -> Result<Vec<Instruction>> {
+        if params.rpc.is_none() {
+            return Err(anyhow!("RPC is not set"));
+        }
+        let rpc = params.rpc.as_ref().unwrap().clone();
+        // 查找池
+        let pool = find_pool(rpc.as_ref(), &params.mint).await?;
+
+        // 创建用户代币账户
+        let user_base_token_account = spl_associated_token_account::get_associated_token_address(
+            &params.payer.pubkey(),
+            &params.mint,
+        );
+        let user_quote_token_account = spl_associated_token_account::get_associated_token_address(
+            &params.payer.pubkey(),
+            &accounts::WSOL_TOKEN_ACCOUNT,
+        );
+
+        // 获取池的代币账户
+        let pool_base_token_account =
+            spl_associated_token_account::get_associated_token_address_with_program_id(
+                &pool,
+                &params.mint,
+                &accounts::TOKEN_PROGRAM,
+            );
+
+        let pool_quote_token_account =
+            spl_associated_token_account::get_associated_token_address_with_program_id(
+                &pool,
+                &accounts::WSOL_TOKEN_ACCOUNT,
+                &accounts::TOKEN_PROGRAM,
+            );
+
+        self.build_buy_instructions_with_accounts(
+            params,
+            pool,
+            pool_base_token_account,
+            pool_quote_token_account,
+            user_base_token_account,
+            user_quote_token_account,
+            true,
+        )
+        .await
+    }
+
+    /// 自动发现池和账户信息并构建卖出指令
+    async fn build_sell_instructions_auto_discover(
+        &self,
+        params: &SellParams,
+    ) -> Result<Vec<Instruction>> {
+        if params.rpc.is_none() {
+            return Err(anyhow!("RPC is not set"));
+        }
+        let rpc = params.rpc.as_ref().unwrap().clone();
+
+        // 查找池
+        let pool = find_pool(rpc.as_ref(), &params.mint).await?;
+
+        // 创建用户代币账户
+        let user_base_token_account = spl_associated_token_account::get_associated_token_address(
+            &params.payer.pubkey(),
+            &params.mint,
+        );
+        let user_quote_token_account = spl_associated_token_account::get_associated_token_address(
+            &params.payer.pubkey(),
+            &accounts::WSOL_TOKEN_ACCOUNT,
+        );
+
+        // 获取池的代币账户
+        let pool_base_token_account =
+            spl_associated_token_account::get_associated_token_address_with_program_id(
+                &pool,
+                &params.mint,
+                &accounts::TOKEN_PROGRAM,
+            );
+
+        let pool_quote_token_account =
+            spl_associated_token_account::get_associated_token_address_with_program_id(
+                &pool,
+                &accounts::WSOL_TOKEN_ACCOUNT,
+                &accounts::TOKEN_PROGRAM,
+            );
+
+        self.build_sell_instructions_with_accounts(
+            params,
+            pool,
+            pool_base_token_account,
+            pool_quote_token_account,
+            user_base_token_account,
+            user_quote_token_account,
+        )
+        .await
+    }
+
+    /// 使用提供的账户信息构建买入指令
+    async fn build_buy_instructions_with_accounts(
+        &self,
+        params: &BuyParams,
+        pool: Pubkey,
+        pool_base_token_account: Pubkey,
+        pool_quote_token_account: Pubkey,
+        user_base_token_account: Pubkey,
+        user_quote_token_account: Pubkey,
+        auto_handle_wsol: bool,
+    ) -> Result<Vec<Instruction>> {
+        if params.rpc.is_none() {
+            return Err(anyhow!("RPC is not set"));
+        }
+        let rpc = params.rpc.as_ref().unwrap().clone();
+        // 计算预期的代币数量
+        let token_amount = get_buy_token_amount(rpc.as_ref(), &pool, params.amount_sol).await?;
+
+        // 计算滑点后的最大SOL数量
+        let max_sol_amount = calculate_with_slippage_buy(
+            params.amount_sol,
+            params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE),
+        );
+
+        let mut instructions = vec![];
+
+        if auto_handle_wsol {
+            // 插入wsol
+            instructions.push(
+                // 创建wSOL ATA账户，如果不存在
+                create_associated_token_account_idempotent(
+                    &params.payer.pubkey(),
+                    &params.payer.pubkey(),
+                    &accounts::WSOL_TOKEN_ACCOUNT,
+                    &accounts::TOKEN_PROGRAM,
+                ),
+            );
+            instructions.push(
+                // 将SOL转入wSOL ATA账户
+                solana_sdk::system_instruction::transfer(
+                    &params.payer.pubkey(),
+                    &user_quote_token_account,
+                    max_sol_amount,
+                ),
+            );
+
+            // 同步wSOL余额
+            instructions.push(
+                spl_token::instruction::sync_native(
+                    &accounts::TOKEN_PROGRAM,
+                    &user_quote_token_account,
+                )
+                .unwrap(),
+            );
+        }
+
+        // 创建用户的基础代币账户
+        instructions.push(create_associated_token_account_idempotent(
+            &params.payer.pubkey(),
+            &params.payer.pubkey(),
+            &params.mint,
+            &accounts::TOKEN_PROGRAM,
+        ));
+
+        let coin_creator_vault_ata = coin_creator_vault_ata(params.creator);
+        let coin_creator_vault_authority = coin_creator_vault_authority(params.creator);
+
+        // 创建买入指令
+        let accounts = vec![
+            solana_sdk::instruction::AccountMeta::new_readonly(pool, false), // pool_id (readonly)
+            solana_sdk::instruction::AccountMeta::new(params.payer.pubkey(), true), // user (signer)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::GLOBAL_ACCOUNT, false), // global (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(params.mint, false), // mint (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::WSOL_TOKEN_ACCOUNT, false), // WSOL_TOKEN_ACCOUNT (readonly)
+            solana_sdk::instruction::AccountMeta::new(user_base_token_account, false), // user_base_token_account
+            solana_sdk::instruction::AccountMeta::new(user_quote_token_account, false), // user_quote_token_account
+            solana_sdk::instruction::AccountMeta::new(pool_base_token_account, false), // pool_base_token_account
+            solana_sdk::instruction::AccountMeta::new(pool_quote_token_account, false), // pool_quote_token_account
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::FEE_RECIPIENT, false), // fee_recipient (readonly)
+            solana_sdk::instruction::AccountMeta::new(accounts::FEE_RECIPIENT_ATA, false), // fee_recipient_ata
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::TOKEN_PROGRAM, false), // TOKEN_PROGRAM_ID (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::TOKEN_PROGRAM, false), // TOKEN_PROGRAM_ID (readonly, duplicated as in JS)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::SYSTEM_PROGRAM, false), // System Program (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(
+                accounts::ASSOCIATED_TOKEN_PROGRAM,
+                false,
+            ), // ASSOCIATED_TOKEN_PROGRAM_ID (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::EVENT_AUTHORITY, false), // event_authority (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::AMM_PROGRAM, false), // PUMP_AMM_PROGRAM_ID (readonly)
+            solana_sdk::instruction::AccountMeta::new(coin_creator_vault_ata, false), // coin_creator_vault_ata
+            solana_sdk::instruction::AccountMeta::new_readonly(coin_creator_vault_authority, false), // coin_creator_vault_authority (readonly)
+        ];
+
+        // 创建指令数据
+        let mut data = vec![];
+        data.extend_from_slice(&BUY_DISCRIMINATOR);
+        data.extend_from_slice(&token_amount.to_le_bytes());
+        data.extend_from_slice(&max_sol_amount.to_le_bytes());
+
+        instructions.push(Instruction {
+            program_id: accounts::AMM_PROGRAM,
+            accounts,
+            data,
+        });
+
+        if auto_handle_wsol {
+            // 关闭wSOL ATA账户，回收租金
+            instructions.push(
+                spl_token::instruction::close_account(
+                    &accounts::TOKEN_PROGRAM,
+                    &user_quote_token_account,
+                    &params.payer.pubkey(),
+                    &params.payer.pubkey(),
+                    &[],
+                )
+                .unwrap(),
+            );
+        }
+
+        Ok(instructions)
+    }
+
+    /// 使用提供的账户信息构建卖出指令
+    async fn build_sell_instructions_with_accounts(
+        &self,
+        params: &SellParams,
+        pool: Pubkey,
+        pool_base_token_account: Pubkey,
+        pool_quote_token_account: Pubkey,
+        user_base_token_account: Pubkey,
+        user_quote_token_account: Pubkey,
+    ) -> Result<Vec<Instruction>> {
+        if params.rpc.is_none() {
+            return Err(anyhow!("RPC is not set"));
+        }
+        let rpc = params.rpc.as_ref().unwrap().clone();
+
+        // 获取代币余额
+        let mut amount = params.amount_token;
+        if params.amount_token.is_none() {
+            let (balance_u64, _) =
+                get_token_balance(rpc.as_ref(), params.payer.as_ref(), &params.mint).await?;
+            amount = Some(balance_u64);
+        }
+        let amount = amount.unwrap_or(0);
+
+        if amount == 0 {
+            return Err(anyhow!("Amount cannot be zero"));
+        }
+
+        // 计算预期的SOL数量
+        let sol_amount = get_sell_sol_amount(rpc.as_ref(), &pool, amount).await?;
+
+        // 计算滑点后的最小SOL数量
+        let min_sol_amount = calculate_with_slippage_sell(
+            sol_amount,
+            params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE),
+        );
+
+        let coin_creator_vault_ata = coin_creator_vault_ata(params.creator);
+        let coin_creator_vault_authority = coin_creator_vault_authority(params.creator);
+
+        let mut instructions = vec![];
+
+        // 插入wsol
+        instructions.push(
+            // 创建wSOL ATA账户，如果不存在
+            create_associated_token_account_idempotent(
+                &params.payer.pubkey(),
+                &params.payer.pubkey(),
+                &accounts::WSOL_TOKEN_ACCOUNT,
+                &accounts::TOKEN_PROGRAM,
+            ),
+        );
+
+        // 创建用户的代币账户
+        instructions.push(create_associated_token_account_idempotent(
+            &params.payer.pubkey(),
+            &params.payer.pubkey(),
+            &params.mint,
+            &accounts::TOKEN_PROGRAM,
+        ));
+
+        // 创建卖出指令
+        let accounts = vec![
+            solana_sdk::instruction::AccountMeta::new_readonly(pool, false), // pool_id (readonly)
+            solana_sdk::instruction::AccountMeta::new(params.payer.pubkey(), true), // user (signer)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::GLOBAL_ACCOUNT, false), // global (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(params.mint, false), // mint (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::WSOL_TOKEN_ACCOUNT, false), // WSOL_TOKEN_ACCOUNT (readonly)
+            solana_sdk::instruction::AccountMeta::new(user_base_token_account, false), // user_base_token_account
+            solana_sdk::instruction::AccountMeta::new(user_quote_token_account, false), // user_quote_token_account
+            solana_sdk::instruction::AccountMeta::new(pool_base_token_account, false), // pool_base_token_account
+            solana_sdk::instruction::AccountMeta::new(pool_quote_token_account, false), // pool_quote_token_account
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::FEE_RECIPIENT, false), // fee_recipient (readonly)
+            solana_sdk::instruction::AccountMeta::new(accounts::FEE_RECIPIENT_ATA, false), // fee_recipient_ata
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::TOKEN_PROGRAM, false), // TOKEN_PROGRAM_ID (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::TOKEN_PROGRAM, false), // TOKEN_PROGRAM_ID (readonly, duplicated as in JS)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::SYSTEM_PROGRAM, false), // System Program (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(
+                accounts::ASSOCIATED_TOKEN_PROGRAM,
+                false,
+            ), // ASSOCIATED_TOKEN_PROGRAM_ID (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::EVENT_AUTHORITY, false), // event_authority (readonly)
+            solana_sdk::instruction::AccountMeta::new_readonly(accounts::AMM_PROGRAM, false), // PUMP_AMM_PROGRAM_ID (readonly)
+            solana_sdk::instruction::AccountMeta::new(coin_creator_vault_ata, false), // coin_creator_vault_ata
+            solana_sdk::instruction::AccountMeta::new_readonly(coin_creator_vault_authority, false), // coin_creator_vault_authority (readonly)
+        ];
+
+        // 创建指令数据
+        let mut data = vec![];
+        data.extend_from_slice(&SELL_DISCRIMINATOR);
+        data.extend_from_slice(&amount.to_le_bytes());
+        data.extend_from_slice(&min_sol_amount.to_le_bytes());
+
+        instructions.push(Instruction {
+            program_id: accounts::AMM_PROGRAM,
+            accounts,
+            data,
+        });
+
+        Ok(instructions)
+    }
+}