fix pump upgrade

src/pumpfun/buy.rs

@@ -146,17 +146,12 @@ pub async fn build_buy_instructions(
         return Err(anyhow!("Amount cannot be zero"));
     }
 
-    let rpc = rpc.as_ref();
-    let global_account = get_global_account(rpc).await?;
-    let buy_amount = match get_bonding_curve_account(rpc, mint.as_ref()).await {
-        Ok(account) => account.get_buy_price(amount_sol).map_err(|e| anyhow!(e))?,
-        Err(_e) => {
-            println!("Bonding curve account not found, using initial buy price: {}", _e);
-            let initial_buy_amount = get_initial_buy_price(&global_account, amount_sol).await?;
-            initial_buy_amount * 80 / 100
-        }
-    };
-    let buy_amount_with_slippage = calculate_with_slippage_buy(amount_sol, slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE));
+    let (bonding_curve_account, bonding_curve_pda) = get_bonding_curve_account(&rpc, &mint).await?;
+
+    let creator_vault_pda = get_creator_vault_pda(&bonding_curve_account.creator).unwrap();
+
+    let (buy_token_amount, max_sol_cost) = get_buy_token_amount(&bonding_curve_account, buy_sol_cost, slippage_basis_points)?;
+
     let mut instructions = vec![];
     instructions.push(create_associated_token_account(
         &payer.pubkey(),
@@ -168,10 +163,12 @@ pub async fn build_buy_instructions(
     instructions.push(instruction::buy(
         payer.as_ref(),
         &mint,
+        &bonding_curve_pda,
+        &creator_vault_pda,
         &global_account.fee_recipient,
         instruction::Buy {
-            _amount: buy_amount,
-            _max_sol_cost: buy_amount_with_slippage,
+            _amount: buy_token_amount,
+            _max_sol_cost: max_sol_cost,
         },
     ));
 

src/pumpfun/common.rs

@@ -88,9 +88,7 @@ pub async fn get_token_balance_and_ata(rpc: &SolanaRpcClient, payer: &Keypair, m
 
 #[inline]
 pub async fn get_sol_balance(rpc: &SolanaRpcClient, account: &Pubkey) -> Result<u64, anyhow::Error> {
-    println!("get_sol_balance account: {}", account);
     let balance = rpc.get_balance(account).await?;
-    println!("get_sol_balance balance: {}", balance);
     Ok(balance)
 }
 
@@ -118,6 +116,14 @@ pub fn get_bonding_curve_pda(mint: &Pubkey) -> Option<Pubkey> {
     pda.map(|pubkey| pubkey.0)
 }
 
+#[inline]
+pub fn get_creator_vault_pda(creator: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[constants::seeds::CREATOR_VAULT_SEED, creator.as_ref()];
+    let program_id: &Pubkey = &constants::accounts::PUMPFUN;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
 #[inline]
 pub fn get_metadata_pda(mint: &Pubkey) -> Pubkey {
     Pubkey::find_program_address(
@@ -155,7 +161,7 @@ pub async fn get_initial_buy_price(global_account: &Arc<accounts::GlobalAccount>
 pub async fn get_bonding_curve_account(
     rpc: &SolanaRpcClient,
     mint: &Pubkey,
-) -> Result<Arc<accounts::BondingCurveAccount>, anyhow::Error> {
+) -> Result<(Arc<accounts::BondingCurveAccount>, Pubkey), anyhow::Error> {
     let bonding_curve_pda = get_bonding_curve_pda(mint)
         .ok_or(anyhow!("Bonding curve not found"))?;
 
@@ -164,8 +170,22 @@ pub async fn get_bonding_curve_account(
         return Err(anyhow!("Bonding curve not found"));
     }
 
-    let bonding_curve = Arc::new(accounts::BondingCurveAccount::try_from_slice(&account.data)?);
-    Ok(bonding_curve)
+    let bonding_curve = Arc::new(bincode::deserialize::<accounts::BondingCurveAccount>(&account.data)?);
+
+    Ok((bonding_curve, bonding_curve_pda))
+}
+
+#[inline]
+pub fn get_buy_token_amount(
+    bonding_curve_account: &BondingCurveAccount,
+    buy_sol_cost: u64,
+    slippage_basis_points: Option<u64>,
+) -> anyhow::Result<(u64, u64)> {
+    let buy_token = bonding_curve_account.get_buy_price(buy_sol_cost).map_err(|e| anyhow!(e))?;
+
+    let max_sol_cost = calculate_with_slippage_buy(buy_sol_cost, slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE));
+
+    Ok((buy_token, max_sol_cost))
 }
 
 #[inline]

src/pumpfun/sell.rs

@@ -196,7 +196,7 @@ pub async fn build_sell_instructions(
     }
     
     let global_account = get_global_account(rpc.as_ref()).await?;
-    let bonding_curve_account = get_bonding_curve_account(rpc.as_ref(), &mint).await?;
+    let (bonding_curve_account, bonding_curve_pda) = get_bonding_curve_account(&rpc, &mint).await?;
     let min_sol_output = bonding_curve_account
         .get_sell_price(amount, global_account.fee_basis_points)
         .map_err(|e| anyhow!(e))?;
@@ -205,10 +205,14 @@ pub async fn build_sell_instructions(
         slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE),
     );
 
+    let creator_vault_pda = get_creator_vault_pda(&bonding_curve_account.creator).unwrap();
+
     let instructions = vec![
         instruction::sell(
             payer.as_ref(),
             &mint,
+            &bonding_curve_pda,
+            &creator_vault_pda,
             &global_account.fee_recipient,
             instruction::Sell {
                 _amount: amount,