clippy auto edits

Author: Bengt Lofgren

solana/Cargo.lock

@@ -83,7 +83,7 @@ cast_possible_wrap = "deny"
 cast_precision_loss = "deny"
 cast_sign_loss = "deny"
 eq_op = "deny"
-expect_used = "allow" # TODO: Change this back once we get there
+expect_used = "deny"
 float_cmp = "deny"
 integer_division = "deny"
 large_futures = "deny"

solana/Cargo.toml

@@ -4,4 +4,7 @@ disallowed-methods = [
     { path = "std::option::Option::map_or", reason = "prefer `map_or_else` for lazy evaluation" },
     { path = "std::option::Option::ok_or", reason = "prefer `ok_or_else` for lazy evaluation" },
     { path = "std::option::Option::unwrap_or", reason = "prefer `unwrap_or_else` for lazy evaluation" },
-]
+]
+
+[expect_used]
+ignore-tests = true

solana/clippy.toml

@@ -61,6 +61,7 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 tracing-log = "0.2.0"
 once_cell = "1.8"
+anyhow = "1.0.97"
 wormhole-svm-shim.workspace = true
 wormhole-svm-definitions.workspace = true
 

solana/programs/matching-engine/Cargo.toml

@@ -119,15 +119,10 @@ pub async fn test_post_message_shims() {
         None,
     )
     .await;
-    let actors = testing_context.testing_actors;
+    let actors = &testing_context.testing_actors;
     let emitter_signer = actors.owner.keypair();
     let payer_signer = actors.solvers[0].keypair();
-    set_up_post_message_transaction_test(
-        &testing_context.test_context,
-        &payer_signer,
-        &emitter_signer,
-    )
-    .await;
+    set_up_post_message_transaction_test(&testing_context, &payer_signer, &emitter_signer).await;
 }
 
 #[tokio::test]
@@ -222,13 +217,14 @@ pub async fn test_approve_usdc() {
     // TODO: Create an issue based on this bug. So this function will transfer the ownership of whatever the guardian signatures signer is set to to the verify shim program. This means that the argument to this function MUST be ephemeral and cannot be used until the close signatures instruction has been executed.
     let (_guardian_set_pubkey, _guardian_signatures_pubkey, _guardian_set_bump) =
         shimful::verify_shim::create_guardian_signatures(
-            &testing_context.test_context,
+            &testing_context,
             &actors.owner.keypair(),
             &vaa_data,
             &CORE_BRIDGE_PROGRAM_ID,
             None,
         )
-        .await;
+        .await
+        .expect("Failed to create guardian signatures");
 
     println!("Solver USDC balance: {:?}", usdc_balance);
     let solver_token_account_address = solver.token_account_address().unwrap();

solana/programs/matching-engine/tests/integration_tests.rs

@@ -141,9 +141,7 @@ pub async fn close_fast_market_order_fallback(
     expected_error: Option<&ExpectedError>,
 ) {
     let program_id = &testing_context.get_matching_engine_program_id();
-    let test_ctx = &testing_context.test_context;
-    let recent_blockhash = test_ctx
-        .borrow_mut()
+    let recent_blockhash = testing_context
         .get_new_latest_blockhash()
         .await
         .expect("Failed to get new blockhash");
@@ -211,7 +209,7 @@ pub fn create_fast_market_order_state_from_vaa_data(
         min_amount_out: order.min_amount_out,
         deadline: order.deadline,
         target_chain: order.target_chain,
-        redeemer_message_length: order.redeemer_message.len() as u16,
+        redeemer_message_length: u16::try_from(order.redeemer_message.len()).unwrap(),
         redeemer: order.redeemer,
         sender: order.sender,
         refund_address: order.refund_address,

solana/programs/matching-engine/tests/shimful/fast_market_order_shim.rs

@@ -1,4 +1,4 @@
-use crate::utils::constants::*;
+use crate::utils::{constants::*, setup::TestingContext};
 use solana_program_test::ProgramTestContext;
 use solana_sdk::{
     compute_budget::ComputeBudgetInstruction,
@@ -36,7 +36,7 @@ impl BumpCosts {
     }
 
     fn bump_cu_cost(bump: u8) -> u64 {
-        1_500 * (255 - u64::from(bump))
+        1_500 * (255_u64.saturating_sub(u64::from(bump)))
     }
 }
 
@@ -50,12 +50,11 @@ impl BumpCosts {
 /// * `payer_signer` - The payer signer keypair
 /// * `emitter_signer` - The emitter signer keypair
 pub async fn set_up_post_message_transaction_test(
-    test_ctx: &Rc<RefCell<ProgramTestContext>>,
+    testing_context: &TestingContext,
     payer_signer: &Rc<Keypair>,
     emitter_signer: &Rc<Keypair>,
 ) {
-    let recent_blockhash = test_ctx
-        .borrow_mut()
+    let recent_blockhash = testing_context
         .get_new_latest_blockhash()
         .await
         .expect("Could not get last blockhash");
@@ -66,12 +65,14 @@ pub async fn set_up_post_message_transaction_test(
         recent_blockhash,
     );
     let details = {
-        let out = test_ctx
-            .borrow_mut()
+        let test_ctx = &testing_context.test_context;
+        let mut ctx = test_ctx.borrow_mut();
+        let out = ctx
             .banks_client
             .simulate_transaction(transaction)
             .await
             .unwrap();
+        drop(ctx);
         assert!(out.result.clone().unwrap().is_ok(), "{:?}", out.result);
         out.simulation_details.unwrap()
     };

solana/programs/matching-engine/tests/shimful/post_message.rs

@@ -36,6 +36,7 @@ use std::rc::Rc;
 ///
 /// * The expected error is reached
 /// * If successful, the solver's USDC balance should decrease by the offer price
+#[allow(clippy::too_many_arguments)]
 pub async fn place_initial_offer_fallback(
     testing_context: &TestingContext,
     payer_signer: &Rc<Keypair>,
@@ -143,7 +144,8 @@ pub async fn place_initial_offer_fallback(
                 offer_price,
             },
         };
-        let new_auction_state = utils::auction::AuctionState::Active(new_active_auction_state);
+        let new_auction_state =
+            utils::auction::AuctionState::Active(Box::new(new_active_auction_state));
         Some(InitialOfferPlacedState {
             auction_state: new_auction_state,
         })

solana/programs/matching-engine/tests/shimful/shims_make_offer.rs

@@ -1,15 +1,16 @@
-use crate::utils;
 use crate::utils::constants::*;
+use crate::utils::{self, setup::TestingContext};
 use anchor_lang::prelude::*;
-use solana_program_test::ProgramTestContext;
+use anyhow::Result as AnyhowResult;
+
 use solana_sdk::{
     compute_budget::ComputeBudgetInstruction,
     hash::Hash,
     message::{v0::Message, VersionedMessage},
     signature::{Keypair, Signer},
     transaction::VersionedTransaction,
 };
-use std::cell::RefCell;
+
 use std::rc::Rc;
 use std::str::FromStr;
 use wormhole_svm_definitions::GUARDIAN_SIGNATURE_LENGTH;
@@ -31,36 +32,34 @@ use wormhole_svm_shim::verify_vaa;
 ///
 /// * `(guardian_set_pubkey, guardian_signatures_pubkey, guardian_set_bump)` - The guardian set pubkey, the guardian signatures pubkey and the guardian set bump
 pub async fn create_guardian_signatures(
-    test_ctx: &Rc<RefCell<ProgramTestContext>>,
+    testing_context: &TestingContext,
     payer_signer: &Rc<Keypair>,
     vaa_data: &utils::vaa::PostedVaaData,
     wormhole_program_id: &Pubkey,
     guardian_signature_signer: Option<&Rc<Keypair>>,
-) -> (Pubkey, Pubkey, u8) {
+) -> AnyhowResult<(Pubkey, Pubkey, u8)> {
     let new_keypair = Rc::new(Keypair::new());
-    let guardian_signature_signer = guardian_signature_signer.unwrap_or(&new_keypair);
+    let guardian_signature_signer = guardian_signature_signer.unwrap_or_else(|| &new_keypair);
     let (guardian_set_pubkey, guardian_set_bump) =
         wormhole_svm_definitions::find_guardian_set_address(
             0_u32.to_be_bytes(),
-            &wormhole_program_id,
+            wormhole_program_id,
         );
-    let guardian_secret_key = secp256k1::SecretKey::from_str(GUARDIAN_SECRET_KEY)
-        .expect("Failed to parse guardian secret key");
+    let guardian_secret_key = secp256k1::SecretKey::from_str(GUARDIAN_SECRET_KEY)?;
     let guardian_set_signatures = vaa_data.sign_with_guardian_key(&guardian_secret_key, 0);
     let guardian_signatures_pubkey = add_guardian_signatures_account(
-        test_ctx,
+        testing_context,
         payer_signer,
         guardian_signature_signer,
         vec![guardian_set_signatures],
         0,
     )
-    .await
-    .expect("Failed to post guardian signatures");
-    (
+    .await?;
+    Ok((
         guardian_set_pubkey,
         guardian_signatures_pubkey,
         guardian_set_bump,
-    )
+    ))
 }
 
 /// Add a guardian signatures account
@@ -79,31 +78,22 @@ pub async fn create_guardian_signatures(
 ///
 /// * `guardian_signatures_pubkey` - The guardian signatures pubkey
 async fn add_guardian_signatures_account(
-    test_ctx: &Rc<RefCell<ProgramTestContext>>,
+    testing_context: &TestingContext,
     payer_signer: &Rc<Keypair>,
     signatures_signer: &Rc<Keypair>,
     guardian_signatures: Vec<[u8; GUARDIAN_SIGNATURE_LENGTH]>,
     guardian_set_index: u32,
-) -> Result<Pubkey> {
-    let new_blockhash = test_ctx
-        .borrow_mut()
-        .get_new_latest_blockhash()
-        .await
-        .expect("Failed to get new blockhash");
+) -> AnyhowResult<Pubkey> {
+    let new_blockhash = testing_context.get_new_latest_blockhash().await?;
     let transaction = post_signatures_transaction(
         payer_signer,
         signatures_signer,
         guardian_set_index,
-        guardian_signatures.len() as u8,
+        u8::try_from(guardian_signatures.len())?,
         &guardian_signatures,
         new_blockhash,
     );
-    test_ctx
-        .borrow_mut()
-        .banks_client
-        .process_transaction(transaction)
-        .await
-        .expect("Failed to add guardian signatures account");
+    testing_context.process_transaction(transaction).await?;
 
     Ok(signatures_signer.pubkey())
 }

solana/programs/matching-engine/tests/shimful/verify_shim.rs

@@ -32,11 +32,11 @@ pub struct InitializeFixture {
 
 impl InitializeFixture {
     pub fn get_custodian_address(&self) -> Pubkey {
-        self.addresses.custodian_address.clone()
+        self.addresses.custodian_address
     }
 
     pub fn get_auction_config_address(&self) -> Pubkey {
-        self.addresses.auction_config_address.clone()
+        self.addresses.auction_config_address
     }
 }
 
@@ -121,17 +121,17 @@ impl Default for AuctionParametersConfig {
     }
 }
 
-impl Into<AuctionParameters> for AuctionParametersConfig {
-    fn into(self) -> AuctionParameters {
+impl From<AuctionParametersConfig> for AuctionParameters {
+    fn from(val: AuctionParametersConfig) -> Self {
         AuctionParameters {
-            user_penalty_reward_bps: self.user_penalty_reward_bps,
-            initial_penalty_bps: self.initial_penalty_bps,
-            duration: self.duration,
-            grace_period: self.grace_period,
-            penalty_period: self.penalty_period,
-            min_offer_delta_bps: self.min_offer_delta_bps,
-            security_deposit_base: self.security_deposit_base,
-            security_deposit_bps: self.security_deposit_bps,
+            user_penalty_reward_bps: val.user_penalty_reward_bps,
+            initial_penalty_bps: val.initial_penalty_bps,
+            duration: val.duration,
+            grace_period: val.grace_period,
+            penalty_period: val.penalty_period,
+            min_offer_delta_bps: val.min_offer_delta_bps,
+            security_deposit_base: val.security_deposit_base,
+            security_deposit_bps: val.security_deposit_bps,
         }
     }
 }
@@ -199,11 +199,10 @@ pub async fn initialize_program(
     // Create and sign transaction
     let mut transaction =
         Transaction::new_with_payer(&[instruction], Some(&test_context.borrow().payer.pubkey()));
-    let new_blockhash = test_context
-        .borrow_mut()
+    let new_blockhash = testing_context
         .get_new_latest_blockhash()
         .await
-        .expect("Failed to get new blockhash");
+        .expect("Could not get new blockhash");
     transaction.sign(
         &[
             &test_context.borrow().payer,
@@ -213,19 +212,15 @@ pub async fn initialize_program(
     );
 
     // Process transaction
-    let versioned_transaction = VersionedTransaction::try_from(transaction)
-        .expect("Failed to convert transaction to versioned transaction");
-
+    let versioned_transaction = VersionedTransaction::from(transaction);
     testing_context
         .execute_and_verify_transaction(versioned_transaction, expected_error)
         .await;
 
     if expected_error.is_none() {
         // Verify the results
-        let custodian_account = test_context
-            .borrow_mut()
-            .banks_client
-            .get_account(custodian.clone())
+        let custodian_account = testing_context
+            .get_account(custodian)
             .await
             .expect("Failed to get custodian account")
             .expect("Custodian account not found");