added instruction for settle auction none cctp shim

Author: Bengt Lofgren

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

@@ -4,4 +4,5 @@ pub mod post_message;
 pub mod shims_execute_order;
 pub mod shims_make_offer;
 pub mod shims_prepare_order_response;
+pub mod shims_settle_auction_none;
 pub mod verify_shim;

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

@@ -0,0 +1,252 @@
+use anchor_lang::prelude::*;
+use anchor_spl::token::spl_token;
+use matching_engine::{
+    fallback::{
+        settle_auction_none_cctp::{
+            SettleAuctionNoneCctpShimAccounts, SettleAuctionNoneCctpShimData,
+        },
+        FallbackMatchingEngineInstruction,
+    },
+    state::Auction,
+};
+use solana_program::instruction::Instruction;
+use solana_program_test::ProgramTestContext;
+use solana_sdk::{signature::Signer, sysvar::SysvarId, transaction::Transaction};
+use wormhole_svm_definitions::solana::{
+    CORE_BRIDGE_PROGRAM_ID, POST_MESSAGE_SHIM_EVENT_AUTHORITY, POST_MESSAGE_SHIM_PROGRAM_ID,
+};
+
+use crate::{
+    testing_engine::{
+        config::{InstructionConfig, SettleAuctionNoneShimInstructionConfig},
+        setup::TestingContext,
+        state::{OrderPreparedState, TestingEngineState},
+    },
+    utils::{auction::AuctionState, CORE_BRIDGE_CONFIG, CORE_BRIDGE_FEE_COLLECTOR},
+};
+
+use super::shims_execute_order::{create_cctp_accounts, CctpAccounts};
+
+pub struct SettleAuctionNoneCctpShim<'ix> {
+    pub program_id: &'ix Pubkey,
+    pub accounts: SettleAuctionNoneCctpShimAccounts<'ix>,
+    pub data: SettleAuctionNoneCctpShimData,
+}
+
+impl SettleAuctionNoneCctpShim<'_> {
+    pub fn instruction(self) -> Instruction {
+        Instruction {
+            program_id: *self.program_id,
+            accounts: self.accounts.to_account_metas(),
+            data: FallbackMatchingEngineInstruction::SettleAuctionNoneCctp(self.data).to_vec(),
+        }
+    }
+}
+
+pub async fn settle_auction_none_shimful(
+    testing_context: &TestingContext,
+    test_context: &mut ProgramTestContext,
+    current_state: &TestingEngineState,
+    config: &SettleAuctionNoneShimInstructionConfig,
+) -> AuctionState {
+    let payer_signer = &config
+        .payer_signer
+        .clone()
+        .unwrap_or_else(|| testing_context.testing_actors.payer_signer.clone());
+
+    let settle_auction_none_cctp_accounts =
+        create_settle_auction_none_cctp_accounts(testing_context, current_state, config);
+    let settle_auction_none_cctp_data = settle_auction_none_cctp_accounts.bumps;
+
+    let settle_auction_none_cctp_ix = SettleAuctionNoneCctpShim {
+        program_id: &testing_context.get_matching_engine_program_id(),
+        accounts: settle_auction_none_cctp_accounts.as_ref(),
+        data: settle_auction_none_cctp_data,
+    }
+    .instruction();
+    let last_blockhash = test_context.get_new_latest_blockhash().await.unwrap();
+    let tx = Transaction::new_signed_with_payer(
+        &[settle_auction_none_cctp_ix],
+        Some(&payer_signer.pubkey()),
+        &[&payer_signer],
+        last_blockhash,
+    );
+    testing_context
+        .execute_and_verify_transaction(test_context, tx, config.expected_error())
+        .await;
+    if config.expected_error().is_some() {
+        return current_state.auction_state().clone();
+    }
+
+    AuctionState::Settled
+}
+
+struct SettleAuctionNoneCctpShimAccountsOwned {
+    pub payer: Pubkey,
+    pub post_message_message: Pubkey,
+    pub post_message_sequence: Pubkey,
+    pub post_message_shim_event_authority: Pubkey,
+    pub post_message_shim_program: Pubkey,
+    pub cctp_message: Pubkey,
+    pub custodian: Pubkey,
+    pub fee_recipient_token: Pubkey,
+    pub closed_prepared_order_response_actor: Pubkey,
+    pub closed_prepared_order_response: Pubkey,
+    pub closed_prepared_order_response_custody_token: Pubkey,
+    pub auction: Pubkey,
+    pub cctp_mint: Pubkey,
+    pub cctp_local_token: Pubkey,
+    pub cctp_token_messenger_minter_event_authority: Pubkey,
+    pub cctp_remote_token_messenger: Pubkey,
+    pub cctp_token_messenger: Pubkey,
+    pub cctp_token_messenger_minter_sender_authority: Pubkey,
+    pub cctp_token_minter: Pubkey,
+    pub cctp_token_messenger_minter_program: Pubkey,
+    pub cctp_message_transmitter_config: Pubkey,
+    pub cctp_message_transmitter_program: Pubkey,
+    pub core_bridge_program: Pubkey,
+    pub core_bridge_fee_collector: Pubkey,
+    pub core_bridge_config: Pubkey,
+    pub token_program: Pubkey,
+    pub system_program: Pubkey,
+    pub clock: Pubkey,
+    pub rent: Pubkey,
+    pub bumps: SettleAuctionNoneCctpShimData,
+}
+
+impl SettleAuctionNoneCctpShimAccountsOwned {
+    pub fn as_ref(&self) -> SettleAuctionNoneCctpShimAccounts {
+        SettleAuctionNoneCctpShimAccounts {
+            payer: &self.payer,
+            post_message_message: &self.post_message_message,
+            post_message_sequence: &self.post_message_sequence,
+            post_message_shim_event_authority: &self.post_message_shim_event_authority,
+            post_message_shim_program: &self.post_message_shim_program,
+            cctp_message: &self.cctp_message,
+            custodian: &self.custodian,
+            fee_recipient_token: &self.fee_recipient_token,
+            closed_prepared_order_response_actor: &self.closed_prepared_order_response_actor,
+            closed_prepared_order_response: &self.closed_prepared_order_response,
+            closed_prepared_order_response_custody_token: &self
+                .closed_prepared_order_response_custody_token,
+            auction: &self.auction,
+            cctp_mint: &self.cctp_mint,
+            cctp_local_token: &self.cctp_local_token,
+            cctp_token_messenger_minter_event_authority: &self
+                .cctp_token_messenger_minter_event_authority,
+            cctp_remote_token_messenger: &self.cctp_remote_token_messenger,
+            cctp_token_messenger: &self.cctp_token_messenger,
+            cctp_token_messenger_minter_sender_authority: &self
+                .cctp_token_messenger_minter_sender_authority,
+            cctp_token_minter: &self.cctp_token_minter,
+            cctp_token_messenger_minter_program: &self.cctp_token_messenger_minter_program,
+            cctp_message_transmitter_config: &self.cctp_message_transmitter_config,
+            cctp_message_transmitter_program: &self.cctp_message_transmitter_program,
+            core_bridge_program: &self.core_bridge_program,
+            core_bridge_fee_collector: &self.core_bridge_fee_collector,
+            core_bridge_config: &self.core_bridge_config,
+            token_program: &self.token_program,
+            system_program: &self.system_program,
+            clock: &self.clock,
+            rent: &self.rent,
+        }
+    }
+}
+
+fn create_settle_auction_none_cctp_accounts(
+    testing_context: &TestingContext,
+    current_state: &TestingEngineState,
+    config: &SettleAuctionNoneShimInstructionConfig,
+) -> SettleAuctionNoneCctpShimAccountsOwned {
+    let payer_signer = &config
+        .payer_signer
+        .clone()
+        .unwrap_or_else(|| testing_context.testing_actors.payer_signer.clone());
+
+    let order_prepared_state = current_state.order_prepared().unwrap();
+    let OrderPreparedState {
+        prepared_order_response_address,
+        prepared_custody_token,
+        base_fee_token,
+        actor_enum,
+    } = *order_prepared_state;
+
+    let prepared_order_by = actor_enum
+        .get_actor(&testing_context.testing_actors)
+        .pubkey();
+
+    let custodian = current_state
+        .custodian_address()
+        .expect("Custodian address not found");
+
+    let fast_market_order = current_state.fast_market_order().unwrap().fast_market_order;
+    let fast_vaa_hash = fast_market_order.digest();
+    let (auction, auction_bump) = Pubkey::find_program_address(
+        &[Auction::SEED_PREFIX, fast_vaa_hash.as_ref()],
+        &testing_context.get_matching_engine_program_id(),
+    );
+
+    let (cctp_message, cctp_message_bump) = Pubkey::find_program_address(
+        &[common::CCTP_MESSAGE_SEED_PREFIX, &auction.to_bytes()],
+        &testing_context.get_matching_engine_program_id(),
+    );
+
+    let post_message_sequence = wormhole_svm_definitions::find_emitter_sequence_address(
+        &custodian,
+        &CORE_BRIDGE_PROGRAM_ID,
+    )
+    .0;
+    let post_message_message = wormhole_svm_definitions::find_shim_message_address(
+        &custodian,
+        &POST_MESSAGE_SHIM_PROGRAM_ID,
+    )
+    .0;
+
+    let CctpAccounts {
+        mint,
+        local_token,
+        token_messenger_minter_event_authority,
+        remote_token_messenger,
+        token_messenger,
+        token_messenger_minter_sender_authority,
+        token_minter,
+        token_messenger_minter_program,
+        message_transmitter_config,
+        message_transmitter_program,
+    } = create_cctp_accounts(current_state, testing_context);
+    SettleAuctionNoneCctpShimAccountsOwned {
+        payer: payer_signer.pubkey(),
+        post_message_message,
+        post_message_sequence,
+        post_message_shim_event_authority: POST_MESSAGE_SHIM_EVENT_AUTHORITY,
+        post_message_shim_program: POST_MESSAGE_SHIM_PROGRAM_ID,
+        cctp_message,
+        custodian,
+        fee_recipient_token: base_fee_token,
+        closed_prepared_order_response_actor: prepared_order_by,
+        closed_prepared_order_response: prepared_order_response_address,
+        closed_prepared_order_response_custody_token: prepared_custody_token,
+        auction,
+        cctp_mint: mint,
+        cctp_local_token: local_token,
+        cctp_token_messenger_minter_event_authority: token_messenger_minter_event_authority,
+        cctp_remote_token_messenger: remote_token_messenger,
+        cctp_token_messenger: token_messenger,
+        cctp_token_messenger_minter_sender_authority: token_messenger_minter_sender_authority,
+        cctp_token_minter: token_minter,
+        cctp_token_messenger_minter_program: token_messenger_minter_program,
+        cctp_message_transmitter_config: message_transmitter_config,
+        cctp_message_transmitter_program: message_transmitter_program,
+        core_bridge_program: CORE_BRIDGE_PROGRAM_ID,
+        core_bridge_fee_collector: CORE_BRIDGE_FEE_COLLECTOR,
+        core_bridge_config: CORE_BRIDGE_CONFIG,
+        token_program: spl_token::ID,
+        system_program: solana_program::system_program::ID,
+        clock: solana_program::clock::Clock::id(),
+        rent: solana_program::rent::Rent::id(),
+        bumps: SettleAuctionNoneCctpShimData {
+            cctp_message_bump,
+            auction_bump,
+        },
+    }
+}

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

@@ -239,6 +239,62 @@ pub async fn test_settle_auction_base_fee_token_not_best_offer_actor() {
         .await;
 }
 
+/// Test settle auction none shim
+#[tokio::test]
+pub async fn test_settle_auction_none_shim() {
+    let transfer_direction = TransferDirection::FromEthereumToArbitrum;
+    let (testing_context, mut test_context) = setup_environment(
+        ShimMode::VerifyAndPostSignature,
+        transfer_direction,
+        Some(vec![VaaArgs::default()]),
+    )
+    .await;
+    let testing_engine = TestingEngine::new(testing_context).await;
+
+    let instruction_triggers = vec![
+        InstructionTrigger::InitializeProgram(InitializeInstructionConfig::default()),
+        InstructionTrigger::CreateCctpRouterEndpoints(
+            CreateCctpRouterEndpointsInstructionConfig::default(),
+        ),
+    ];
+    let create_cctp_router_endpoints_state = testing_engine
+        .execute(&mut test_context, instruction_triggers, None)
+        .await;
+
+    // This is just needed to get the router endpoint accounts when prepare order happens before place initial offer, it is not used for anything else
+    let fake_auction_accounts = AuctionAccounts::fake_auction_accounts(
+        &create_cctp_router_endpoints_state,
+        &testing_engine.testing_context,
+    );
+    let instruction_triggers = vec![
+        InstructionTrigger::InitializeFastMarketOrderShim(
+            InitializeFastMarketOrderShimInstructionConfig::default(),
+        ),
+        InstructionTrigger::PrepareOrderShim(PrepareOrderResponseInstructionConfig {
+            overwrite_auction_accounts: Some(fake_auction_accounts),
+            ..Default::default()
+        }),
+    ];
+    let prepared_order_state = testing_engine
+        .execute(
+            &mut test_context,
+            instruction_triggers,
+            Some(create_cctp_router_endpoints_state),
+        )
+        .await;
+
+    let instruction_triggers = vec![InstructionTrigger::SettleAuctionNoneShim(
+        SettleAuctionNoneShimInstructionConfig::default(),
+    )];
+    testing_engine
+        .execute(
+            &mut test_context,
+            instruction_triggers,
+            Some(prepared_order_state),
+        )
+        .await;
+}
+
 /*
                     Sad path tests section
 

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

@@ -177,7 +177,7 @@ impl InstructionConfig for PrepareOrderResponseInstructionConfig {
 
 #[derive(Clone)]
 pub struct ExecuteOrderInstructionConfig {
-    pub fast_market_order_address: OverwriteCurrentState<Pubkey>,
+    pub override_fast_market_order_address: OverwriteCurrentState<Pubkey>,
     pub actor_enum: TestingActorEnum,
     pub token_enum: SplTokenEnum,
     pub vaa_index: usize,
@@ -192,7 +192,7 @@ impl Default for ExecuteOrderInstructionConfig {
         Self {
             fast_forward_slots: 3,
             actor_enum: TestingActorEnum::default(),
-            fast_market_order_address: None,
+            override_fast_market_order_address: None,
             token_enum: SplTokenEnum::default(),
             vaa_index: 0,
             payer_signer: None,
@@ -619,3 +619,19 @@ pub struct BalanceChange {
     pub usdc: i32,
     pub usdt: i32,
 }
+
+#[derive(Default)]
+pub struct SettleAuctionNoneShimInstructionConfig {
+    pub payer_signer: Option<Rc<Keypair>>,
+    pub expected_error: Option<ExpectedError>,
+    pub expected_log_messages: Option<Vec<ExpectedLog>>,
+}
+
+impl InstructionConfig for SettleAuctionNoneShimInstructionConfig {
+    fn expected_error(&self) -> Option<&ExpectedError> {
+        self.expected_error.as_ref()
+    }
+    fn expected_log_messages(&self) -> Option<&Vec<ExpectedLog>> {
+        self.expected_log_messages.as_ref()
+    }
+}