more negative tests added

Author: Bengt Lofgren

solana/modules/matching-engine-testing/Cargo.toml

@@ -61,6 +61,37 @@ tracing-log = "0.2.0"
 once_cell = "1.8"
 anyhow = "1.0.97"
 
-[lints]
-workspace = true
+[lints.clippy]
+correctness = { priority = -1, level = "warn"}
+inconsistent_digit_grouping = "allow"
+
+### See clippy.toml.
+unnecessary_lazy_evaluations = "allow"
+or_fun_call = "warn"
+
+arithmetic_side_effects = "allow"
+as_conversions = "allow"
+cast_abs_to_unsigned = "allow"
+cast_lossless= "allow"
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_precision_loss = "deny"
+cast_sign_loss = "deny"
+eq_op = "deny"
+expect_used = "deny"
+float_cmp = "deny"
+integer_division = "allow"
+large_futures = "deny"
+large_stack_arrays = "deny"
+large_stack_frames = "deny"
+lossy_float_literal = "deny"
+manual_slice_size_calculation = "deny"
+modulo_one = "deny"
+out_of_bounds_indexing = "deny"
+overflow_check_conditional = "deny"
+panic = "allow"
+recursive_format_impl = "deny"
+todo = "allow"
+unchecked_duration_subtraction = "allow"
+unreachable = "deny"
 

solana/modules/matching-engine-testing/tests/shimful/shims_execute_order.rs

@@ -3,7 +3,6 @@ use crate::testing_engine::config::{
 };
 use crate::testing_engine::setup::{TestingContext, TransferDirection};
 use crate::testing_engine::state::TestingEngineState;
-use crate::utils::token_account::SplTokenEnum;
 
 use super::super::utils;
 use anchor_spl::token::spl_token;
@@ -107,7 +106,7 @@ pub async fn execute_order_fallback(
     let payer_signer = config
         .payer_signer
         .clone()
-        .unwrap_or_else(|| testing_context.testing_actors.owner.keypair());
+        .unwrap_or_else(|| testing_context.testing_actors.payer_signer.clone());
 
     let execute_order_fallback_fixture = create_execute_order_fallback_fixture(
         testing_context,
@@ -190,11 +189,8 @@ pub fn create_execute_order_fallback_fixture(
         &POST_MESSAGE_SHIM_PROGRAM_ID,
     )
     .0;
-    let solver = testing_context.testing_actors.solvers[config.solver_index].clone();
-    let executor_token = solver
-        .actor
-        .token_account_address(&SplTokenEnum::Usdc)
-        .unwrap();
+    let solver = config.actor_enum.get_actor(&testing_context.testing_actors);
+    let executor_token = solver.token_account_address(&config.token_enum).unwrap();
     ExecuteOrderFallbackFixture {
         cctp_message,
         post_message_sequence,
@@ -279,7 +275,7 @@ pub async fn execute_order_fallback_test(
     let payer_signer = config
         .payer_signer
         .clone()
-        .unwrap_or_else(|| testing_context.testing_actors.owner.keypair());
+        .unwrap_or_else(|| testing_context.testing_actors.payer_signer.clone());
     let execute_order_fallback_accounts =
         ExecuteOrderFallbackAccounts::new(current_state, &payer_signer.pubkey(), &fixture_accounts);
     execute_order_fallback(

solana/modules/matching-engine-testing/tests/shimful/shims_make_offer.rs

@@ -46,7 +46,7 @@ pub async fn place_initial_offer_fallback(
     let payer_signer = config
         .payer_signer
         .clone()
-        .unwrap_or_else(|| testing_context.testing_actors.owner.keypair());
+        .unwrap_or_else(|| testing_context.testing_actors.payer_signer.clone());
     let close_account_refund_recipient = current_state
         .fast_market_order()
         .unwrap()
@@ -73,6 +73,7 @@ pub async fn place_initial_offer_fallback(
     let fast_market_order =
         create_fast_market_order_state_from_vaa_data(vaa_data, close_account_refund_recipient);
     let offer_price = config.offer_price;
+    let actor_enum = config.actor;
     let offer_actor = config.actor.get_actor(&testing_context.testing_actors);
     let offer_token = match &config.custom_accounts {
         Some(custom_accounts) => match custom_accounts.offer_token_address {
@@ -186,11 +187,13 @@ pub async fn place_initial_offer_fallback(
             auction_custody_token_address,
             auction_config_address,
             initial_offer: utils::auction::AuctionOffer {
+                actor: actor_enum,
                 participant: payer_signer.pubkey(),
                 offer_token,
                 offer_price,
             },
             best_offer: utils::auction::AuctionOffer {
+                actor: actor_enum,
                 participant: payer_signer.pubkey(),
                 offer_token,
                 offer_price,

solana/modules/matching-engine-testing/tests/shimful/shims_prepare_order_response.rs

@@ -265,6 +265,7 @@ pub async fn prepare_order_response_cctp_shim(
         Some(PrepareOrderResponseShimFixture {
             prepared_order_response: prepared_order_response_pda,
             prepared_custody_token: prepared_custody_token_pda,
+            base_fee_token: accounts.base_fee_token,
         })
     } else {
         None
@@ -383,4 +384,5 @@ pub async fn prepare_order_response_test(
 pub struct PrepareOrderResponseShimFixture {
     pub prepared_order_response: Pubkey,
     pub prepared_custody_token: Pubkey,
+    pub base_fee_token: Pubkey,
 }

solana/modules/matching-engine-testing/tests/shimless/initialize.rs

@@ -2,7 +2,7 @@ use solana_program_test::ProgramTestContext;
 use solana_sdk::{
     instruction::Instruction,
     pubkey::Pubkey,
-    signature::Signer,
+    signature::{Keypair, Signer},
     transaction::{Transaction, VersionedTransaction},
 };
 
@@ -144,6 +144,7 @@ pub async fn initialize_program(
     testing_context: &TestingContext,
     test_context: &mut ProgramTestContext,
     auction_parameters_config: AuctionParametersConfig,
+    payer_signer: &Keypair,
     expected_error: Option<&ExpectedError>,
     expected_log_messages: Option<&Vec<ExpectedLog>>,
 ) -> Option<InitializeFixture> {
@@ -201,16 +202,15 @@ pub async fn initialize_program(
         data: ix_data.data(),
     };
     // Create and sign transaction
-    let mut transaction =
-        Transaction::new_with_payer(&[instruction], Some(&test_context.payer.pubkey()));
+    let mut transaction = Transaction::new_with_payer(&[instruction], Some(&payer_signer.pubkey()));
     let new_blockhash = testing_context
         .get_new_latest_blockhash(test_context)
         .await
         .expect("Could not get new blockhash");
     transaction.sign(
         &[
-            &test_context.payer,
-            &testing_context.testing_actors.owner.keypair(),
+            &payer_signer,
+            &testing_context.testing_actors.owner.keypair().as_ref(),
         ],
         new_blockhash,
     );

solana/modules/matching-engine-testing/tests/shimless/make_offer.rs

@@ -57,7 +57,7 @@ pub async fn place_initial_offer_shimless(
     let payer_signer = config
         .payer_signer
         .clone()
-        .unwrap_or_else(|| testing_context.testing_actors.owner.keypair());
+        .unwrap_or_else(|| testing_context.testing_actors.payer_signer.clone());
     let offer_actor = config.actor.get_actor(&testing_context.testing_actors);
     let offer_token = offer_actor
         .token_account_address(&config.spl_token_enum)
@@ -253,11 +253,13 @@ pub async fn place_initial_offer_shimless(
             auction_custody_token_address,
             auction_config_address,
             initial_offer: AuctionOffer {
+                actor: config.actor,
                 participant: payer_signer.pubkey(),
                 offer_token,
                 offer_price: initial_offer_ix.offer_price,
             },
             best_offer: AuctionOffer {
+                actor: config.actor,
                 participant: payer_signer.pubkey(),
                 offer_token,
                 offer_price: initial_offer_ix.offer_price,
@@ -397,6 +399,7 @@ pub async fn improve_offer(
             auction_config_address: auction_config,
             initial_offer: initial_offer.clone(),
             best_offer: AuctionOffer {
+                actor: config.actor,
                 participant: payer_signer.pubkey(),
                 offer_token,
                 offer_price,

solana/modules/matching-engine-testing/tests/shimless/mod.rs

@@ -3,5 +3,6 @@
 pub mod execute_order;
 pub mod initialize;
 pub mod make_offer;
+pub mod pause_custodian;
 pub mod prepare_order_response;
 pub mod settle_auction;

solana/modules/matching-engine-testing/tests/shimless/pause_custodian.rs

@@ -0,0 +1,71 @@
+use std::rc::Rc;
+
+use crate::testing_engine::config::ExpectedError;
+
+use crate::testing_engine::state::TestingEngineState;
+
+use anchor_lang::prelude::*;
+use anchor_lang::InstructionData;
+use matching_engine::accounts::AdminMut;
+
+use crate::testing_engine::setup::TestingContext;
+
+use matching_engine::accounts::SetPause as SetPauseAccounts;
+use matching_engine::instruction::SetPause as SetPauseIx;
+use solana_program_test::ProgramTestContext;
+use solana_sdk::instruction::Instruction;
+use solana_sdk::signature::Keypair;
+use solana_sdk::signature::Signer;
+use solana_sdk::transaction::Transaction;
+
+/// Pause the custodian
+///
+/// # Arguments
+///
+/// * `test_context` - The test context
+/// * `current_state` - The current state
+/// * `config` - The config
+///
+/// # Returns
+///
+/// The new paused state
+pub async fn set_pause(
+    test_context: &mut ProgramTestContext,
+    testing_context: &TestingContext,
+    current_state: &TestingEngineState,
+    owner_or_assistant: &Rc<Keypair>,
+    expected_error: Option<&ExpectedError>,
+    is_paused: bool,
+) -> TestingEngineState {
+    let custodian_address = current_state.initialized().unwrap().custodian_address;
+    let admin_mut = AdminMut {
+        owner_or_assistant: owner_or_assistant.pubkey(),
+        custodian: custodian_address,
+    };
+    let accounts = SetPauseAccounts { admin: admin_mut };
+    let instruction_data = SetPauseIx { pause: is_paused }.data();
+    let instruction = Instruction {
+        program_id: testing_context.get_matching_engine_program_id(),
+        accounts: accounts.to_account_metas(None),
+        data: instruction_data,
+    };
+    let transaction = Transaction::new_signed_with_payer(
+        &[instruction],
+        Some(&owner_or_assistant.pubkey()),
+        &[&owner_or_assistant],
+        test_context.last_blockhash,
+    );
+    testing_context
+        .execute_and_verify_transaction(test_context, transaction, expected_error)
+        .await;
+
+    let new_auction_state = current_state.auction_state().set_pause(is_paused);
+
+    let expect_msg = format!(
+        "Failed to set {} auction state",
+        if is_paused { "pause" } else { "unpause" }
+    );
+    current_state
+        .set_auction_state(new_auction_state)
+        .expect(&expect_msg)
+}

solana/modules/matching-engine-testing/tests/shimless/prepare_order_response.rs

@@ -28,6 +28,7 @@ use wormhole_svm_definitions::EVENT_AUTHORITY_SEED;
 pub struct PrepareOrderResponseFixture {
     pub prepared_order_response: Pubkey,
     pub prepared_custody_token: Pubkey,
+    pub base_fee_token: Pubkey,
 }
 
 /// Prepare an order response (shimless)
@@ -239,6 +240,7 @@ pub async fn prepare_order_response(
         Some(PrepareOrderResponseFixture {
             prepared_order_response: prepared_order_response_pda,
             prepared_custody_token: prepared_custody_token_pda,
+            base_fee_token: *base_fee_token_address,
         })
     } else {
         None

solana/modules/matching-engine-testing/tests/shimless/settle_auction.rs

@@ -1,5 +1,7 @@
 use crate::testing_engine::config::ExpectedError;
 use crate::testing_engine::setup::TestingContext;
+use crate::testing_engine::state::OrderPreparedState;
+use crate::testing_engine::state::TestingEngineState;
 use crate::utils::auction::AuctionState;
 
 use anchor_lang::prelude::*;
@@ -33,27 +35,34 @@ use wormhole_svm_definitions::EVENT_AUTHORITY_SEED;
 /// The new auction state if successful, otherwise the old auction state
 pub async fn settle_auction_complete(
     testing_context: &TestingContext,
+    current_state: &TestingEngineState,
     test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
-    auction_state: &AuctionState,
-    prepare_order_response_address: &Pubkey,
-    prepared_custody_token: &Pubkey,
     expected_error: Option<&ExpectedError>,
 ) -> AuctionState {
+    let auction_state = current_state.auction_state();
+    let order_prepared_state = current_state
+        .order_prepared()
+        .expect("Order prepared not found");
+    let OrderPreparedState {
+        prepared_order_response_address,
+        prepared_custody_token,
+        base_fee_token,
+        actor_enum: _,
+    } = *order_prepared_state;
+
     let matching_engine_program_id = testing_context.get_matching_engine_program_id();
-    let usdc_mint_address = &testing_context.get_usdc_mint_address();
     let active_auction = auction_state
         .get_active_auction()
         .expect("Failed to get active auction");
-    let base_fee_token = *usdc_mint_address;
     let event_seeds = EVENT_AUTHORITY_SEED;
     let event_authority =
         Pubkey::find_program_address(&[event_seeds], &matching_engine_program_id).0;
     let settle_auction_accounts = SettleAuctionCompleteCpiAccounts {
         beneficiary: payer_signer.pubkey(),
         base_fee_token,
-        prepared_order_response: *prepare_order_response_address,
-        prepared_custody_token: *prepared_custody_token,
+        prepared_order_response: prepared_order_response_address,
+        prepared_custody_token,
         auction: active_auction.auction_address,
         best_offer_token: active_auction.best_offer.offer_token,
         token_program: spl_token::ID,