working tests

Author: Bengt Lofgren

solana/programs/matching-engine/Cargo.toml

@@ -57,6 +57,10 @@ bs58 = "0.5.0"
 serde = { version = "1.0.212", features = ["derive"] }
 secp256k1 = {version = "0.30.0", features = ["rand", "hashes", "std", "global-context", "recovery"] }
 num-traits = "0.2.16"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing-log = "0.2.0"
+once_cell = "1.8"
 wormhole-svm-shim.workspace = true
 wormhole-svm-definitions.workspace = true
 

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

@@ -12,9 +12,11 @@ use crate::state::{
 use anchor_lang::prelude::*;
 use anchor_spl::token::spl_token;
 use common::messages::raw::LiquidityLayerDepositMessage;
+use common::messages::raw::LiquidityLayerMessage;
 use common::messages::raw::SlowOrderResponse;
 use common::wormhole_cctp_solana::cctp::message_transmitter_program;
 use common::wormhole_cctp_solana::cpi::ReceiveMessageArgs;
+use common::wormhole_cctp_solana::utils::CctpMessage;
 use solana_program::instruction::Instruction;
 use solana_program::keccak;
 use solana_program::program::invoke_signed_unchecked;
@@ -225,6 +227,29 @@ pub fn prepare_order_response_cctp_shim(
     let system_program = &accounts[27];
     let receive_message_args = data.to_receive_message_args();
     let finalized_vaa_message = data.finalized_vaa_message;
+
+    let deposit_option = LiquidityLayerMessage::parse(&finalized_vaa_message.vaa_payload)
+        .map_err(|_| MatchingEngineError::InvalidDeposit)?;
+    let deposit = deposit_option
+        .deposit()
+        .ok_or(MatchingEngineError::InvalidDepositPayloadId)?;
+    let cctp_message = CctpMessage::parse(&receive_message_args.encoded_message)
+        .map_err(|_| MatchingEngineError::InvalidCctpMessage)?;
+    require_eq!(
+        cctp_message.source_domain(),
+        deposit.source_cctp_domain(),
+        MatchingEngineError::InvalidCctpMessage
+    );
+    require_eq!(
+        cctp_message.destination_domain(),
+        deposit.destination_cctp_domain(),
+        MatchingEngineError::InvalidCctpMessage
+    );
+    require_eq!(
+        cctp_message.nonce(),
+        deposit.cctp_nonce(),
+        MatchingEngineError::InvalidCctpMessage
+    );
     // Load accounts
     let fast_market_order_account_data = fast_market_order.data.borrow();
     let fast_market_order_zero_copy =
@@ -295,28 +320,27 @@ pub fn prepare_order_response_cctp_shim(
         Pubkey::find_program_address(&prepared_custody_token_seeds, program_id);
 
     // Check custodian account
-    require!(custodian.owner == program_id, ErrorCode::ConstraintOwner);
+    require_eq!(custodian.owner, program_id, ErrorCode::ConstraintOwner);
 
     require!(!checked_custodian.paused, MatchingEngineError::Paused);
 
     // Check usdc mint
-    require!(
-        usdc.key() == common::USDC_MINT,
+    require_eq!(
+        usdc.key(),
+        common::USDC_MINT,
         MatchingEngineError::InvalidMint
     );
 
     // Check from_endpoint owner
-    require!(
-        from_endpoint.owner == program_id,
-        ErrorCode::ConstraintOwner
-    );
+    require_eq!(from_endpoint.owner, program_id, ErrorCode::ConstraintOwner);
 
     // Check to_endpoint owner
-    require!(to_endpoint.owner == program_id, ErrorCode::ConstraintOwner);
+    require_eq!(to_endpoint.owner, program_id, ErrorCode::ConstraintOwner);
 
     // Check that the from and to endpoints are different
-    require!(
-        from_endpoint_account.chain != to_endpoint_account.chain,
+    require_neq!(
+        from_endpoint_account.chain,
+        to_endpoint_account.chain,
         MatchingEngineError::SameEndpoint
     );
 
@@ -339,39 +363,47 @@ pub fn prepare_order_response_cctp_shim(
     );
 
     // Check that to endpoint chain is equal to the fast_market_order target_chain
-    require!(
-        to_endpoint_account.chain == fast_market_order_zero_copy.target_chain,
+    require_eq!(
+        to_endpoint_account.chain,
+        fast_market_order_zero_copy.target_chain,
         MatchingEngineError::InvalidTargetRouter
     );
 
-    require!(
-        prepared_order_response_pda == prepared_order_response.key(),
+    require_eq!(
+        prepared_order_response_pda,
+        prepared_order_response.key(),
         MatchingEngineError::InvalidPda
     );
 
-    require!(
-        prepared_custody_token_pda == prepared_custody_token.key(),
+    require_eq!(
+        prepared_custody_token_pda,
+        prepared_custody_token.key(),
         MatchingEngineError::InvalidPda
     );
 
     // Check the base token fee key is not equal to the prepared custody token key
-    require!(
-        base_fee_token.key() != prepared_custody_token.key(),
+    // TODO: Check that base fee token is actually a token account
+    require_neq!(
+        base_fee_token.key(),
+        prepared_custody_token.key(),
         MatchingEngineError::InvalidBaseFeeToken
     );
 
-    require!(
-        token_program.key() == spl_token::ID,
+    require_eq!(
+        token_program.key(),
+        spl_token::ID,
         MatchingEngineError::InvalidProgram
     );
 
-    require!(
-        _verify_shim_program.key() == wormhole_svm_definitions::solana::VERIFY_VAA_SHIM_PROGRAM_ID,
+    require_eq!(
+        _verify_shim_program.key(),
+        wormhole_svm_definitions::solana::VERIFY_VAA_SHIM_PROGRAM_ID,
         MatchingEngineError::InvalidProgram
     );
 
-    require!(
-        system_program.key() == solana_program::system_program::ID,
+    require_eq!(
+        system_program.key(),
+        solana_program::system_program::ID,
         MatchingEngineError::InvalidProgram
     );
 

solana/programs/matching-engine/src/lib.rs

@@ -2,12 +2,14 @@
 #![allow(clippy::result_large_err)]
 
 mod composite;
+use composite::*;
 
 pub mod error;
 
 mod events;
 
 mod processor;
+pub use processor::CctpMessageArgs;
 pub use processor::InitializeArgs;
 pub use processor::VaaMessage;
 use processor::*;
@@ -485,6 +487,11 @@ pub mod matching_engine {
         err!(ErrorCode::Deprecated)
     }
 
+    /// UNUSED. This instruction does not exist anymore. It just reverts and exist to expose an account lol.
+    pub fn get_cctp_mint_recipient(_ctx: Context<CctpMintRecipientMut>) -> Result<()> {
+        err!(ErrorCode::InstructionMissing)
+    }
+
     /// Non anchor function for placing an initial offer using the VAA shim.
     pub fn fallback_process_instruction(
         program_id: &Pubkey,

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

@@ -485,6 +485,108 @@ pub async fn test_prepare_order_shim_fallback() {
     testing_engine.execute(instruction_triggers).await;
 }
 
+// Prepare order response from ethereum to arbitrum (shimless)
+#[tokio::test]
+pub async fn test_prepare_order_shimless() {
+    let transfer_direction = TransferDirection::FromEthereumToArbitrum;
+    let vaa_args = VaaArgs {
+        post_vaa: true,
+        ..VaaArgs::default()
+    };
+    let testing_context = setup_environment(
+        ShimMode::VerifyAndPostSignature,
+        transfer_direction,
+        Some(vaa_args),
+    )
+    .await;
+    let testing_engine = TestingEngine::new(testing_context).await;
+    let instruction_triggers = vec![
+        InstructionTrigger::InitializeProgram(InitializeInstructionConfig::default()),
+        InstructionTrigger::CreateCctpRouterEndpoints(
+            CreateCctpRouterEndpointsInstructionConfig::default(),
+        ),
+        InstructionTrigger::InitializeFastMarketOrderShim(
+            InitializeFastMarketOrderShimInstructionConfig::default(),
+        ),
+        InstructionTrigger::PlaceInitialOfferShimless(PlaceInitialOfferInstructionConfig::default()),
+        InstructionTrigger::ExecuteOrderShimless(ExecuteOrderInstructionConfig::default()),
+        InstructionTrigger::PrepareOrderShimless(PrepareOrderInstructionConfig::default()),
+    ];
+    testing_engine.execute(instruction_triggers).await;
+}
+
+#[tokio::test]
+pub async fn test_prepare_order_response_shimful_blocks_shimless() {
+    let transfer_direction = TransferDirection::FromEthereumToArbitrum;
+    let vaa_args = VaaArgs {
+        post_vaa: true,
+        ..VaaArgs::default()
+    };
+    let testing_context = setup_environment(
+        ShimMode::VerifyAndPostSignature,
+        transfer_direction,
+        Some(vaa_args),
+    )
+    .await;
+    let testing_engine = TestingEngine::new(testing_context).await;
+    let instruction_triggers = vec![
+        InstructionTrigger::InitializeProgram(InitializeInstructionConfig::default()),
+        InstructionTrigger::CreateCctpRouterEndpoints(
+            CreateCctpRouterEndpointsInstructionConfig::default(),
+        ),
+        InstructionTrigger::InitializeFastMarketOrderShim(
+            InitializeFastMarketOrderShimInstructionConfig::default(),
+        ),
+        InstructionTrigger::PlaceInitialOfferShim(PlaceInitialOfferInstructionConfig::default()),
+        InstructionTrigger::ExecuteOrderShim(ExecuteOrderInstructionConfig::default()),
+        InstructionTrigger::PrepareOrderShim(PrepareOrderInstructionConfig::default()),
+        //TODO: This does not currently work, but the logs are as expected, I just don't know how to capture and test them
+        InstructionTrigger::PrepareOrderShimless(PrepareOrderInstructionConfig {
+            // expected_log_message: Some("Already prepared".to_string()),
+            ..PrepareOrderInstructionConfig::default()
+        }),
+    ];
+    testing_engine.execute(instruction_triggers).await;
+}
+
+#[tokio::test]
+pub async fn test_prepare_order_response_shimless_blocks_shimful() {
+    let transfer_direction = TransferDirection::FromEthereumToArbitrum;
+    let vaa_args = VaaArgs {
+        post_vaa: true,
+        ..VaaArgs::default()
+    };
+    let testing_context = setup_environment(
+        ShimMode::VerifyAndPostSignature,
+        transfer_direction,
+        Some(vaa_args),
+    )
+    .await;
+    let testing_engine = TestingEngine::new(testing_context).await;
+    let instruction_triggers = vec![
+        InstructionTrigger::InitializeProgram(InitializeInstructionConfig::default()),
+        InstructionTrigger::CreateCctpRouterEndpoints(
+            CreateCctpRouterEndpointsInstructionConfig::default(),
+        ),
+        InstructionTrigger::InitializeFastMarketOrderShim(
+            InitializeFastMarketOrderShimInstructionConfig::default(),
+        ),
+        InstructionTrigger::PlaceInitialOfferShimless(PlaceInitialOfferInstructionConfig::default()),
+        InstructionTrigger::ExecuteOrderShimless(ExecuteOrderInstructionConfig::default()),
+        InstructionTrigger::PrepareOrderShimless(PrepareOrderInstructionConfig::default()),
+        // TODO: Figure out why this is failing on account already in use rather than the what happens the other way around above
+        InstructionTrigger::PrepareOrderShim(PrepareOrderInstructionConfig {
+            expected_error: Some(ExpectedError {
+                instruction_index: 0,
+                error_code: 0,
+                error_string: TransactionError::AccountInUse.to_string(),
+            }),
+            ..PrepareOrderInstructionConfig::default()
+        }),
+    ];
+    testing_engine.execute(instruction_triggers).await;
+}
+
 #[tokio::test]
 pub async fn test_settle_auction_complete() {
     let transfer_direction = TransferDirection::FromEthereumToArbitrum;

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

@@ -54,6 +54,7 @@ impl ExecuteOrderFallbackAccounts {
             TransferDirection::FromArbitrumToEthereum => {
                 fixture_accounts.ethereum_remote_token_messenger
             }
+            _ => panic!("Unsupported transfer direction"),
         };
 
         Self {