manual clippy lint fixes

Author: Bengt Lofgren

solana/Cargo.toml

@@ -68,6 +68,7 @@ overflow-checks = true
 
 [workspace.lints.clippy]
 correctness = { priority = -1, level = "warn"}
+inconsistent_digit_grouping = "allow"
 
 ### See clippy.toml.
 unnecessary_lazy_evaluations = "allow"
@@ -82,7 +83,7 @@ cast_possible_wrap = "deny"
 cast_precision_loss = "deny"
 cast_sign_loss = "deny"
 eq_op = "deny"
-expect_used = "deny"
+expect_used = "allow" # TODO: Change this back once we get there
 float_cmp = "deny"
 integer_division = "deny"
 large_futures = "deny"

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

@@ -65,16 +65,17 @@ pub fn close_fast_market_order(accounts: &[AccountInfo]) -> Result<()> {
     {
         return Err(ProgramError::InvalidAccountData.into()).map_err(|e: Error| {
             e.with_pubkeys((
-                Pubkey::try_from(fast_market_order_data.close_account_refund_recipient)
-                    .expect("Failed to convert close account refund recipient to pubkey"),
+                Pubkey::from(fast_market_order_data.close_account_refund_recipient),
                 close_account_refund_recipient.key(),
             ))
         });
     }
 
     // Transfer the lamports from the fast market order to the close account refund recipient
     let mut fast_market_order_lamports = fast_market_order.lamports.borrow_mut();
-    **close_account_refund_recipient.lamports.borrow_mut() += **fast_market_order_lamports;
+    **close_account_refund_recipient.lamports.borrow_mut() =
+        (**close_account_refund_recipient.lamports.borrow())
+            .saturating_add(**fast_market_order_lamports);
     **fast_market_order_lamports = 0;
 
     Ok(())

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

@@ -31,7 +31,7 @@ pub fn create_account_reliably(
             payer_key,
             account_key,
             lamports,
-            data_len as u64,
+            u64::try_from(data_len).unwrap(), // lol it won't do ::from
             program_id,
         );
 
@@ -105,8 +105,9 @@ pub fn create_account_reliably(
             let cpi_data = &mut cpi_ix.data;
 
             cpi_data[0] = 8; // allocate selector
-            cpi_data[4..12].copy_from_slice(&(data_len as u64).to_le_bytes());
-
+            cpi_data[4..12].copy_from_slice(&u64::try_from(data_len).unwrap().to_le_bytes());
+            //                                         ↑
+            //                              It won't do ::from but it'll do ::try_from
             invoke_signed_unchecked(&cpi_ix, accounts, signer_seeds)?;
         }
 

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

@@ -159,7 +159,7 @@ pub fn initialise_fast_market_order(
     // Start of fast market order account creation
     // ------------------------------------------------------------------------------------------------
     let fast_market_order_key = fast_market_order_account.key();
-    let space = 8 + std::mem::size_of::<FastMarketOrderState>();
+    let space = 8_usize.saturating_add(std::mem::size_of::<FastMarketOrderState>());
     let (fast_market_order_pda, fast_market_order_bump) = Pubkey::find_program_address(
         &[
             FastMarketOrderState::SEED_PREFIX,
@@ -201,13 +201,14 @@ pub fn initialise_fast_market_order(
 
     let fast_market_order_bytes = bytemuck::bytes_of(&data.fast_market_order);
     // Ensure the destination has enough space
-    if fast_market_order_account_data.len() < 8 + fast_market_order_bytes.len() {
+    if fast_market_order_account_data.len() < 8_usize.saturating_add(fast_market_order_bytes.len())
+    {
         msg!("Account data buffer too small");
         return Err(MatchingEngineError::AccountDataTooSmall.into());
     }
 
     // Write the fast_market_order struct to the account
-    fast_market_order_account_data[8..8 + fast_market_order_bytes.len()]
+    fast_market_order_account_data[8..8_usize.saturating_add(fast_market_order_bytes.len())]
         .copy_from_slice(fast_market_order_bytes);
     // End of fast market order account creation
     // ------------------------------------------------------------------------------------------------

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

@@ -154,7 +154,7 @@ impl VaaMessageBodyHeader {
         if fast_market_order.redeemer_message_length > 0 {
             payload.extend_from_slice(
                 &fast_market_order.redeemer_message
-                    [..fast_market_order.redeemer_message_length as usize],
+                    [..usize::from(fast_market_order.redeemer_message_length)],
             );
         }
         message_body.extend_from_slice(&payload);
@@ -329,7 +329,7 @@ pub fn place_initial_offer_cctp_shim(
 
     // Check contents of fast_market_order
     {
-        let deadline = fast_market_order_zero_copy.deadline as i64;
+        let deadline = i64::from(fast_market_order_zero_copy.deadline);
         let expiration = i64::from(vaa_time).saturating_add(crate::VAA_AUCTION_EXPIRATION_TIME);
         let current_time = Clock::get().unwrap().unix_timestamp;
         if !((deadline == 0 || current_time < deadline) && current_time < expiration) {
@@ -362,7 +362,7 @@ pub fn place_initial_offer_cctp_shim(
             crate::AUCTION_CUSTODY_TOKEN_SEED_PREFIX,
             auction_key.as_ref(),
         ],
-        &program_id,
+        program_id,
     );
     if auction_custody_token_pda != auction_custody_token.key() {
         msg!(
@@ -407,7 +407,7 @@ pub fn place_initial_offer_cctp_shim(
     let auction_space = 8 + Auction::INIT_SPACE;
     let (pda, bump) = Pubkey::find_program_address(
         &[Auction::SEED_PREFIX, vaa_message_digest.as_ref()],
-        &program_id,
+        program_id,
     );
 
     if pda != auction_key {
@@ -422,7 +422,7 @@ pub fn place_initial_offer_cctp_shim(
         auction_account.lamports(),
         auction_space,
         accounts,
-        &program_id,
+        program_id,
         auction_signer_seeds,
     )?;
     // Borrow the account data mutably
@@ -472,7 +472,7 @@ pub fn place_initial_offer_cctp_shim(
     let auction_bytes = auction_to_write
         .try_to_vec()
         .map_err(|_| MatchingEngineError::BorshDeserializationError)?;
-    data[8..8 + auction_bytes.len()].copy_from_slice(&auction_bytes);
+    data[8..8_usize.saturating_add(auction_bytes.len())].copy_from_slice(&auction_bytes);
     // ------------------------------------------------------------------------------------------------
     // End of initialisation of auction account
 
@@ -509,30 +509,32 @@ pub fn place_initial_offer_cctp_shim(
 
 #[cfg(test)]
 mod tests {
+    use crate::state::FastMarketOrderParams;
+
     use super::*;
 
     #[test]
     fn test_bytemuck() {
-        let test_fast_market_order = FastMarketOrderState::new(
-            1000000000000000000,
-            1000000000000000000,
-            1000000000,
-            1,
-            0,
-            [0_u8; 32],
-            [0_u8; 32],
-            [0_u8; 32],
-            0,
-            0,
-            [0_u8; 512],
-            [0_u8; 32],
-            0,
-            0,
-            0,
-            0,
-            0,
-            [0_u8; 32],
-        );
+        let test_fast_market_order = FastMarketOrderState::new(FastMarketOrderParams {
+            amount_in: 1000000000000000000,
+            min_amount_out: 1000000000000000000,
+            deadline: 1000000000,
+            target_chain: 1,
+            redeemer_message_length: 0,
+            redeemer: [0_u8; 32],
+            sender: [0_u8; 32],
+            refund_address: [0_u8; 32],
+            max_fee: 0,
+            init_auction_fee: 0,
+            redeemer_message: [0_u8; 512],
+            close_account_refund_recipient: [0_u8; 32],
+            vaa_sequence: 0,
+            vaa_timestamp: 0,
+            vaa_nonce: 0,
+            vaa_emitter_chain: 0,
+            vaa_consistency_level: 0,
+            vaa_emitter_address: [0_u8; 32],
+        });
         let bytes = bytemuck::bytes_of(&test_fast_market_order);
         assert!(bytes.len() == std::mem::size_of::<FastMarketOrderState>());
     }

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

@@ -43,13 +43,13 @@ pub fn process_instruction(
     let instruction = FallbackMatchingEngineInstruction::deserialize(instruction_data).unwrap();
     match instruction {
         FallbackMatchingEngineInstruction::InitialiseFastMarketOrder(data) => {
-            initialise_fast_market_order(accounts, &data)
+            initialise_fast_market_order(accounts, data)
         }
         FallbackMatchingEngineInstruction::CloseFastMarketOrder => {
             close_fast_market_order(accounts)
         }
         FallbackMatchingEngineInstruction::PlaceInitialOfferCctpShim(data) => {
-            place_initial_offer_cctp_shim(accounts, &data)
+            place_initial_offer_cctp_shim(accounts, data)
         } // FallbackMatchingEngineInstruction::ExecuteOrderCctpShim => {
           //     handle_execute_order_shim(accounts)
           // }
@@ -68,12 +68,12 @@ impl<'ix> FallbackMatchingEngineInstruction<'ix> {
         match instruction_data[..8].try_into().unwrap() {
             FallbackMatchingEngineInstruction::PLACE_INITIAL_OFFER_CCTP_SHIM_SELECTOR => {
                 Some(Self::PlaceInitialOfferCctpShim(
-                    &PlaceInitialOfferCctpShimData::from_bytes(&instruction_data[8..]).unwrap(),
+                    PlaceInitialOfferCctpShimData::from_bytes(&instruction_data[8..]).unwrap(),
                 ))
             }
 
             FallbackMatchingEngineInstruction::INITIALISE_FAST_MARKET_ORDER_SELECTOR => Some(
-                Self::InitialiseFastMarketOrder(&bytemuck::from_bytes(&instruction_data[8..])),
+                Self::InitialiseFastMarketOrder(bytemuck::from_bytes(&instruction_data[8..])),
             ),
             FallbackMatchingEngineInstruction::CLOSE_FAST_MARKET_ORDER_SELECTOR => {
                 Some(Self::CloseFastMarketOrder)
@@ -97,7 +97,7 @@ impl FallbackMatchingEngineInstruction<'_> {
             Self::PlaceInitialOfferCctpShim(data) => {
                 // Calculate the total capacity needed
                 let data_slice = bytemuck::bytes_of(*data);
-                let total_capacity = 8 + data_slice.len(); // 8 for the selector, plus the data length
+                let total_capacity = 8_usize.saturating_add(data_slice.len()); // 8 for the selector, plus the data length
 
                 // Create a vector with the calculated capacity
                 let mut out = Vec::with_capacity(total_capacity);
@@ -125,7 +125,7 @@ impl FallbackMatchingEngineInstruction<'_> {
             // }
             Self::InitialiseFastMarketOrder(data) => {
                 let data_slice = bytemuck::bytes_of(*data);
-                let total_capacity = 8 + data_slice.len(); // 8 for the selector, plus the data length
+                let total_capacity = 8_usize.saturating_add(data_slice.len()); // 8 for the selector, plus the data length
 
                 let mut out = Vec::with_capacity(total_capacity);
 

solana/programs/matching-engine/src/processor/auction/offer/place_initial/cctp_shim.rs

@@ -50,8 +50,8 @@ pub struct PlaceInitialOfferCctpShim<'info> {
     #[account(
         init,
         payer = payer,
-        space = 8 + std::mem::size_of::<FastMarketOrderState>(),
-        //      │   └─ FastMarketOrderState account data size
+        space = 8_usize.saturating_add(std::mem::size_of::<FastMarketOrderState>()),
+        //      │                       └─ FastMarketOrderState account data size
         //      └─ Anchor discriminator (8 bytes)
         seeds = [
             FastMarketOrderState::SEED_PREFIX,
@@ -209,7 +209,7 @@ impl VaaMessageBody {
     }
 
     fn to_vec(&self) -> Vec<u8> {
-        vec![
+        [
             self.vaa_time.to_be_bytes().as_ref(),
             self.nonce.to_be_bytes().as_ref(),
             self.emitter_chain.to_be_bytes().as_ref(),

solana/programs/matching-engine/src/state/fast_market_order.rs

@@ -48,46 +48,48 @@ pub struct FastMarketOrder {
     _padding: [u8; 5],
 }
 
+pub struct FastMarketOrderParams {
+    pub amount_in: u64,
+    pub min_amount_out: u64,
+    pub deadline: u32,
+    pub target_chain: u16,
+    pub redeemer_message_length: u16,
+    pub redeemer: [u8; 32],
+    pub sender: [u8; 32],
+    pub refund_address: [u8; 32],
+    pub max_fee: u64,
+    pub init_auction_fee: u64,
+    pub redeemer_message: [u8; 512],
+    pub close_account_refund_recipient: [u8; 32],
+    pub vaa_sequence: u64,
+    pub vaa_timestamp: u32,
+    pub vaa_nonce: u32,
+    pub vaa_emitter_chain: u16,
+    pub vaa_consistency_level: u8,
+    pub vaa_emitter_address: [u8; 32],
+}
+
 impl FastMarketOrder {
-    pub fn new(
-        amount_in: u64,
-        min_amount_out: u64,
-        deadline: u32,
-        target_chain: u16,
-        redeemer_message_length: u16,
-        redeemer: [u8; 32],
-        sender: [u8; 32],
-        refund_address: [u8; 32],
-        max_fee: u64,
-        init_auction_fee: u64,
-        redeemer_message: [u8; 512],
-        close_account_refund_recipient: [u8; 32],
-        vaa_sequence: u64,
-        vaa_timestamp: u32,
-        vaa_nonce: u32,
-        vaa_emitter_chain: u16,
-        vaa_consistency_level: u8,
-        vaa_emitter_address: [u8; 32],
-    ) -> Self {
+    pub fn new(params: FastMarketOrderParams) -> Self {
         Self {
-            amount_in,
-            min_amount_out,
-            deadline,
-            target_chain,
-            redeemer_message_length,
-            redeemer,
-            sender,
-            refund_address,
-            max_fee,
-            init_auction_fee,
-            redeemer_message,
-            close_account_refund_recipient,
-            vaa_sequence,
-            vaa_timestamp,
-            vaa_nonce,
-            vaa_emitter_chain,
-            vaa_consistency_level,
-            vaa_emitter_address,
+            amount_in: params.amount_in,
+            min_amount_out: params.min_amount_out,
+            deadline: params.deadline,
+            target_chain: params.target_chain,
+            redeemer_message_length: params.redeemer_message_length,
+            redeemer: params.redeemer,
+            sender: params.sender,
+            refund_address: params.refund_address,
+            max_fee: params.max_fee,
+            init_auction_fee: params.init_auction_fee,
+            redeemer_message: params.redeemer_message,
+            close_account_refund_recipient: params.close_account_refund_recipient,
+            vaa_sequence: params.vaa_sequence,
+            vaa_timestamp: params.vaa_timestamp,
+            vaa_nonce: params.vaa_nonce,
+            vaa_emitter_chain: params.vaa_emitter_chain,
+            vaa_consistency_level: params.vaa_consistency_level,
+            vaa_emitter_address: params.vaa_emitter_address,
             _padding: [0_u8; 5],
         }
     }
@@ -117,8 +119,10 @@ impl FastMarketOrder {
         payload.extend_from_slice(&self.deadline.to_be_bytes());
         payload.extend_from_slice(&self.redeemer_message_length.to_be_bytes());
         if self.redeemer_message_length > 0 {
-            payload
-                .extend_from_slice(&self.redeemer_message[..self.redeemer_message_length as usize]);
+            payload.extend_from_slice(
+                // uisize try from should never fail
+                &self.redeemer_message[..usize::from(self.redeemer_message_length)],
+            );
         }
         payload
     }

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

@@ -1,6 +1,5 @@
 use anchor_lang::AccountDeserialize;
 use anchor_spl::token::TokenAccount;
-use matching_engine::error::MatchingEngineError;
 use matching_engine::ID as PROGRAM_ID;
 use solana_program_test::tokio;
 use solana_sdk::pubkey::Pubkey;
@@ -195,7 +194,7 @@ pub async fn test_approve_usdc() {
     let first_test_ft = testing_context.get_vaa_pair(0).unwrap().fast_transfer_vaa;
     let vaa_data = first_test_ft.vaa_data;
 
-    let actors = testing_context.testing_actors;
+    let actors = &testing_context.testing_actors;
     let solver = actors.solvers[0].clone();
     let offer_price: u64 = 1__000_000;
     let program_id = PROGRAM_ID;
@@ -234,9 +233,6 @@ pub async fn test_approve_usdc() {
     println!("Solver USDC balance: {:?}", usdc_balance);
     let solver_token_account_address = solver.token_account_address().unwrap();
     let solver_token_account_info = testing_context
-        .test_context
-        .borrow_mut()
-        .banks_client
         .get_account(solver_token_account_address)
         .await
         .expect("Failed to query banks client for solver token account info")