more docs

Author: Bengt Lofgren

solana/modules/matching-engine-testing/tests/integration_tests.rs

@@ -1,5 +1,4 @@
 #![allow(clippy::expect_used)]
-#![allow(dead_code)]
 #![allow(clippy::panic)]
 
 use anchor_lang::AccountDeserialize;
@@ -108,8 +107,12 @@ pub async fn test_setup_vaas() {
         post_vaa: true,
         ..VaaArgs::default()
     };
-    let (testing_context, mut test_context) =
-        setup_environment(ShimMode::PostVaa, transfer_direction, Some(vaa_args)).await;
+    let (testing_context, mut test_context) = setup_environment(
+        ShimMode::VerifySignature,
+        transfer_direction,
+        Some(vaa_args),
+    )
+    .await;
 
     testing_context.verify_vaas(&mut test_context).await;
 

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

@@ -232,7 +232,7 @@ pub async fn execute_order_fallback_test(
         active_auction_state,
         &testing_context.testing_actors.owner.pubkey(),
         &fixture_accounts,
-        testing_context.testing_state.transfer_direction,
+        testing_context.initial_testing_state.transfer_direction,
     );
     execute_order_fallback(
         testing_context,

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

@@ -53,7 +53,7 @@ pub struct PrepareOrderResponseShimAccountsFixture {
 }
 
 impl PrepareOrderResponseShimAccountsFixture {
-    #[allow(clippy::too_many_arguments)]
+    #[allow(clippy::too_many_arguments)] // TODO: fix this (10/7)
     pub fn new(
         signer: &Pubkey,
         fixture_accounts: &FixtureAccounts,
@@ -304,16 +304,17 @@ pub async fn prepare_order_response_test(
     .await
     .unwrap();
 
-    let source_remote_token_messenger = match testing_context.testing_state.transfer_direction {
-        TransferDirection::FromEthereumToArbitrum => {
-            utils::router::get_remote_token_messenger(
-                test_context,
-                fixture_accounts.ethereum_remote_token_messenger,
-            )
-            .await
-        }
-        _ => panic!("Unsupported transfer direction"),
-    };
+    let source_remote_token_messenger =
+        match testing_context.initial_testing_state.transfer_direction {
+            TransferDirection::FromEthereumToArbitrum => {
+                utils::router::get_remote_token_messenger(
+                    test_context,
+                    fixture_accounts.ethereum_remote_token_messenger,
+                )
+                .await
+            }
+            _ => panic!("Unsupported transfer direction"),
+        };
     let cctp_nonce = deposit.cctp_nonce;
 
     let message_transmitter_config_pubkey = fixture_accounts.message_transmitter_config;
@@ -366,7 +367,7 @@ pub async fn prepare_order_response_test(
         usdc_mint_address,
         &cctp_message_decoded,
         &guardian_signature_info,
-        &testing_context.testing_state.transfer_direction,
+        &testing_context.initial_testing_state.transfer_direction,
     );
     super::shims_prepare_order_response::prepare_order_response_cctp_shim(
         testing_context,

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

@@ -106,7 +106,7 @@ pub fn create_execute_order_shimless_accounts(
         Pubkey::find_program_address(&[b"message_transmitter"], &MESSAGE_TRANSMITTER_PROGRAM_ID).0;
     let token_messenger =
         Pubkey::find_program_address(&[b"token_messenger"], &TOKEN_MESSENGER_MINTER_PROGRAM_ID).0;
-    let remote_token_messenger = match testing_context.testing_state.transfer_direction {
+    let remote_token_messenger = match testing_context.initial_testing_state.transfer_direction {
         TransferDirection::FromEthereumToArbitrum => {
             fixture_accounts.arbitrum_remote_token_messenger
         }

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

@@ -50,16 +50,17 @@ pub async fn prepare_order_response(
         .clone()
         .expect("Fixture accounts not found");
 
-    let source_remote_token_messenger = match testing_context.testing_state.transfer_direction {
-        TransferDirection::FromEthereumToArbitrum => {
-            utils::router::get_remote_token_messenger(
-                test_context,
-                fixture_accounts.ethereum_remote_token_messenger,
-            )
-            .await
-        }
-        _ => panic!("Unsupported transfer direction"),
-    };
+    let source_remote_token_messenger =
+        match testing_context.initial_testing_state.transfer_direction {
+            TransferDirection::FromEthereumToArbitrum => {
+                utils::router::get_remote_token_messenger(
+                    test_context,
+                    fixture_accounts.ethereum_remote_token_messenger,
+                )
+                .await
+            }
+            _ => panic!("Unsupported transfer direction"),
+        };
 
     let message_transmitter_config_pubkey = fixture_accounts.message_transmitter_config;
     let custodian_address = testing_engine_state
@@ -144,7 +145,8 @@ pub async fn prepare_order_response(
     };
     let cctp_message_transmitter_event_authority =
         Pubkey::find_program_address(&[EVENT_AUTHORITY_SEED], &MESSAGE_TRANSMITTER_PROGRAM_ID).0;
-    let cctp_remote_token_messenger = match testing_context.testing_state.transfer_direction {
+    let cctp_remote_token_messenger = match testing_context.initial_testing_state.transfer_direction
+    {
         TransferDirection::FromEthereumToArbitrum => {
             fixture_accounts.ethereum_remote_token_messenger
         }

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

@@ -4,15 +4,33 @@ use crate::{shimless::initialize::AuctionParametersConfig, utils::Chain};
 use anchor_lang::prelude::*;
 use solana_sdk::signature::Keypair;
 
+pub trait InstructionConfig: Default {
+    fn expected_error(&self) -> Option<&ExpectedError>;
+}
+
+/// A type alias for an optional value that overwrites the current state
 pub type OverwriteCurrentState<T> = Option<T>;
 
+/// A struct representing an expected error
+///
+/// # Fields
+///
+/// * `instruction_index` - The index of the instruction that is expected to error
+/// * `error_code` - The error code that is expected to be returned
+/// * `error_string` - The error string that is expected to be returned
 #[derive(Clone)]
 pub struct ExpectedError {
     pub instruction_index: u8,
     pub error_code: u32,
     pub error_string: String,
 }
 
+/// A struct representing an expected log
+///
+/// # Fields
+///
+/// * `log_message` - The log message that is expected to be returned
+/// * `count` - The number of times the log message is expected to appear
 #[derive(Clone)]
 pub struct ExpectedLog {
     pub log_message: String,
@@ -25,6 +43,11 @@ pub struct InitializeInstructionConfig {
     pub expected_error: Option<ExpectedError>,
 }
 
+impl InstructionConfig for InitializeInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+}
 pub struct CreateCctpRouterEndpointsInstructionConfig {
     pub chains: HashSet<Chain>,
     pub payer_signer: Option<Rc<Keypair>>,
@@ -42,6 +65,13 @@ impl Default for CreateCctpRouterEndpointsInstructionConfig {
         }
     }
 }
+
+impl InstructionConfig for CreateCctpRouterEndpointsInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct InitializeFastMarketOrderShimInstructionConfig {
     pub fast_market_order_id: u32,
@@ -50,6 +80,12 @@ pub struct InitializeFastMarketOrderShimInstructionConfig {
     pub expected_error: Option<ExpectedError>,
 }
 
+impl InstructionConfig for InitializeFastMarketOrderShimInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct PrepareOrderInstructionConfig {
     pub fast_market_order_address: OverwriteCurrentState<Pubkey>,
@@ -59,6 +95,12 @@ pub struct PrepareOrderInstructionConfig {
     pub expected_log_messages: Option<Vec<ExpectedLog>>,
 }
 
+impl InstructionConfig for PrepareOrderInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct ExecuteOrderInstructionConfig {
     pub fast_market_order_address: OverwriteCurrentState<Pubkey>,
@@ -67,19 +109,37 @@ pub struct ExecuteOrderInstructionConfig {
     pub expected_error: Option<ExpectedError>,
 }
 
+impl InstructionConfig for ExecuteOrderInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct SettleAuctionInstructionConfig {
     pub payer_signer: Option<Rc<Keypair>>,
     pub expected_error: Option<ExpectedError>,
 }
 
+impl InstructionConfig for SettleAuctionInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+}
+
 #[derive(Clone, Default)]
 pub struct CloseFastMarketOrderShimInstructionConfig {
     pub close_account_refund_recipient_keypair: Option<Rc<Keypair>>, // If none, will use the solver 0 keypair
     pub fast_market_order_address: OverwriteCurrentState<Pubkey>, // If none, will use the fast market order address from the current state
     pub expected_error: Option<ExpectedError>,
 }
 
+impl InstructionConfig for CloseFastMarketOrderShimInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+}
+
 pub struct PlaceInitialOfferInstructionConfig {
     pub solver_index: usize,
     pub offer_price: u64,
@@ -100,6 +160,12 @@ impl Default for PlaceInitialOfferInstructionConfig {
     }
 }
 
+impl InstructionConfig for PlaceInitialOfferInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+}
+
 pub struct ImproveOfferInstructionConfig {
     pub solver_index: usize,
     pub offer_price: u64,
@@ -117,3 +183,9 @@ impl Default for ImproveOfferInstructionConfig {
         }
     }
 }
+
+impl InstructionConfig for ImproveOfferInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+}