stake-pool: Update fee changes only once per epoch (#2269)

* fix

* test for withdrawal fee

* merge conflict changes

Author: jon-chuang

stake-pool/program/src/processor.rs

@@ -1651,16 +1651,18 @@ impl Processor {
                 .ok_or(StakePoolError::CalculationFailure)?;
         }
 
-        if let Some(next_epoch_fee) = stake_pool.next_epoch_fee {
-            stake_pool.fee = next_epoch_fee;
-            stake_pool.next_epoch_fee = None;
-        }
-        if let Some(next_withdrawal_fee) = stake_pool.next_withdrawal_fee {
-            stake_pool.withdrawal_fee = next_withdrawal_fee;
-            stake_pool.next_withdrawal_fee = None;
+        if stake_pool.last_update_epoch < clock.epoch {
+            if let Some(next_epoch_fee) = stake_pool.next_epoch_fee {
+                stake_pool.fee = next_epoch_fee;
+                stake_pool.next_epoch_fee = None;
+            }
+            if let Some(next_withdrawal_fee) = stake_pool.next_withdrawal_fee {
+                stake_pool.withdrawal_fee = next_withdrawal_fee;
+                stake_pool.next_withdrawal_fee = None;
+            }
+            stake_pool.last_update_epoch = clock.epoch;
         }
         stake_pool.total_stake_lamports = total_stake_lamports;
-        stake_pool.last_update_epoch = clock.epoch;
 
         let pool_mint = Mint::unpack_from_slice(&pool_mint_info.data.borrow())?;
         stake_pool.pool_token_supply = pool_mint.supply;

stake-pool/program/tests/set_withdrawal_fee.rs

@@ -105,6 +105,117 @@ async fn success() {
     assert_eq!(stake_pool.next_withdrawal_fee, None);
 }
 
+#[tokio::test]
+async fn success_fee_cannot_increase_more_than_once() {
+    let (mut context, stake_pool_accounts, new_withdrawal_fee) = setup(None).await;
+
+    let stake_pool = get_account(
+        &mut context.banks_client,
+        &stake_pool_accounts.stake_pool.pubkey(),
+    )
+    .await;
+    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool.data.as_slice()).unwrap();
+    let old_withdrawal_fee = stake_pool.withdrawal_fee;
+
+    let transaction = Transaction::new_signed_with_payer(
+        &[instruction::set_fee(
+            &id(),
+            &stake_pool_accounts.stake_pool.pubkey(),
+            &stake_pool_accounts.manager.pubkey(),
+            FeeType::Withdrawal(new_withdrawal_fee),
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &stake_pool_accounts.manager],
+        context.last_blockhash,
+    );
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    let stake_pool = get_account(
+        &mut context.banks_client,
+        &stake_pool_accounts.stake_pool.pubkey(),
+    )
+    .await;
+    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool.data.as_slice()).unwrap();
+
+    assert_eq!(stake_pool.withdrawal_fee, old_withdrawal_fee);
+    assert_eq!(stake_pool.next_withdrawal_fee, Some(new_withdrawal_fee));
+
+    let first_normal_slot = context.genesis_config().epoch_schedule.first_normal_slot;
+    let slots_per_epoch = context.genesis_config().epoch_schedule.slots_per_epoch;
+
+    context
+        .warp_to_slot(first_normal_slot + slots_per_epoch)
+        .unwrap();
+    stake_pool_accounts
+        .update_all(
+            &mut context.banks_client,
+            &context.payer,
+            &context.last_blockhash,
+            &[],
+            false,
+        )
+        .await;
+
+    let stake_pool = get_account(
+        &mut context.banks_client,
+        &stake_pool_accounts.stake_pool.pubkey(),
+    )
+    .await;
+    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool.data.as_slice()).unwrap();
+    assert_eq!(stake_pool.withdrawal_fee, new_withdrawal_fee);
+    assert_eq!(stake_pool.next_withdrawal_fee, None);
+
+    // try setting to the old fee in the same epoch
+    let transaction = Transaction::new_signed_with_payer(
+        &[instruction::set_fee(
+            &id(),
+            &stake_pool_accounts.stake_pool.pubkey(),
+            &stake_pool_accounts.manager.pubkey(),
+            FeeType::Withdrawal(old_withdrawal_fee),
+        )],
+        Some(&context.payer.pubkey()),
+        &[&context.payer, &stake_pool_accounts.manager],
+        context.last_blockhash,
+    );
+    context
+        .banks_client
+        .process_transaction(transaction)
+        .await
+        .unwrap();
+
+    let stake_pool = get_account(
+        &mut context.banks_client,
+        &stake_pool_accounts.stake_pool.pubkey(),
+    )
+    .await;
+    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool.data.as_slice()).unwrap();
+    assert_eq!(stake_pool.withdrawal_fee, new_withdrawal_fee);
+    assert_eq!(stake_pool.next_withdrawal_fee, Some(old_withdrawal_fee));
+
+    let error = stake_pool_accounts
+        .update_stake_pool_balance(
+            &mut context.banks_client,
+            &context.payer,
+            &context.last_blockhash,
+        )
+        .await;
+    assert!(error.is_none());
+
+    // Check that nothing has changed after updating the stake pool
+    let stake_pool = get_account(
+        &mut context.banks_client,
+        &stake_pool_accounts.stake_pool.pubkey(),
+    )
+    .await;
+    let stake_pool = try_from_slice_unchecked::<StakePool>(&stake_pool.data.as_slice()).unwrap();
+    assert_eq!(stake_pool.withdrawal_fee, new_withdrawal_fee);
+    assert_eq!(stake_pool.next_withdrawal_fee, Some(old_withdrawal_fee));
+}
+
 #[tokio::test]
 async fn success_increase_fee_from_0() {
     let (mut context, stake_pool_accounts, _) = setup(Some(Fee {