working tests

Author: Bengt Lofgren

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

@@ -302,3 +302,85 @@ fn create_execute_order_shim_accounts<'ix>(
         clock: clock_id,                                                                    // 31
     }
 }
+
+pub struct CctpAccounts {
+    pub mint: Pubkey,
+    pub token_messenger: Pubkey,
+    pub token_messenger_minter_sender_authority: Pubkey,
+    pub token_messenger_minter_event_authority: Pubkey,
+    pub message_transmitter_config: Pubkey,
+    pub token_minter: Pubkey,
+    pub local_token: Pubkey,
+    pub remote_token_messenger: Pubkey,
+    pub token_messenger_minter_program: Pubkey,
+    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,
+        }
+    }
+}
+
+pub fn create_cctp_accounts(
+    current_state: &TestingEngineState,
+    testing_context: &TestingContext,
+) -> CctpAccounts {
+    let transfer_direction = current_state.base().transfer_direction;
+    let fixture_accounts = testing_context.get_fixture_accounts().unwrap();
+    let remote_token_messenger = match transfer_direction {
+        TransferDirection::FromEthereumToArbitrum => {
+            fixture_accounts.arbitrum_remote_token_messenger
+        }
+        TransferDirection::FromArbitrumToEthereum => {
+            fixture_accounts.ethereum_remote_token_messenger
+        }
+        _ => panic!("Unsupported transfer direction"),
+    };
+    let token_messenger_minter_sender_authority =
+        Pubkey::find_program_address(&[b"sender_authority"], &TOKEN_MESSENGER_MINTER_PROGRAM_ID).0;
+    let message_transmitter_config =
+        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 token_minter =
+        Pubkey::find_program_address(&[b"token_minter"], &TOKEN_MESSENGER_MINTER_PROGRAM_ID).0;
+    let local_token = Pubkey::find_program_address(
+        &[b"local_token", &USDC_MINT.to_bytes()],
+        &TOKEN_MESSENGER_MINTER_PROGRAM_ID,
+    )
+    .0;
+    let token_messenger_minter_event_authority =
+        Pubkey::find_program_address(&[EVENT_AUTHORITY_SEED], &TOKEN_MESSENGER_MINTER_PROGRAM_ID).0;
+    CctpAccounts {
+        mint: utils::constants::USDC_MINT,
+        token_messenger,
+        token_messenger_minter_sender_authority,
+        token_messenger_minter_event_authority,
+        message_transmitter_config,
+        token_minter,
+        local_token,
+        remote_token_messenger,
+        token_messenger_minter_program: TOKEN_MESSENGER_MINTER_PROGRAM_ID,
+        message_transmitter_program: MESSAGE_TRANSMITTER_PROGRAM_ID,
+    }
+}
+
+pub fn create_cctp_deposit_for_burn(
+    current_state: &TestingEngineState,
+    testing_context: &TestingContext,
+) -> CctpDepositForBurn {
+    let cctp_accounts = create_cctp_accounts(current_state, testing_context);
+    cctp_accounts.into()
+}

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

@@ -140,6 +140,7 @@ pub async fn prepare_order_response_cctp_shimful(
             prepared_custody_token: accounts.prepared_custody_token,
             base_fee_token: accounts.base_fee_token,
             actor_enum: config.actor_enum,
+            prepared_by: payer_signer.pubkey(),
         };
         TestingEngineState::OrderPrepared {
             base: current_state.base().clone(),

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

@@ -61,7 +61,7 @@ pub async fn settle_auction_none_shimful(
         return current_state.auction_state().clone();
     }
 
-    AuctionState::Settled
+    AuctionState::Settled(None)
 }
 
 struct SettleAuctionNoneCctpShimAccountsOwned {

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

@@ -107,7 +107,7 @@ pub async fn settle_auction_complete(
             base: current_state.base().clone(),
             initialized: current_state.initialized().unwrap().clone(),
             router_endpoints: current_state.router_endpoints().unwrap().clone(),
-            auction_state: AuctionState::Settled(Box::new(active_auction.clone())),
+            auction_state: AuctionState::Settled(Some(Box::new(active_auction.clone()))),
             fast_market_order: current_state.fast_market_order().cloned(),
             order_prepared: current_state.order_prepared().unwrap().clone(),
             auction_accounts: current_state.auction_accounts().cloned(),

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

@@ -63,7 +63,7 @@ pub async fn settle_auction_none_shimless(
         return current_state.auction_state().clone();
     }
 
-    AuctionState::Settled
+    AuctionState::Settled(None)
 }
 
 async fn create_settle_auction_none_cctp_shimless_accounts(

solana/modules/matching-engine-testing/tests/utils/auction.rs

@@ -47,7 +47,7 @@ pub struct AuctionAccounts {
 pub enum AuctionState {
     Active(Box<ActiveAuctionState>),
     Paused(Box<ActiveAuctionState>),
-    Settled(Box<ActiveAuctionState>),
+    Settled(Option<Box<ActiveAuctionState>>),
     Inactive,
 }
 
@@ -57,7 +57,8 @@ impl AuctionState {
             AuctionState::Active(auction) => Some(auction),
             AuctionState::Paused(auction) => Some(auction),
             AuctionState::Inactive => None,
-            AuctionState::Settled(auction) => Some(auction),
+            AuctionState::Settled(Some(auction)) => Some(auction),
+            AuctionState::Settled(None) => None,
         }
     }
 

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

@@ -185,9 +185,9 @@ pub fn process(accounts: &[AccountInfo], data: &SettleAuctionNoneCctpShimData) -
     let closed_prepared_order_response_infos = &accounts[7..=9];
 
     let closed_prepared_order_response_info = &closed_prepared_order_response_infos[0];
-    let mut prepared_order_response = PreparedOrderResponse::try_deserialize(
+    let mut prepared_order_response = Box::new(PreparedOrderResponse::try_deserialize(
         &mut &closed_prepared_order_response_info.data.borrow_mut()[..],
-    )?;
+    )?);
     let prepared_order_response_pda = Pubkey::create_program_address(
         &[
             PreparedOrderResponse::SEED_PREFIX,
@@ -273,7 +273,7 @@ pub fn process(accounts: &[AccountInfo], data: &SettleAuctionNoneCctpShimData) -
         &ID,
         auction_signer_seeds,
     )?;
-    let mut auction = prepared_order_response.new_auction_placeholder(data.auction_bump);
+    let mut auction = Box::new(prepared_order_response.new_auction_placeholder(data.auction_bump));
 
     let SettledNone {
         user_amount,