XXX ixn introspection

Author: 2501babe

Cargo.lock

@@ -23,6 +23,7 @@ solana-borsh = "3.0"
 solana-clock = "3.0"
 solana-cpi = "3.1"
 solana-instruction = "3.0"
+solana-instructions-sysvar = "3.0"
 solana-msg = "3.1"
 solana-native-token = "3.0"
 solana-program-entrypoint = "3.1"

program/Cargo.toml

@@ -166,6 +166,7 @@ pub enum SinglePoolInstruction {
     ///   5. `[]` Stake program
     InitializePoolOnRamp,
 
+    /// HANA fix if we do this
     ///   Deposit liquid sol into the pool. The output is a "pool" token
     ///   representing fractional ownership of the pool stake. Inputs are
     ///   converted to the current ratio, less a fee of `DEPOSIT_SOL_FEE_BPS`.
@@ -386,6 +387,7 @@ pub fn deposit_liquid(
             user_token_account,
             lamports,
         ),
+        replenish_pool(program_id, vote_account_address),
     ]
 }
 
@@ -399,33 +401,25 @@ pub fn deposit_sol(
     user_token_account: &Pubkey,
     lamports: u64,
 ) -> Instruction {
+    // HANA pass pool directly
     let pool_address = find_pool_address(program_id, vote_account_address);
 
     let data = borsh::to_vec(&SinglePoolInstruction::DepositSol { lamports }).unwrap();
     let accounts = vec![
-        AccountMeta::new_readonly(*vote_account_address, false),
         AccountMeta::new_readonly(pool_address, false),
-        AccountMeta::new(find_pool_stake_address(program_id, &pool_address), false),
+        AccountMeta::new_readonly(find_pool_stake_address(program_id, &pool_address), false),
         AccountMeta::new(find_pool_onramp_address(program_id, &pool_address), false),
         AccountMeta::new(find_pool_mint_address(program_id, &pool_address), false),
-        AccountMeta::new_readonly(
-            find_pool_stake_authority_address(program_id, &pool_address),
-            false,
-        ),
         AccountMeta::new_readonly(
             find_pool_mint_authority_address(program_id, &pool_address),
             false,
         ),
         AccountMeta::new(*user_deposit_account, true),
         AccountMeta::new(*user_token_account, false),
-        AccountMeta::new_readonly(sysvar::clock::id(), false),
-        AccountMeta::new_readonly(stake_history::id(), false),
-        #[allow(deprecated)]
-        AccountMeta::new_readonly(stake::config::id(), false),
         AccountMeta::new_readonly(system_program::id(), false),
         AccountMeta::new_readonly(spl_token::id(), false),
         AccountMeta::new_readonly(stake::program::id(), false),
-        AccountMeta::new_readonly(*program_id, false),
+        AccountMeta::new_readonly(solana_instructions_sysvar::id(), false),
     ];
 
     Instruction {

program/src/instruction.rs

@@ -1550,39 +1550,27 @@ impl Processor {
         deposit_amount: u64,
     ) -> ProgramResult {
         let account_info_iter = &mut accounts.iter();
-        let vote_account_info = next_account_info(account_info_iter)?;
         let pool_info = next_account_info(account_info_iter)?;
         let pool_stake_info = next_account_info(account_info_iter)?;
         let pool_onramp_info = next_account_info(account_info_iter)?;
         let pool_mint_info = next_account_info(account_info_iter)?;
-        let pool_stake_authority_info = next_account_info(account_info_iter)?;
         let pool_mint_authority_info = next_account_info(account_info_iter)?;
         let user_lamport_account_info = next_account_info(account_info_iter)?;
         let user_token_account_info = next_account_info(account_info_iter)?;
-        let clock_info = next_account_info(account_info_iter)?;
-        let clock = &Clock::from_account_info(clock_info)?;
-        let stake_history_info = next_account_info(account_info_iter)?;
-        let stake_config_info = next_account_info(account_info_iter)?;
         let system_program_info = next_account_info(account_info_iter)?;
         let token_program_info = next_account_info(account_info_iter)?;
         let stake_program_info = next_account_info(account_info_iter)?;
+        let result_instructions_info = next_account_info(account_info_iter);
 
         let rent = Rent::get()?;
+        let clock = Clock::get()?;
         let stake_history = &StakeHistorySysvar(clock.epoch);
 
-        check_vote_account(vote_account_info)?;
-        check_pool_address(program_id, vote_account_info.key, pool_info.key)?;
-
         SinglePool::from_account_info(pool_info, program_id)?;
 
         check_pool_stake_address(program_id, pool_info.key, pool_stake_info.key)?;
         check_pool_onramp_address(program_id, pool_info.key, pool_onramp_info.key)?;
         let token_supply = check_pool_mint_with_supply(program_id, pool_info.key, pool_mint_info)?;
-        check_pool_stake_authority_address(
-            program_id,
-            pool_info.key,
-            pool_stake_authority_info.key,
-        )?;
         let mint_authority_bump_seed = check_pool_mint_authority_address(
             program_id,
             pool_info.key,
@@ -1592,6 +1580,9 @@ impl Processor {
         check_token_program(token_program_info.key)?;
         check_stake_program(stake_program_info.key)?;
 
+        let minimum_delegation = stake::tools::get_minimum_delegation()?;
+        let onramp_rent_exempt_reserve = rent.minimum_balance(pool_onramp_info.data_len());
+
         if deposit_amount == 0 {
             return Err(SinglePoolError::DepositTooSmall.into());
         }
@@ -1613,10 +1604,15 @@ impl Processor {
         };
 
         // we require onramp to exist, though we dont care what state its in
-        match deserialize_stake(pool_onramp_info) {
-            Ok(StakeStateV2::Initialized(_)) | Ok(StakeStateV2::Stake(_, _, _)) => (),
+        let pre_onramp_stake = match deserialize_stake(pool_onramp_info) {
+            Ok(StakeStateV2::Stake(_, Stake { delegation, .. }, _))
+                if delegation.deactivation_epoch == u64::MAX =>
+            {
+                delegation.stake
+            }
+            Ok(StakeStateV2::Stake(_, _, _)) | Ok(StakeStateV2::Initialized(_)) => 0,
             _ => return Err(SinglePoolError::OnRampDoesntExist.into()),
-        }
+        };
 
         // deposit source must be a system account for transfer to succeed
         if !user_lamport_account_info.is_signer
@@ -1679,21 +1675,30 @@ impl Processor {
             new_pool_tokens,
         )?;
 
-        // replenish to delegate the deposit. this safely returns Ok if onramp doesnt meet minimum delegation
-        invoke(
-            &svsp_instruction::replenish_pool(program_id, vote_account_info.key),
-            &[
-                vote_account_info.clone(),
-                pool_info.clone(),
-                pool_stake_info.clone(),
-                pool_onramp_info.clone(),
-                pool_stake_authority_info.clone(),
-                clock_info.clone(),
-                stake_history_info.clone(),
-                stake_config_info.clone(),
-                stake_program_info.clone(),
-            ],
-        )?;
+        // if there is at least minimum delegation idle, we require replenish
+        if pool_onramp_info
+            .lamports()
+            .saturating_sub(pre_onramp_stake)
+            .saturating_sub(onramp_rent_exempt_reserve)
+            >= minimum_delegation
+        {
+            let instructions_info = result_instructions_info?;
+
+            let current_index =
+                solana_instructions_sysvar::load_current_index_checked(&instructions_info)?;
+
+            let replenish_instruction = solana_instructions_sysvar::load_instruction_at_checked(
+                current_index.saturating_add(1) as usize,
+                &instructions_info,
+            )?;
+
+            if &replenish_instruction.program_id != program_id
+                || replenish_instruction.data != [1]
+                || &replenish_instruction.accounts[1].pubkey != pool_info.key
+            {
+                panic!("HANA new err");
+            }
+        }
 
         Ok(())
     }