stake-pool: Fail initializing if mint has a freeze authority (#1949)

Author: joncinque

stake-pool/program/src/error.rs

@@ -96,6 +96,9 @@ pub enum StakePoolError {
     /// The provided withdraw stake account is not the preferred deposit vote account
     #[error("IncorrectWithdrawVoteAddress")]
     IncorrectWithdrawVoteAddress,
+    /// The mint has an invalid freeze authority
+    #[error("InvalidMintFreezeAuthority")]
+    InvalidMintFreezeAuthority,
 }
 impl From<StakePoolError> for ProgramError {
     fn from(e: StakePoolError) -> Self {

stake-pool/program/src/processor.rs

@@ -488,6 +488,10 @@ impl Processor {
             return Err(StakePoolError::WrongMintingAuthority.into());
         }
 
+        if pool_mint.freeze_authority.is_some() {
+            return Err(StakePoolError::InvalidMintFreezeAuthority.into());
+        }
+
         if *reserve_stake_info.owner != stake_program::id() {
             msg!("Reserve stake account not owned by stake program");
             return Err(ProgramError::IncorrectProgramId);
@@ -2099,6 +2103,7 @@ impl PrintProgramError for StakePoolError {
             StakePoolError::StakeLamportsNotEqualToMinimum => msg!("Error: The lamports in the validator stake account is not equal to the minimum"),
             StakePoolError::IncorrectDepositVoteAddress => msg!("Error: The provided deposit stake account is not delegated to the preferred deposit vote account"),
             StakePoolError::IncorrectWithdrawVoteAddress => msg!("Error: The provided withdraw stake account is not the preferred deposit vote account"),
+            StakePoolError::InvalidMintFreezeAuthority => msg!("Error: The mint has an invalid freeze authority"),
         }
     }
 }

stake-pool/program/tests/initialize.rs

@@ -313,6 +313,89 @@ async fn fail_with_wrong_mint_authority() {
     }
 }
 
+#[tokio::test]
+async fn fail_with_freeze_authority() {
+    let (mut banks_client, payer, recent_blockhash) = program_test().start().await;
+    let stake_pool_accounts = StakePoolAccounts::new();
+
+    create_required_accounts(
+        &mut banks_client,
+        &payer,
+        &recent_blockhash,
+        &stake_pool_accounts,
+    )
+    .await;
+
+    // create mint with freeze authority
+    let wrong_mint = Keypair::new();
+    let rent = banks_client.get_rent().await.unwrap();
+    let mint_rent = rent.minimum_balance(spl_token::state::Mint::LEN);
+
+    let transaction = Transaction::new_signed_with_payer(
+        &[
+            system_instruction::create_account(
+                &payer.pubkey(),
+                &wrong_mint.pubkey(),
+                mint_rent,
+                spl_token::state::Mint::LEN as u64,
+                &spl_token::id(),
+            ),
+            spl_token::instruction::initialize_mint(
+                &spl_token::id(),
+                &wrong_mint.pubkey(),
+                &stake_pool_accounts.withdraw_authority,
+                Some(&stake_pool_accounts.withdraw_authority),
+                0,
+            )
+            .unwrap(),
+        ],
+        Some(&payer.pubkey()),
+        &[&payer, &wrong_mint],
+        recent_blockhash,
+    );
+    banks_client.process_transaction(transaction).await.unwrap();
+
+    let pool_fee_account = Keypair::new();
+    create_token_account(
+        &mut banks_client,
+        &payer,
+        &recent_blockhash,
+        &pool_fee_account,
+        &wrong_mint.pubkey(),
+        &stake_pool_accounts.manager.pubkey(),
+    )
+    .await
+    .unwrap();
+
+    let error = create_stake_pool(
+        &mut banks_client,
+        &payer,
+        &recent_blockhash,
+        &stake_pool_accounts.stake_pool,
+        &stake_pool_accounts.validator_list,
+        &stake_pool_accounts.reserve_stake.pubkey(),
+        &wrong_mint.pubkey(),
+        &pool_fee_account.pubkey(),
+        &stake_pool_accounts.manager,
+        &stake_pool_accounts.staker.pubkey(),
+        &None,
+        &stake_pool_accounts.fee,
+        stake_pool_accounts.max_validators,
+    )
+    .await
+    .err()
+    .unwrap()
+    .unwrap();
+
+    assert_eq!(
+        error,
+        TransactionError::InstructionError(
+            2,
+            InstructionError::Custom(error::StakePoolError::InvalidMintFreezeAuthority as u32),
+        )
+    );
+}
+
 #[tokio::test]
 async fn fail_with_wrong_token_program_id() {
     let (mut banks_client, payer, recent_blockhash) = program_test().start().await;