L-03: Slippage protection (#58)

* fix: slippage

* fix: conflicts

* fix: conflicts

Author: aoikurokawa

cli/src/interceptor.rs

@@ -176,7 +176,11 @@ pub enum StakeDepositInterceptorActions {
 
         /// Amount of pool tokens to withdraw
         #[arg(long)]
-        amount: u64,
+        pool_tokens_in: u64,
+
+        /// Minimum amount of lamports to receive
+        #[arg(long)]
+        minimum_lamports_out: Option<u64>,
     },
 
     /// Fund hopper

cli/src/interceptor_handler.rs

@@ -333,7 +333,8 @@ impl StakeDepositInterceptorCliHandler {
                         user_stake_authority,
                         fee_rebate_recipient,
                         spl_stake_pool_program_id,
-                        amount,
+                        pool_tokens_in,
+                        minimum_lamports_out,
                     },
             } => {
                 self.withdraw_stake_whitelisted(
@@ -344,7 +345,8 @@ impl StakeDepositInterceptorCliHandler {
                     user_stake_authority,
                     fee_rebate_recipient,
                     spl_stake_pool_program_id,
-                    amount,
+                    pool_tokens_in,
+                    minimum_lamports_out,
                 )
                 .await
             }
@@ -926,7 +928,8 @@ impl StakeDepositInterceptorCliHandler {
         user_stake_authority: Pubkey,
         fee_rebate_recipient: Pubkey,
         spl_stake_pool_program_id: Pubkey,
-        amount: u64,
+        pool_tokens_in: u64,
+        minimum_lamports_out: Option<u64>,
     ) -> anyhow::Result<()> {
         let rpc_client = self.get_rpc_client();
 
@@ -985,7 +988,12 @@ impl StakeDepositInterceptorCliHandler {
             .clock(solana_clock::Clock::id())
             .stake_program(solana_stake_interface::program::id())
             .spl_stake_pool_program(spl_stake_pool_program_id)
-            .amount(amount);
+            .pool_tokens_in(pool_tokens_in);
+
+        if let Some(lamports_out) = minimum_lamports_out {
+            ix_builder.minimum_lamports_out(lamports_out);
+        }
+
         let mut ix = ix_builder.instruction();
         ix.program_id = self.stake_deposit_interceptor_program_id;
 

clients/rust/stake-deposit-interceptor/src/generated/instructions/deposit_stake_whitelisted.rs

@@ -54,13 +54,17 @@ pub struct DepositStakeWhitelisted {
 }
 
 impl DepositStakeWhitelisted {
-    pub fn instruction(&self) -> solana_instruction::Instruction {
-        self.instruction_with_remaining_accounts(&[])
+    pub fn instruction(
+        &self,
+        args: DepositStakeWhitelistedInstructionArgs,
+    ) -> solana_instruction::Instruction {
+        self.instruction_with_remaining_accounts(args, &[])
     }
     #[allow(clippy::arithmetic_side_effects)]
     #[allow(clippy::vec_init_then_push)]
     pub fn instruction_with_remaining_accounts(
         &self,
+        args: DepositStakeWhitelistedInstructionArgs,
         remaining_accounts: &[solana_instruction::AccountMeta],
     ) -> solana_instruction::Instruction {
         let mut accounts = Vec::with_capacity(19 + remaining_accounts.len());
@@ -134,9 +138,11 @@ impl DepositStakeWhitelisted {
             false,
         ));
         accounts.extend_from_slice(remaining_accounts);
-        let data = DepositStakeWhitelistedInstructionData::new()
+        let mut data = DepositStakeWhitelistedInstructionData::new()
             .try_to_vec()
             .unwrap();
+        let mut args = args.try_to_vec().unwrap();
+        data.append(&mut args);
 
         solana_instruction::Instruction {
             program_id: crate::STAKE_DEPOSIT_INTERCEPTOR_ID,
@@ -168,6 +174,18 @@ impl Default for DepositStakeWhitelistedInstructionData {
     }
 }
 
+#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct DepositStakeWhitelistedInstructionArgs {
+    pub minimum_pool_tokens_out: Option<u64>,
+}
+
+impl DepositStakeWhitelistedInstructionArgs {
+    pub(crate) fn try_to_vec(&self) -> Result<Vec<u8>, std::io::Error> {
+        borsh::to_vec(self)
+    }
+}
+
 /// Instruction builder for `DepositStakeWhitelisted`.
 ///
 /// ### Accounts:
@@ -212,6 +230,7 @@ pub struct DepositStakeWhitelistedBuilder {
     stake_program: Option<solana_pubkey::Pubkey>,
     spl_stake_pool_program: Option<solana_pubkey::Pubkey>,
     system_program: Option<solana_pubkey::Pubkey>,
+    minimum_pool_tokens_out: Option<u64>,
     __remaining_accounts: Vec<solana_instruction::AccountMeta>,
 }
 
@@ -344,6 +363,12 @@ impl DepositStakeWhitelistedBuilder {
         self.system_program = Some(system_program);
         self
     }
+    /// `[optional argument]`
+    #[inline(always)]
+    pub fn minimum_pool_tokens_out(&mut self, minimum_pool_tokens_out: u64) -> &mut Self {
+        self.minimum_pool_tokens_out = Some(minimum_pool_tokens_out);
+        self
+    }
     /// Add an additional account to the instruction.
     #[inline(always)]
     pub fn add_remaining_account(&mut self, account: solana_instruction::AccountMeta) -> &mut Self {
@@ -398,8 +423,11 @@ impl DepositStakeWhitelistedBuilder {
                 .system_program
                 .unwrap_or(solana_pubkey::pubkey!("11111111111111111111111111111111")),
         };
+        let args = DepositStakeWhitelistedInstructionArgs {
+            minimum_pool_tokens_out: self.minimum_pool_tokens_out.clone(),
+        };
 
-        accounts.instruction_with_remaining_accounts(&self.__remaining_accounts)
+        accounts.instruction_with_remaining_accounts(args, &self.__remaining_accounts)
     }
 }
 
@@ -487,12 +515,15 @@ pub struct DepositStakeWhitelistedCpi<'a, 'b> {
     pub spl_stake_pool_program: &'b solana_account_info::AccountInfo<'a>,
     /// System program
     pub system_program: &'b solana_account_info::AccountInfo<'a>,
+    /// The arguments for the instruction.
+    pub __args: DepositStakeWhitelistedInstructionArgs,
 }
 
 impl<'a, 'b> DepositStakeWhitelistedCpi<'a, 'b> {
     pub fn new(
         program: &'b solana_account_info::AccountInfo<'a>,
         accounts: DepositStakeWhitelistedCpiAccounts<'a, 'b>,
+        args: DepositStakeWhitelistedInstructionArgs,
     ) -> Self {
         Self {
             __program: program,
@@ -515,6 +546,7 @@ impl<'a, 'b> DepositStakeWhitelistedCpi<'a, 'b> {
             stake_program: accounts.stake_program,
             spl_stake_pool_program: accounts.spl_stake_pool_program,
             system_program: accounts.system_program,
+            __args: args,
         }
     }
     #[inline(always)]
@@ -624,9 +656,11 @@ impl<'a, 'b> DepositStakeWhitelistedCpi<'a, 'b> {
                 is_writable: remaining_account.2,
             })
         });
-        let data = DepositStakeWhitelistedInstructionData::new()
+        let mut data = DepositStakeWhitelistedInstructionData::new()
             .try_to_vec()
             .unwrap();
+        let mut args = self.__args.try_to_vec().unwrap();
+        data.append(&mut args);
 
         let instruction = solana_instruction::Instruction {
             program_id: crate::STAKE_DEPOSIT_INTERCEPTOR_ID,
@@ -717,6 +751,7 @@ impl<'a, 'b> DepositStakeWhitelistedCpiBuilder<'a, 'b> {
             stake_program: None,
             spl_stake_pool_program: None,
             system_program: None,
+            minimum_pool_tokens_out: None,
             __remaining_accounts: Vec::new(),
         });
         Self { instruction }
@@ -883,6 +918,12 @@ impl<'a, 'b> DepositStakeWhitelistedCpiBuilder<'a, 'b> {
         self.instruction.system_program = Some(system_program);
         self
     }
+    /// `[optional argument]`
+    #[inline(always)]
+    pub fn minimum_pool_tokens_out(&mut self, minimum_pool_tokens_out: u64) -> &mut Self {
+        self.instruction.minimum_pool_tokens_out = Some(minimum_pool_tokens_out);
+        self
+    }
     /// Add an additional account to the instruction.
     #[inline(always)]
     pub fn add_remaining_account(
@@ -917,6 +958,9 @@ impl<'a, 'b> DepositStakeWhitelistedCpiBuilder<'a, 'b> {
     #[allow(clippy::clone_on_copy)]
     #[allow(clippy::vec_init_then_push)]
     pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
+        let args = DepositStakeWhitelistedInstructionArgs {
+            minimum_pool_tokens_out: self.instruction.minimum_pool_tokens_out.clone(),
+        };
         let instruction = DepositStakeWhitelistedCpi {
             __program: self.instruction.__program,
 
@@ -1002,6 +1046,7 @@ impl<'a, 'b> DepositStakeWhitelistedCpiBuilder<'a, 'b> {
                 .instruction
                 .system_program
                 .expect("system_program is not set"),
+            __args: args,
         };
         instruction.invoke_signed_with_remaining_accounts(
             signers_seeds,
@@ -1032,6 +1077,7 @@ struct DepositStakeWhitelistedCpiBuilderInstruction<'a, 'b> {
     stake_program: Option<&'b solana_account_info::AccountInfo<'a>>,
     spl_stake_pool_program: Option<&'b solana_account_info::AccountInfo<'a>>,
     system_program: Option<&'b solana_account_info::AccountInfo<'a>>,
+    minimum_pool_tokens_out: Option<u64>,
     /// Additional instruction accounts `(AccountInfo, is_writable, is_signer)`.
     __remaining_accounts: Vec<(&'b solana_account_info::AccountInfo<'a>, bool, bool)>,
 }

clients/rust/stake-deposit-interceptor/src/generated/instructions/withdraw_stake_whitelisted.rs

@@ -183,7 +183,8 @@ impl Default for WithdrawStakeWhitelistedInstructionData {
 #[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct WithdrawStakeWhitelistedInstructionArgs {
-    pub amount: u64,
+    pub pool_tokens_in: u64,
+    pub minimum_lamports_out: u64,
 }
 
 impl WithdrawStakeWhitelistedInstructionArgs {
@@ -238,7 +239,8 @@ pub struct WithdrawStakeWhitelistedBuilder {
     stake_program: Option<solana_pubkey::Pubkey>,
     spl_stake_pool_program: Option<solana_pubkey::Pubkey>,
     system_program: Option<solana_pubkey::Pubkey>,
-    amount: Option<u64>,
+    pool_tokens_in: Option<u64>,
+    minimum_lamports_out: Option<u64>,
     __remaining_accounts: Vec<solana_instruction::AccountMeta>,
 }
 
@@ -387,8 +389,13 @@ impl WithdrawStakeWhitelistedBuilder {
         self
     }
     #[inline(always)]
-    pub fn amount(&mut self, amount: u64) -> &mut Self {
-        self.amount = Some(amount);
+    pub fn pool_tokens_in(&mut self, pool_tokens_in: u64) -> &mut Self {
+        self.pool_tokens_in = Some(pool_tokens_in);
+        self
+    }
+    #[inline(always)]
+    pub fn minimum_lamports_out(&mut self, minimum_lamports_out: u64) -> &mut Self {
+        self.minimum_lamports_out = Some(minimum_lamports_out);
         self
     }
     /// Add an additional account to the instruction.
@@ -455,7 +462,14 @@ impl WithdrawStakeWhitelistedBuilder {
                 .unwrap_or(solana_pubkey::pubkey!("11111111111111111111111111111111")),
         };
         let args = WithdrawStakeWhitelistedInstructionArgs {
-            amount: self.amount.clone().expect("amount is not set"),
+            pool_tokens_in: self
+                .pool_tokens_in
+                .clone()
+                .expect("pool_tokens_in is not set"),
+            minimum_lamports_out: self
+                .minimum_lamports_out
+                .clone()
+                .expect("minimum_lamports_out is not set"),
         };
 
         accounts.instruction_with_remaining_accounts(args, &self.__remaining_accounts)
@@ -794,7 +808,8 @@ impl<'a, 'b> WithdrawStakeWhitelistedCpiBuilder<'a, 'b> {
             stake_program: None,
             spl_stake_pool_program: None,
             system_program: None,
-            amount: None,
+            pool_tokens_in: None,
+            minimum_lamports_out: None,
             __remaining_accounts: Vec::new(),
         });
         Self { instruction }
@@ -971,8 +986,13 @@ impl<'a, 'b> WithdrawStakeWhitelistedCpiBuilder<'a, 'b> {
         self
     }
     #[inline(always)]
-    pub fn amount(&mut self, amount: u64) -> &mut Self {
-        self.instruction.amount = Some(amount);
+    pub fn pool_tokens_in(&mut self, pool_tokens_in: u64) -> &mut Self {
+        self.instruction.pool_tokens_in = Some(pool_tokens_in);
+        self
+    }
+    #[inline(always)]
+    pub fn minimum_lamports_out(&mut self, minimum_lamports_out: u64) -> &mut Self {
+        self.instruction.minimum_lamports_out = Some(minimum_lamports_out);
         self
     }
     /// Add an additional account to the instruction.
@@ -1010,7 +1030,16 @@ impl<'a, 'b> WithdrawStakeWhitelistedCpiBuilder<'a, 'b> {
     #[allow(clippy::vec_init_then_push)]
     pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
         let args = WithdrawStakeWhitelistedInstructionArgs {
-            amount: self.instruction.amount.clone().expect("amount is not set"),
+            pool_tokens_in: self
+                .instruction
+                .pool_tokens_in
+                .clone()
+                .expect("pool_tokens_in is not set"),
+            minimum_lamports_out: self
+                .instruction
+                .minimum_lamports_out
+                .clone()
+                .expect("minimum_lamports_out is not set"),
         };
         let instruction = WithdrawStakeWhitelistedCpi {
             __program: self.instruction.__program,
@@ -1134,7 +1163,8 @@ struct WithdrawStakeWhitelistedCpiBuilderInstruction<'a, 'b> {
     stake_program: Option<&'b solana_account_info::AccountInfo<'a>>,
     spl_stake_pool_program: Option<&'b solana_account_info::AccountInfo<'a>>,
     system_program: Option<&'b solana_account_info::AccountInfo<'a>>,
-    amount: Option<u64>,
+    pool_tokens_in: Option<u64>,
+    minimum_lamports_out: Option<u64>,
     /// Additional instruction accounts `(AccountInfo, is_writable, is_signer)`.
     __remaining_accounts: Vec<(&'b solana_account_info::AccountInfo<'a>, bool, bool)>,
 }

stake_deposit_interceptor/idl/stake_deposit_interceptor.json

@@ -772,7 +772,14 @@
           ]
         }
       ],
-      "args": [],
+      "args": [
+        {
+          "name": "minimumPoolTokensOut",
+          "type": {
+            "option": "u64"
+          }
+        }
+      ],
       "discriminant": {
         "type": "u8",
         "value": 6
@@ -944,7 +951,11 @@
       ],
       "args": [
         {
-          "name": "amount",
+          "name": "poolTokensIn",
+          "type": "u64"
+        },
+        {
+          "name": "minimumLamportsOut",
           "type": "u64"
         }
       ],

stake_deposit_interceptor/src/instruction.rs

@@ -412,7 +412,9 @@ pub enum StakeDepositInterceptorInstruction {
     #[account(16, name = "stake_program", desc = "Stake program id")]
     #[account(17, name = "spl_stake_pool_program", desc = "SPL Stake Pool Program")]
     #[account(18, name = "system_program", desc = "System program")]
-    DepositStakeWhitelisted,
+    DepositStakeWhitelisted {
+        minimum_pool_tokens_out: Option<u64>,
+    },
 
     /// Wraps spl-stake-pool WithdrawStake with whitelist verification.
     ///
@@ -501,7 +503,10 @@ pub enum StakeDepositInterceptorInstruction {
     #[account(17, name = "stake_program", desc = "Stake program id")]
     #[account(18, name = "spl_stake_pool_program", desc = "SPL Stake Pool Program")]
     #[account(19, name = "system_program", desc = "System program")]
-    WithdrawStakeWhitelisted { amount: u64 },
+    WithdrawStakeWhitelisted {
+        pool_tokens_in: u64,
+        minimum_lamports_out: u64,
+    },
 }
 
 pub const STAKE_POOL_DEPOSIT_STAKE_AUTHORITY: &[u8] = b"deposit_stake_authority";