fix: disallow target account when creating position for integrity pool

staking/integration-tests/src/staking/instructions.rs

@@ -148,7 +148,7 @@ pub fn create_position(
     target_with_parameters: TargetWithParameters,
     pool_authority: Option<&Keypair>,
     amount: frac64,
-) {
+) -> TransactionResult {
     let config_pubkey = get_config_address();
     let stake_account_metadata = get_stake_account_metadata_address(stake_account_positions);
     let stake_account_custody = get_stake_account_custody_address(stake_account_positions);
@@ -194,7 +194,7 @@ pub fn create_position(
         svm.latest_blockhash(),
     );
 
-    svm.send_transaction(create_position_tx).unwrap();
+    svm.send_transaction(create_position_tx)
 }
 
 pub fn close_position(

staking/integration-tests/tests/merge_delegation_positions.rs

@@ -99,7 +99,8 @@ fn test_merge_delegation_positions() {
         TargetWithParameters::Voting,
         None,
         3,
-    );
+    )
+    .unwrap();
 
     let mut stake_positions_account = fetch_positions_account(&mut svm, &stake_account_positions);
     let positions = stake_positions_account.to_dynamic_position_array();
@@ -179,7 +180,8 @@ fn test_merge_delegation_positions() {
         TargetWithParameters::Voting,
         None,
         5,
-    );
+    )
+    .unwrap();
 
     delegate(
         &mut svm,

staking/integration-tests/tests/pool_authority.rs

@@ -0,0 +1,143 @@
+use {
+    anchor_lang::{
+        system_program,
+        InstructionData,
+        ToAccountMetas,
+    },
+    integration_tests::{
+        assert_anchor_program_error,
+        setup::{
+            setup,
+            SetupProps,
+            SetupResult,
+        },
+        staking::{
+            helper_functions::initialize_new_stake_account,
+            instructions::{
+                create_position,
+                update_pool_authority,
+            },
+            pda::{
+                get_config_address,
+                get_stake_account_custody_address,
+                get_stake_account_metadata_address,
+                get_target_address,
+            },
+        },
+    },
+    integrity_pool::utils::types::FRAC_64_MULTIPLIER,
+    solana_sdk::{
+        instruction::Instruction,
+        signature::Keypair,
+        signer::Signer,
+        transaction::Transaction,
+    },
+    staking::error::ErrorCode,
+};
+
+
+#[test]
+fn test_pool_authority() {
+    let SetupResult {
+        mut svm,
+        payer,
+        pyth_token_mint,
+        publisher_keypair,
+        pool_data_pubkey: _,
+        reward_program_authority: _,
+        maybe_publisher_index: _,
+    } = setup(SetupProps {
+        init_config:     true,
+        init_target:     true,
+        init_mint:       true,
+        init_pool_data:  true,
+        init_publishers: true,
+    });
+
+    let stake_account_positions =
+        initialize_new_stake_account(&mut svm, &payer, &pyth_token_mint, true, true);
+
+    let pool_authority = Keypair::new();
+
+    update_pool_authority(&mut svm, &payer, pool_authority.pubkey());
+
+    create_position(
+        &mut svm,
+        &payer,
+        stake_account_positions,
+        staking::state::positions::TargetWithParameters::IntegrityPool {
+            publisher: publisher_keypair.pubkey(),
+        },
+        Some(&pool_authority),
+        50 * FRAC_64_MULTIPLIER,
+    )
+    .unwrap();
+
+    assert_anchor_program_error!(
+        create_position(
+            &mut svm,
+            &payer,
+            stake_account_positions,
+            staking::state::positions::TargetWithParameters::IntegrityPool {
+                publisher: publisher_keypair.pubkey(),
+            },
+            None,
+            50 * FRAC_64_MULTIPLIER,
+        ),
+        ErrorCode::InvalidPoolAuthority,
+        0
+    );
+
+    create_position(
+        &mut svm,
+        &payer,
+        stake_account_positions,
+        staking::state::positions::TargetWithParameters::Voting,
+        None,
+        10 * FRAC_64_MULTIPLIER,
+    )
+    .unwrap();
+
+    let config_pubkey = get_config_address();
+    let stake_account_metadata = get_stake_account_metadata_address(stake_account_positions);
+    let stake_account_custody = get_stake_account_custody_address(stake_account_positions);
+    let voting_target_account = get_target_address();
+
+    let create_position_data = staking::instruction::CreatePosition {
+        target_with_parameters: staking::state::positions::TargetWithParameters::IntegrityPool {
+            publisher: publisher_keypair.pubkey(),
+        },
+        amount:                 10 * FRAC_64_MULTIPLIER,
+    };
+
+    let create_position_accs = staking::accounts::CreatePosition {
+        config: config_pubkey,
+        stake_account_metadata,
+        stake_account_positions,
+        stake_account_custody,
+        owner: payer.pubkey(),
+        target_account: Some(voting_target_account),
+        pool_authority: Some(pool_authority.pubkey()),
+        system_program: system_program::ID,
+    };
+
+    let create_position_ix = Instruction::new_with_bytes(
+        staking::ID,
+        &create_position_data.data(),
+        create_position_accs.to_account_metas(None),
+    );
+
+
+    let create_position_tx = Transaction::new_signed_with_payer(
+        &[create_position_ix],
+        Some(&payer.pubkey()),
+        &[&payer, &pool_authority],
+        svm.latest_blockhash(),
+    );
+
+    assert_anchor_program_error!(
+        svm.send_transaction(create_position_tx),
+        ErrorCode::UnexpectedTargetAccount,
+        0
+    );
+}

staking/integration-tests/tests/stability.rs

@@ -669,7 +669,8 @@ fn test_stability(props: StabilityTestProps) {
                     TargetWithParameters::Voting {},
                     None,
                     *amount,
-                );
+                )
+                .unwrap();
                 operation_counts.get_mut(&operation.get_name()).unwrap().0 += 1;
             }
             Operation::CloseGovernancePosition { delegator, amount } => {

staking/integration-tests/tests/staking_slash.rs

@@ -80,15 +80,17 @@ fn test_staking_slash() {
         },
         Some(&pool_authority),
         50 * FRAC_64_MULTIPLIER,
-    );
+    )
+    .unwrap();
     create_position(
         &mut svm,
         &payer,
         stake_account_positions,
         staking::state::positions::TargetWithParameters::Voting,
         None,
         10 * FRAC_64_MULTIPLIER,
-    );
+    )
+    .unwrap();
     svm.expire_blockhash();
 
     create_position(
@@ -98,7 +100,8 @@ fn test_staking_slash() {
         staking::state::positions::TargetWithParameters::Voting,
         None,
         80 * FRAC_64_MULTIPLIER,
-    );
+    )
+    .unwrap();
 
     let stake_account_metadata = get_stake_account_metadata_address(stake_account_positions);
     let metadata_account: StakeAccountMetadataV2 =

staking/integration-tests/tests/voting.rs

@@ -63,8 +63,8 @@ const MAINNET_ELAPSED_EPOCHS: u64 = 2850;
 /// This test has two purposes:
 /// 1) to test the voting functionality against the deployed governance program and configuration
 /// 2) to test that the new staking account is compatible with stake account positions with the old
-///     fixed sized position array and such accounts can be turned into the new version by calling
-///     merge_target_positions and nothing breaks
+///    fixed sized position array and such accounts can be turned into the new version by calling
+///    merge_target_positions and nothing breaks
 fn test_voting() {
     let SetupResult {
         mut svm,
@@ -135,7 +135,8 @@ fn test_voting() {
         TargetWithParameters::Voting,
         None,
         100,
-    );
+    )
+    .unwrap();
 
     let mut positions_account = fetch_positions_account(&mut svm, &stake_account_positions);
     let positions = positions_account.to_dynamic_position_array();

staking/programs/staking/src/error.rs

@@ -82,6 +82,8 @@ pub enum ErrorCode {
     MissingTargetAccount,
     #[msg("The slash ratio should be between 0 and 1")] // 6038
     InvalidSlashRatio,
-    #[msg("Other")] //6039
+    #[msg("The target account is not allowed for this operation")] // 6039
+    UnexpectedTargetAccount,
+    #[msg("Other")] //6040
     Other,
 }

staking/programs/staking/src/lib.rs

@@ -189,6 +189,10 @@ pub mod staking {
         }
 
         if let TargetWithParameters::IntegrityPool { .. } = target_with_parameters {
+            require!(
+                maybe_target_account.is_none(),
+                ErrorCode::UnexpectedTargetAccount
+            );
             require!(
                 ctx.accounts
                     .pool_authority

staking/target/idl/staking.json

@@ -2594,6 +2594,11 @@
     },
     {
       "code": 6039,
+      "name": "UnexpectedTargetAccount",
+      "msg": "The target account is not allowed for this operation"
+    },
+    {
+      "code": 6040,
       "name": "Other",
       "msg": "Other"
     }

staking/target/types/staking.ts

@@ -2600,6 +2600,11 @@ export type Staking = {
     },
     {
       "code": 6039,
+      "name": "unexpectedTargetAccount",
+      "msg": "The target account is not allowed for this operation"
+    },
+    {
+      "code": 6040,
       "name": "other",
       "msg": "other"
     }