make lint

Author: Bengt Lofgren

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

@@ -62,7 +62,7 @@ pub async fn initialize_fast_market_order_shimful(
         .clone()
         .unwrap_or_else(|| testing_context.testing_actors.payer_signer.clone());
     let guardian_signature_info = create_guardian_signatures(
-        &testing_context,
+        testing_context,
         test_context,
         &payer_signer,
         &fast_transfer_vaa.vaa_data,

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

@@ -316,19 +316,21 @@ pub struct CctpAccounts {
     pub message_transmitter_program: Pubkey,
 }
 
-impl Into<CctpDepositForBurn> for CctpAccounts {
-    fn into(self) -> CctpDepositForBurn {
-        CctpDepositForBurn {
-            mint: self.mint,
-            local_token: self.local_token,
-            token_messenger_minter_sender_authority: self.token_messenger_minter_sender_authority,
-            message_transmitter_config: self.message_transmitter_config,
-            token_messenger: self.token_messenger,
-            remote_token_messenger: self.remote_token_messenger,
-            token_minter: self.token_minter,
-            token_messenger_minter_event_authority: self.token_messenger_minter_event_authority,
-            message_transmitter_program: self.message_transmitter_program,
-            token_messenger_minter_program: self.token_messenger_minter_program,
+impl From<CctpAccounts> for CctpDepositForBurn {
+    fn from(cctp_accounts: CctpAccounts) -> Self {
+        Self {
+            mint: cctp_accounts.mint,
+            local_token: cctp_accounts.local_token,
+            token_messenger_minter_sender_authority: cctp_accounts
+                .token_messenger_minter_sender_authority,
+            message_transmitter_config: cctp_accounts.message_transmitter_config,
+            token_messenger: cctp_accounts.token_messenger,
+            remote_token_messenger: cctp_accounts.remote_token_messenger,
+            token_minter: cctp_accounts.token_minter,
+            token_messenger_minter_event_authority: cctp_accounts
+                .token_messenger_minter_event_authority,
+            message_transmitter_program: cctp_accounts.message_transmitter_program,
+            token_messenger_minter_program: cctp_accounts.token_messenger_minter_program,
         }
     }
 }

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

@@ -164,7 +164,7 @@ pub async fn evaluate_place_initial_offer_shimful_state(
             .get_active_auction()
             .unwrap();
         active_auction_state
-            .verify_auction(&testing_context, test_context)
+            .verify_auction(testing_context, test_context)
             .await
             .expect("Could not verify auction");
         let auction_accounts = initial_offer_placed_state.auction_accounts;

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

@@ -143,8 +143,7 @@ pub fn initialize_program_instruction(
 ) -> Instruction {
     let program_id = testing_context.get_matching_engine_program_id();
     let usdc_mint_address = testing_context.get_usdc_mint_address();
-    let initialize_addresses =
-        InitializeAddresses::new(testing_context, &auction_parameters_config);
+    let initialize_addresses = InitializeAddresses::new(testing_context, auction_parameters_config);
     let InitializeAddresses {
         custodian_address: custodian,
         auction_config_address: auction_config,

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

@@ -275,7 +275,7 @@ pub async fn place_initial_offer_shimless(
         auction_state
             .get_active_auction()
             .unwrap()
-            .verify_auction(&testing_context, test_context)
+            .verify_auction(testing_context, test_context)
             .await
             .expect("Could not verify auction state");
         return TestingEngineState::InitialOfferPlaced {
@@ -413,7 +413,7 @@ pub async fn improve_offer(
         new_auction_state
             .get_active_auction()
             .unwrap()
-            .verify_auction(&testing_context, test_context)
+            .verify_auction(testing_context, test_context)
             .await
             .expect("Could not verify auction state");
         return TestingEngineState::OfferImproved {

solana/modules/matching-engine-testing/tests/testing_engine/config.rs

@@ -639,6 +639,7 @@ pub struct BalanceChange {
     pub usdt: i32,
 }
 
+#[derive(Default)]
 pub struct CombinedInstructionConfig {
     pub create_fast_market_order_config: Option<InitializeFastMarketOrderShimInstructionConfig>,
     pub place_initial_offer_config: Option<PlaceInitialOfferInstructionConfig>,
@@ -648,19 +649,6 @@ pub struct CombinedInstructionConfig {
     pub improve_offer_config: Option<ImproveOfferInstructionConfig>,
 }
 
-impl Default for CombinedInstructionConfig {
-    fn default() -> Self {
-        Self {
-            create_fast_market_order_config: None,
-            place_initial_offer_config: None,
-            execute_order_config: None,
-            settle_auction_config: None,
-            close_fast_market_order_config: None,
-            improve_offer_config: None,
-        }
-    }
-}
-
 impl CombinedInstructionConfig {
     pub fn create_fast_market_order_and_place_initial_offer(
         testing_actors: &TestingActors,

solana/programs/matching-engine/src/fallback/processor/burn_and_post.rs

@@ -53,8 +53,8 @@ pub fn burn_and_post<'info>(
             payer,
             wormhole_program_id: &CORE_BRIDGE_PROGRAM_ID,
             derived: post_message::PostMessageDerivedAccounts {
-                message: Some(&message),
-                sequence: Some(&sequence),
+                message: Some(message),
+                sequence: Some(sequence),
                 core_bridge_config: Some(&CORE_BRIDGE_CONFIG),
                 fee_collector: Some(&CORE_BRIDGE_FEE_COLLECTOR),
                 event_authority: Some(&POST_MESSAGE_SHIM_EVENT_AUTHORITY),

solana/programs/matching-engine/src/fallback/processor/helpers.rs

@@ -129,15 +129,19 @@ pub fn try_fast_market_order_account<'a>(
         return Err(ErrorCode::AccountDiscriminatorNotFound.into());
     }
 
-    if &data[0..8] != &FastMarketOrder::DISCRIMINATOR {
+    if data[0..8] != FastMarketOrder::DISCRIMINATOR {
         return Err(ErrorCode::AccountDiscriminatorMismatch.into());
     }
 
     // TODO: Move up?
     super::helpers::require_owned_by_this_program(fast_market_order_info, "fast_market_order")?;
 
     Ok(Ref::map(data, |data| {
-        bytemuck::from_bytes(&data[8..8 + std::mem::size_of::<FastMarketOrder>()])
+        bytemuck::from_bytes(
+            &data[8..8_usize
+                .checked_add(std::mem::size_of::<FastMarketOrder>())
+                .unwrap()],
+        )
     }))
 }
 

solana/programs/matching-engine/src/fallback/processor/prepare_order_response.rs

@@ -393,7 +393,7 @@ pub fn prepare_order_response_cctp_shim(
         &spl_token::ID,
         &CCTP_MINT_RECIPIENT,
         &expected_prepared_custody_key,
-        &custodian_info.key,
+        custodian_info.key,
         &[], // Apparently this is only for multi-sig accounts
         amount_in,
     )

solana/programs/matching-engine/src/fallback/processor/process_instruction.rs

@@ -114,7 +114,8 @@ impl FallbackMatchingEngineInstruction<'_> {
         match self {
             Self::InitializeFastMarketOrder(data) => {
                 let mut out = Vec::with_capacity(
-                    SELECTOR_SIZE + std::mem::size_of::<InitializeFastMarketOrderData>(),
+                    SELECTOR_SIZE
+                        .saturating_add(std::mem::size_of::<InitializeFastMarketOrderData>()),
                 );
 
                 out.extend_from_slice(
@@ -125,7 +126,8 @@ impl FallbackMatchingEngineInstruction<'_> {
                 out
             }
             Self::PlaceInitialOfferCctpShim(data) => {
-                let mut out = Vec::with_capacity(SELECTOR_SIZE + std::mem::size_of::<u64>());
+                let mut out =
+                    Vec::with_capacity(SELECTOR_SIZE.saturating_add(std::mem::size_of::<u64>()));
 
                 out.extend_from_slice(
                     &FallbackMatchingEngineInstruction::PLACE_INITIAL_OFFER_CCTP_SHIM_SELECTOR,
@@ -156,7 +158,8 @@ impl FallbackMatchingEngineInstruction<'_> {
             }
             FallbackMatchingEngineInstruction::SettleAuctionNoneCctpShim(data) => {
                 let mut out = Vec::with_capacity(
-                    SELECTOR_SIZE + std::mem::size_of::<SettleAuctionNoneCctpShimData>(),
+                    SELECTOR_SIZE
+                        .saturating_add(std::mem::size_of::<SettleAuctionNoneCctpShimData>()),
                 );
 
                 out.extend_from_slice(