removed Rc<RefCell<>>

Author: Bengt Lofgren

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

@@ -15,6 +15,7 @@ use matching_engine::fallback::initialise_fast_market_order::{
 };
 
 use matching_engine::state::{FastMarketOrder as FastMarketOrderState, FastMarketOrderParams};
+use solana_program_test::ProgramTestContext;
 use solana_sdk::transaction::VersionedTransaction;
 use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer, transaction::Transaction};
 use std::rc::Rc;
@@ -39,6 +40,7 @@ use wormhole_io::TypePrefixedPayload;
 /// * The expected error, if any, is reached when executing the instruction
 pub async fn initialise_fast_market_order_fallback(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
     fast_market_order: FastMarketOrderState,
     guardian_set_pubkey: Pubkey,
@@ -55,7 +57,10 @@ pub async fn initialise_fast_market_order_fallback(
         guardian_signatures_pubkey,
         guardian_set_bump,
     );
-    let recent_blockhash = testing_context.test_context.borrow().last_blockhash;
+    let recent_blockhash = testing_context
+        .get_new_latest_blockhash(test_context)
+        .await
+        .unwrap();
     let transaction = solana_sdk::transaction::Transaction::new_signed_with_payer(
         &[initialise_fast_market_order_ix],
         Some(&payer_signer.pubkey()),
@@ -64,7 +69,7 @@ pub async fn initialise_fast_market_order_fallback(
     );
     let versioned_transaction = VersionedTransaction::from(transaction);
     testing_context
-        .execute_and_verify_transaction(versioned_transaction, expected_error)
+        .execute_and_verify_transaction(test_context, versioned_transaction, expected_error)
         .await;
 }
 
@@ -135,13 +140,14 @@ fn initialise_fast_market_order_fallback_instruction(
 /// * The expected error, if any, is reached when executing the instruction
 pub async fn close_fast_market_order_fallback(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     refund_recipient_keypair: &Rc<Keypair>,
     fast_market_order_address: &Pubkey,
     expected_error: Option<&ExpectedError>,
 ) {
     let program_id = &testing_context.get_matching_engine_program_id();
     let recent_blockhash = testing_context
-        .get_new_latest_blockhash()
+        .get_new_latest_blockhash(test_context)
         .await
         .expect("Failed to get new blockhash");
     let close_fast_market_order_ix = CloseFastMarketOrderFallback {
@@ -160,7 +166,7 @@ pub async fn close_fast_market_order_fallback(
         recent_blockhash,
     );
     testing_context
-        .execute_and_verify_transaction(transaction, expected_error)
+        .execute_and_verify_transaction(test_context, transaction, expected_error)
         .await;
 }
 

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

@@ -1,5 +1,6 @@
 use crate::utils::{constants::*, setup::TestingContext};
 
+use solana_program_test::ProgramTestContext;
 use solana_sdk::{
     compute_budget::ComputeBudgetInstruction,
     hash::Hash,
@@ -51,11 +52,12 @@ impl BumpCosts {
 /// * `emitter_signer` - The emitter signer keypair
 pub async fn set_up_post_message_transaction_test(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
     emitter_signer: &Rc<Keypair>,
 ) {
     let recent_blockhash = testing_context
-        .get_new_latest_blockhash()
+        .get_new_latest_blockhash(test_context)
         .await
         .expect("Could not get last blockhash");
     let (transaction, _bump_costs) = set_up_post_message_transaction(
@@ -65,14 +67,11 @@ pub async fn set_up_post_message_transaction_test(
         recent_blockhash,
     );
     let details = {
-        let test_ctx = &testing_context.test_context;
-        let mut ctx = test_ctx.borrow_mut();
-        let out = ctx
+        let out = test_context
             .banks_client
             .simulate_transaction(transaction)
             .await
             .unwrap();
-        drop(ctx);
         assert!(out.result.clone().unwrap().is_ok(), "{:?}", out.result);
         out.simulation_details.unwrap()
     };

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

@@ -8,6 +8,7 @@ use common::wormhole_cctp_solana::cctp::{
     MESSAGE_TRANSMITTER_PROGRAM_ID, TOKEN_MESSENGER_MINTER_PROGRAM_ID,
 };
 use matching_engine::fallback::execute_order::{ExecuteOrderCctpShim, ExecuteOrderShimAccounts};
+use solana_program_test::ProgramTestContext;
 use solana_sdk::{
     pubkey::Pubkey, signature::Keypair, signer::Signer, sysvar::SysvarId, transaction::Transaction,
 };
@@ -91,14 +92,14 @@ pub struct ExecuteOrderFallbackFixtureAccounts {
 
 pub async fn execute_order_fallback(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
     program_id: &Pubkey,
     solver: Solver,
     execute_order_fallback_accounts: &ExecuteOrderFallbackAccounts,
     expected_error: Option<&ExpectedError>,
 ) -> Option<ExecuteOrderFallbackFixture> {
     // Get target chain and use as remote address
-    let test_ctx = &testing_context.test_context;
     let cctp_message = Pubkey::find_program_address(
         &[
             common::CCTP_MESSAGE_SEED_PREFIX,
@@ -181,16 +182,19 @@ pub async fn execute_order_fallback(
     .instruction();
 
     // Considering fast forwarding blocks here for deadline to be reached
-    let recent_blockhash = test_ctx.borrow().last_blockhash;
-    utils::setup::fast_forward_slots(testing_context, 3).await;
+    let recent_blockhash = testing_context
+        .get_new_latest_blockhash(test_context)
+        .await
+        .unwrap();
+    utils::setup::fast_forward_slots(test_context, 3).await;
     let transaction = Transaction::new_signed_with_payer(
         &[execute_order_ix],
         Some(&payer_signer.pubkey()),
         &[&payer_signer],
         recent_blockhash,
     );
     testing_context
-        .execute_and_verify_transaction(transaction, expected_error)
+        .execute_and_verify_transaction(test_context, transaction, expected_error)
         .await;
     if expected_error.is_none() {
         Some(ExecuteOrderFallbackFixture {
@@ -212,6 +216,7 @@ pub async fn execute_order_fallback(
 
 pub async fn execute_order_fallback_test(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     auction_accounts: &utils::auction::AuctionAccounts,
     fast_market_order_address: &Pubkey,
     active_auction_state: &ActiveAuctionState,
@@ -231,6 +236,7 @@ pub async fn execute_order_fallback_test(
     );
     execute_order_fallback(
         testing_context,
+        test_context,
         &testing_context.testing_actors.owner.keypair(),
         &testing_context.get_matching_engine_program_id(),
         solver,

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

@@ -10,6 +10,7 @@ use matching_engine::fallback::place_initial_offer::{
     PlaceInitialOfferCctpShimData as PlaceInitialOfferCctpShimFallbackData,
 };
 use matching_engine::state::Auction;
+use solana_program_test::ProgramTestContext;
 
 use super::fast_market_order_shim::create_fast_market_order_state_from_vaa_data;
 use solana_sdk::{pubkey::Pubkey, signature::Keypair, signer::Signer, transaction::Transaction};
@@ -39,6 +40,7 @@ use std::rc::Rc;
 #[allow(clippy::too_many_arguments)]
 pub async fn place_initial_offer_fallback(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
     vaa_data: &utils::vaa::PostedVaaData,
     solver: Solver,
@@ -48,7 +50,6 @@ pub async fn place_initial_offer_fallback(
     expected_error: Option<&ExpectedError>,
 ) -> Option<InitialOfferPlacedState> {
     let program_id = testing_context.get_matching_engine_program_id();
-    let test_ctx = &testing_context.test_context;
     let fast_market_order = create_fast_market_order_state_from_vaa_data(vaa_data, solver.pubkey());
 
     let auction_address = Pubkey::find_program_address(
@@ -77,10 +78,10 @@ pub async fn place_initial_offer_fallback(
     .0;
 
     solver
-        .approve_usdc(test_ctx, &transfer_authority, 420_000__000_000)
+        .approve_usdc(test_context, &transfer_authority, 420_000__000_000)
         .await;
 
-    let solver_usdc_balance_before = solver.get_balance(test_ctx).await;
+    let solver_usdc_balance_before = solver.get_balance(test_context).await;
 
     let place_initial_offer_ix_data = PlaceInitialOfferCctpShimFallbackData::new(offer_price);
 
@@ -106,7 +107,10 @@ pub async fn place_initial_offer_fallback(
     }
     .instruction();
 
-    let recent_blockhash = test_ctx.borrow().last_blockhash;
+    let recent_blockhash = testing_context
+        .get_new_latest_blockhash(test_context)
+        .await
+        .unwrap();
 
     let transaction = Transaction::new_signed_with_payer(
         &[place_initial_offer_ix],
@@ -116,10 +120,10 @@ pub async fn place_initial_offer_fallback(
     );
 
     testing_context
-        .execute_and_verify_transaction(transaction, expected_error)
+        .execute_and_verify_transaction(test_context, transaction, expected_error)
         .await;
     if expected_error.is_none() {
-        let solver_usdc_balance_after = solver.get_balance(test_ctx).await;
+        let solver_usdc_balance_after = solver.get_balance(test_context).await;
         assert!(
             solver_usdc_balance_after < solver_usdc_balance_before,
             "Solver USDC balance should have decreased"

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

@@ -16,6 +16,7 @@ use matching_engine::fallback::prepare_order_response::{
 };
 use matching_engine::state::{FastMarketOrder as FastMarketOrderState, PreparedOrderResponse};
 use matching_engine::CCTP_MINT_RECIPIENT;
+use solana_program_test::ProgramTestContext;
 use solana_sdk::signature::Keypair;
 use solana_sdk::signer::Signer;
 use solana_sdk::transaction::Transaction;
@@ -171,13 +172,13 @@ impl PrepareOrderResponseShimDataFixture {
 
 pub async fn prepare_order_response_cctp_shim(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
     accounts: PrepareOrderResponseShimAccountsFixture,
     data: PrepareOrderResponseShimDataFixture,
     matching_engine_program_id: &Pubkey,
     expected_error: Option<&ExpectedError>,
 ) -> Option<PrepareOrderResponseShimFixture> {
-    let test_ctx = &testing_context.test_context;
     let fast_market_order_digest = data.fast_market_order.digest();
     let prepared_order_response_seeds = [
         PreparedOrderResponse::SEED_PREFIX,
@@ -247,9 +248,8 @@ pub async fn prepare_order_response_cctp_shim(
     }
     .instruction();
 
-    let recent_blockhash = test_ctx
-        .borrow_mut()
-        .get_new_latest_blockhash()
+    let recent_blockhash = testing_context
+        .get_new_latest_blockhash(test_context)
         .await
         .expect("Failed to get new latest blockhash");
     let transaction = Transaction::new_signed_with_payer(
@@ -259,7 +259,7 @@ pub async fn prepare_order_response_cctp_shim(
         recent_blockhash,
     );
     testing_context
-        .execute_and_verify_transaction(transaction, expected_error)
+        .execute_and_verify_transaction(test_context, transaction, expected_error)
         .await;
     if expected_error.is_none() {
         Some(PrepareOrderResponseShimFixture {
@@ -274,6 +274,7 @@ pub async fn prepare_order_response_cctp_shim(
 #[allow(clippy::too_many_arguments)]
 pub async fn prepare_order_response_test(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
     deposit_vaa_data: &utils::vaa::PostedVaaData,
     testing_engine_state: &TestingEngineState,
@@ -282,7 +283,6 @@ pub async fn prepare_order_response_test(
     deposit: &Deposit,
     expected_error: Option<&ExpectedError>,
 ) -> Option<PrepareOrderResponseShimFixture> {
-    let test_ctx = &testing_context.test_context;
     let core_bridge_program_id = &testing_context.get_wormhole_program_id();
     let matching_engine_program_id = &testing_context.get_matching_engine_program_id();
     let usdc_mint_address = &testing_context.get_usdc_mint_address();
@@ -296,6 +296,7 @@ pub async fn prepare_order_response_test(
     let (guardian_set_pubkey, guardian_signatures_pubkey, guardian_set_bump) =
         super::verify_shim::create_guardian_signatures(
             testing_context,
+            test_context,
             payer_signer,
             deposit_vaa_data,
             core_bridge_program_id,
@@ -307,7 +308,7 @@ pub async fn prepare_order_response_test(
     let source_remote_token_messenger = match testing_context.testing_state.transfer_direction {
         TransferDirection::FromEthereumToArbitrum => {
             utils::router::get_remote_token_messenger(
-                testing_context,
+                test_context,
                 fixture_accounts.ethereum_remote_token_messenger,
             )
             .await
@@ -326,7 +327,7 @@ pub async fn prepare_order_response_test(
         .expect("Custodian address not found");
     // TODO: Make checks to see if fast market order sender matches cctp message sender ...
     let cctp_token_burn_message = utils::cctp_message::craft_cctp_token_burn_message(
-        test_ctx,
+        test_context,
         source_remote_token_messenger.domain,
         cctp_nonce,
         deposit.amount,
@@ -371,6 +372,7 @@ pub async fn prepare_order_response_test(
     );
     super::shims_prepare_order_response::prepare_order_response_cctp_shim(
         testing_context,
+        test_context,
         payer_signer,
         prepare_order_response_cctp_shim_accounts,
         prepare_order_response_cctp_shim_data,

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

@@ -3,6 +3,7 @@ use crate::utils::{self, setup::TestingContext};
 use anchor_lang::prelude::*;
 use anyhow::Result as AnyhowResult;
 
+use solana_program_test::ProgramTestContext;
 use solana_sdk::{
     compute_budget::ComputeBudgetInstruction,
     hash::Hash,
@@ -33,6 +34,7 @@ use wormhole_svm_shim::verify_vaa;
 /// * `(guardian_set_pubkey, guardian_signatures_pubkey, guardian_set_bump)` - The guardian set pubkey, the guardian signatures pubkey and the guardian set bump
 pub async fn create_guardian_signatures(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
     vaa_data: &utils::vaa::PostedVaaData,
     wormhole_program_id: &Pubkey,
@@ -49,6 +51,7 @@ pub async fn create_guardian_signatures(
     let guardian_set_signatures = vaa_data.sign_with_guardian_key(&guardian_secret_key, 0);
     let guardian_signatures_pubkey = add_guardian_signatures_account(
         testing_context,
+        test_context,
         payer_signer,
         guardian_signature_signer,
         vec![guardian_set_signatures],
@@ -79,12 +82,15 @@ pub async fn create_guardian_signatures(
 /// * `guardian_signatures_pubkey` - The guardian signatures pubkey
 async fn add_guardian_signatures_account(
     testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
     payer_signer: &Rc<Keypair>,
     signatures_signer: &Rc<Keypair>,
     guardian_signatures: Vec<[u8; GUARDIAN_SIGNATURE_LENGTH]>,
     guardian_set_index: u32,
 ) -> AnyhowResult<Pubkey> {
-    let new_blockhash = testing_context.get_new_latest_blockhash().await?;
+    let new_blockhash = testing_context
+        .get_new_latest_blockhash(test_context)
+        .await?;
     let transaction = post_signatures_transaction(
         payer_signer,
         signatures_signer,
@@ -93,7 +99,9 @@ async fn add_guardian_signatures_account(
         &guardian_signatures,
         new_blockhash,
     );
-    testing_context.process_transaction(transaction).await?;
+    testing_context
+        .process_transaction(test_context, transaction)
+        .await?;
 
     Ok(signatures_signer.pubkey())
 }