Merge branch 'main' into test_branch

Author: dappboris-dev

keys/test-kp.json

@@ -83,4 +83,7 @@ pub enum ContractError {
 
     #[msg("Invalid Fee Receiver")]
     InvalidFeeReceiver,
+
+    #[msg("Invalid Migration Authority")]
+    InvalidMigrationAuthority,
 }

programs/pump-science/src/errors.rs

@@ -141,13 +141,15 @@ impl Swap<'_> {
                 .apply_sell(exact_in_amount)
                 .ok_or(ContractError::SellFailed)?;
 
+            msg!("SellResult: {:#?}", sell_result);
+
             sol_amount = sell_result.sol_amount;
             token_amount = sell_result.token_amount;
+
             let clock = Clock::get()?;
             fee_lamports = bonding_curve.calculate_fee(sol_amount, clock.unix_timestamp)?;
-
-            msg!("SellResult: {:#?}", sell_result);
             msg!("Fee: {} SOL", fee_lamports); // lamports to SOL
+
             Swap::complete_sell(&ctx, sell_result.clone(), min_out_amount, fee_lamports)?;
         } else {
             // Buy tokens
@@ -157,14 +159,15 @@ impl Swap<'_> {
                 .apply_buy(exact_in_amount)
                 .ok_or(ContractError::BuyFailed)?;
 
+            msg!("BuyResult: {:#?}", buy_result);
+
             sol_amount = buy_result.sol_amount;
             token_amount = buy_result.token_amount;
+
             let clock = Clock::get()?;
             fee_lamports = bonding_curve.calculate_fee(sol_amount, clock.unix_timestamp)?;
             msg!("Fee: {} lamports", fee_lamports);
 
-            msg!("BuyResult: {:#?}", buy_result);
-
             Swap::complete_buy(&ctx, buy_result.clone(), min_out_amount, fee_lamports)?;
 
             let bonding_curve_total_lamports = ctx.accounts.bonding_curve.get_lamports();
@@ -195,12 +198,15 @@ impl Swap<'_> {
                 locker.revoke_freeze_authority()?;
             }
         }
+
         BondingCurve::invariant(
             &mut ctx
                 .accounts
                 .into_bonding_curve_locker_ctx(ctx.bumps.bonding_curve),
         )?;
         let bonding_curve = &ctx.accounts.bonding_curve;
+
+        // Emit trade event used for indexing
         emit_cpi!(TradeEvent {
             mint: *ctx.accounts.mint.to_account_info().key,
             sol_amount: sol_amount,
@@ -214,6 +220,8 @@ impl Swap<'_> {
             real_sol_reserves: bonding_curve.real_sol_reserves,
             real_token_reserves: bonding_curve.real_token_reserves,
         });
+
+        // Emit complete event when bonding curve is completed
         if bonding_curve.complete {
             emit_cpi!(CompleteEvent {
                 user: *ctx.accounts.user.to_account_info().key,

programs/pump-science/src/instructions/curve/swap.rs

@@ -34,8 +34,8 @@ pub struct InitializePoolWithConfig<'info> {
     pub vault: AccountInfo<'info>,
 
     #[account(mut)]
-    /// CHECK: Migration vault account where fee is deposited accounts
-    pub migration_vault: UncheckedAccount<'info>,
+    /// CHECK: fee receiver asserted in handler
+    pub fee_receiver: AccountInfo<'info>,
 
     #[account(mut)]
     /// CHECK: Pool account (PDA address)
@@ -105,8 +105,7 @@ pub struct InitializePoolWithConfig<'info> {
     /// CHECK: Protocol fee token b accounts
     pub protocol_token_b_fee: UncheckedAccount<'info>,
 
-    #[account(mut)]
-    /// CHECK: Admin account
+    #[account(mut, constraint = payer.key() == global.migration_authority @ ContractError::InvalidMigrationAuthority)]
     pub payer: Signer<'info>,
 
     #[account(mut)]
@@ -162,6 +161,11 @@ pub fn initialize_pool_with_config(
         ContractError::NotCompleted
     );
 
+    require!(
+        ctx.accounts.fee_receiver.key() == ctx.accounts.global.fee_receiver,
+        ContractError::InvalidFeeReceiver
+    );
+
     let _clientbump = ctx.bumps.vault.to_le_bytes();
     let signer_seeds: &[&[&[u8]]] = &[
         &[VAULT_SEED, _clientbump.as_ref()]
@@ -260,9 +264,9 @@ pub fn pay_launch_fee(ctx: Context<InitializePoolWithConfig>) -> Result<()> {
             .bonding_curve
             .sub_lamports(fee_amount)
             .unwrap();
-        ctx.accounts
-            .migration_vault
-            .add_lamports(fee_amount)
-            .unwrap();
+    ctx.accounts
+        .fee_receiver
+        .add_lamports(fee_amount)
+        .unwrap();
     Ok(())
 }

programs/pump-science/src/instructions/migration/create_pool.rs

@@ -2,13 +2,21 @@ use anchor_lang::prelude::*;
 use anchor_lang::solana_program::{instruction::Instruction, program::invoke_signed};
 use anchor_spl::associated_token;
 use crate::constants::{VAULT_SEED, METEORA_PROGRAM_KEY};
+use crate::errors::ContractError;
+use crate::Global;
 use std::str::FromStr;
 use crate::state::meteora::{get_function_hash, get_lock_lp_ix_data};
 
-
 #[derive(Accounts)]
 pub struct LockPool<'info> {
-
+    #[account(
+        mut,
+        seeds = [Global::SEED_PREFIX.as_bytes()],
+        constraint = global.initialized == true @ ContractError::NotInitialized,
+        bump,
+    )]
+    global: Box<Account<'info, Global>>,
+    
     #[account(
         seeds = [VAULT_SEED], 
         bump
@@ -55,8 +63,7 @@ pub struct LockPool<'info> {
     /// CHECK: Accounts to bootstrap the pool with initial liquidity
     pub payer_pool_lp: UncheckedAccount<'info>,
 
-    #[account(mut)]
-    /// CHECK: Admin account
+    #[account(mut, constraint = payer.key() == global.migration_authority @ ContractError::InvalidMigrationAuthority)]
     pub payer: Signer<'info>,
 
     /// CHECK: Token program account

programs/pump-science/src/instructions/migration/lock_pool.rs

@@ -94,10 +94,30 @@ impl BondingCurve {
         msg!("ApplyBuy: token_amount: {}", token_amount);
 
         if token_amount >= self.real_token_reserves {
+            // Last Buy
             token_amount = self.real_token_reserves;
+
+            // Temporarily store the current state
+            let current_virtual_token_reserves = self.virtual_token_reserves;
+            let current_virtual_sol_reserves = self.virtual_sol_reserves;
+
+            // Update self with the new token amount
+            self.virtual_token_reserves = (current_virtual_token_reserves as u128)
+                .checked_sub(token_amount as u128)?
+                .try_into()
+                .ok()?;
+            self.virtual_sol_reserves = 115_005_359_056; // Total raise amount at end
+
             let recomputed_sol_amount = self.get_sol_for_sell_tokens(token_amount)?;
             msg!("ApplyBuy: recomputed_sol_amount: {}", recomputed_sol_amount);
             sol_amount = recomputed_sol_amount;
+
+            // Restore the state with the recomputed sol_amount
+            self.virtual_token_reserves = current_virtual_token_reserves;
+            self.virtual_sol_reserves = current_virtual_sol_reserves;
+
+            // Set complete to true
+            self.complete = true;
         }
 
         // Adjusting token reserve values
@@ -199,8 +219,12 @@ impl BondingCurve {
         }
         msg!("GetTokensForBuySol: sol_amount: {}", sol_amount);
 
-        let product_of_reserves =
-            (self.virtual_sol_reserves as u128).checked_mul(self.virtual_token_reserves as u128)?;
+        // Calculate the product of the reserves (decimal adjusted)
+        let product_of_reserves = ((self.virtual_sol_reserves as u128)
+            .checked_div(1_000_000_000)?) // Divide by 9 decimals
+        .checked_mul((self.virtual_token_reserves as u128).checked_div(1_000_000)?)? // Divide by 6 decimals
+        .checked_mul(1_000_000_000)?; // Scaling factor
+
         msg!(
             "GetTokensForBuySol: product_of_reserves: {}",
             product_of_reserves
@@ -213,7 +237,8 @@ impl BondingCurve {
         );
         let new_virtual_token_reserves = product_of_reserves
             .checked_div(new_virtual_sol_reserves)?
-            .checked_add(1)?;
+            .checked_mul(1_000_000)?; // Scale up to proper decimals again;
+
         msg!(
             "GetTokensForBuySol: new_virtual_token_reserves: {}",
             new_virtual_token_reserves
@@ -227,33 +252,42 @@ impl BondingCurve {
         Some(recv)
     }
 
-    pub fn get_sol_for_sell_tokens(&self, tokens: u64) -> Option<u64> {
-        msg!("get_sol_for_sell_tokens: tokens: {}", tokens);
-        if tokens == 0 || tokens > self.virtual_token_reserves as u64 {
+    pub fn get_sol_for_sell_tokens(&self, token_amount: u64) -> Option<u64> {
+        if token_amount == 0 {
             return None;
         }
+        msg!("GetSolForSellTokens: token_amount: {}", token_amount);
+
+        // Calculate the product of the reserves (decimal adjusted)
+        let product_of_reserves = ((self.virtual_sol_reserves as u128)
+            .checked_div(1_000_000_000)?) // Divide by 9 decimals
+        .checked_mul((self.virtual_token_reserves as u128).checked_div(1_000_000)?)? // Divide by 6 decimals
+        .checked_mul(1_000_000_000)?; // Scaling factor
 
-        let scaling_factor = self.initial_virtual_token_reserves as u128;
         msg!(
-            "get_sol_for_sell_tokens: scaling_factor: {}",
-            scaling_factor
+            "GetSolForSellTokens: product_of_reserves: {}",
+            product_of_reserves
         );
+        let new_virtual_token_reserves =
+            (self.virtual_token_reserves as u128).checked_add(token_amount as u128)?;
+        msg!(
+            "GetSolForSellTokens: new_virtual_token_reserves: {}",
+            new_virtual_token_reserves
+        );
+        let new_virtual_sol_reserves = product_of_reserves
+            .checked_div(new_virtual_token_reserves)?
+            .checked_mul(1_000_000)?; // Scale up to proper decimals again;
 
-        let scaled_tokens = (tokens as u128).checked_mul(scaling_factor)?;
-        msg!("get_sol_for_sell_tokens: scaled_tokens: {}", scaled_tokens);
-        let token_sell_proportion =
-            scaled_tokens.checked_div(self.virtual_token_reserves as u128)?;
         msg!(
-            "get_sol_for_sell_tokens: token_sell_proportion: {}",
-            token_sell_proportion
+            "GetSolForSellTokens: new_virtual_sol_reserves: {}",
+            new_virtual_sol_reserves
         );
-        let sol_received = ((self.virtual_sol_reserves as u128)
-            .checked_mul(token_sell_proportion)?)
-        .checked_div(scaling_factor)?;
-        msg!("get_sol_for_sell_tokens: sol_received: {}", sol_received);
-        let recv = <u128 as std::convert::TryInto<u64>>::try_into(sol_received).ok()?;
+        let sol_received =
+            (self.virtual_sol_reserves as u128).checked_sub(new_virtual_sol_reserves)?;
+        msg!("GetSolForSellTokens: sol_received: {}", sol_received);
 
-        msg!("get_sol_for_sell_tokens: recv: {}", recv);
+        let recv = <u128 as std::convert::TryInto<u64>>::try_into(sol_received).ok()?;
+        msg!("GetSolForSellTokens: recv: {}", recv);
         Some(recv)
     }
 

programs/pump-science/src/state/bonding_curve/curve.rs

@@ -39,7 +39,8 @@ mod tests {
         println!("{:?} \n", buy_result);
 
         assert_eq!(buy_result.token_amount, 793100000000000); // Max amount in curve
-        assert_eq!(buy_result.sol_amount, 22174277726); // Should be max cost of curve
+        assert_eq!(buy_result.sol_amount, 85007359056); // Should be max cost of curve
+        assert_eq!(curve.complete, true);
         assert_eq!(
             curve.real_token_reserves,
             curve_initial.real_token_reserves - buy_result.token_amount
@@ -118,15 +119,15 @@ mod tests {
         let curve = bc.update_from_params(mint, creator, &global, &params, &CLOCK, 0);
 
         // first apply buy
-        curve.apply_buy(1000).unwrap();
+        curve.apply_buy(1000000000).unwrap(); // 1 SOL
 
         let curve_initial: BondingCurve = curve.clone();
-        let sell_amount = 15766665; // Tokens
+        let sell_amount = 14612904000000; // Tokens
 
         let result = curve.apply_sell(sell_amount).unwrap();
         println!("{:?} \n", result);
         assert_eq!(result.token_amount, sell_amount);
-        assert_eq!(result.sol_amount, 440); // Manually assert
+        assert_eq!(result.sol_amount, 431000000); // Manually assert
         assert_eq!(
             curve.virtual_token_reserves,
             curve_initial.virtual_token_reserves + result.token_amount
@@ -161,12 +162,12 @@ mod tests {
         let curve = bc.update_from_params(mint, creator, &global, &params, &CLOCK, 0);
         let curve_initial = curve.clone();
 
-        let purchase_amount = 2000; // Lamports
+        let purchase_amount = 1000000000; // 1 SOL
 
         let result = curve.apply_buy(purchase_amount).unwrap();
         println!("{:?} \n", result);
         assert_eq!(result.sol_amount, purchase_amount);
-        assert_eq!(result.token_amount, 71533328); // Manually assert
+        assert_eq!(result.token_amount, 34612904000000); // Manually assert
         assert_eq!(
             curve.virtual_token_reserves,
             curve_initial.virtual_token_reserves - result.token_amount
@@ -197,14 +198,18 @@ mod tests {
         let mut bc = BondingCurve::default();
         let curve = bc.update_from_params(mint, creator, &global, &params, &CLOCK, 0);
 
-        // first apply buy
-        curve.apply_buy(1000).unwrap();
+        // first apply 1 SOL buy
+        let buy_result = curve.apply_buy(1000000000).unwrap();
+        println!("{:?} \n", buy_result);
 
         // Edge case: zero tokens
         assert_eq!(curve.get_sol_for_sell_tokens(0), None);
 
         // Normal case
-        assert_eq!(curve.get_sol_for_sell_tokens(15766665), Some(440));
+        assert_eq!(
+            curve.get_sol_for_sell_tokens(34612904000000),
+            Some(1001000000) // Slightly higher due to bonding curve bahaviour
+        );
 
         let real_sol_reserves = curve.real_sol_reserves;
         msg!("real_sol_reserves: {}", real_sol_reserves);
@@ -230,16 +235,26 @@ mod tests {
             start_time: Some(*START_TIME),
         };
         let mut bc = BondingCurve::default();
-        let curve = bc.update_from_params(mint, creator, &global, &params, &CLOCK, 0);
+        let mut curve = bc.update_from_params(mint, creator, &global, &params, &CLOCK, 0);
 
-        // Test case 1: Normal case
-        assert_eq!(curve.get_tokens_for_buy_sol(100), Some(3576666)); // Adjusted based on current method logic
+        // Test case 1: Normal case 0.01 SOL SOL
+        assert_eq!(curve.get_tokens_for_buy_sol(10000000), Some(357548000000));
 
-        // Test case 2: Edge case - zero SOL
+        // Test case 2: Normal case 1 SOL SOL
+        curve = bc.update_from_params(mint, creator, &global, &params, &CLOCK, 0);
+        assert_eq!(
+            curve.get_tokens_for_buy_sol(1000000000),
+            Some(34612904000000)
+        );
+
+        // Test case 3: Edge case - zero SOL
         assert_eq!(curve.get_tokens_for_buy_sol(0), None);
 
-        // Test case 4: Large SOL amount (but within limits)
-        assert_eq!(curve.get_tokens_for_buy_sol(3000), Some(107299989));
+        // Test case 5: Large SOL amount (but within limits) - 50 SOL
+        assert_eq!(
+            curve.get_tokens_for_buy_sol(50000000000),
+            Some(670625000000000) // 670M token about 66% of total supply
+        );
 
         // Test case 5: SOL amount that would exceed real token reserves
         // Check is made in apply_buy directly in order to recompute counter asset