fixed stack issue with prepare order response

Author: Bengt Lofgren

solana/programs/matching-engine/README.md

@@ -2,3 +2,13 @@
 
 A program to facilitate the transfer of USDC between networks that allow Wormhole and CCTP bridging.
 With the help of solvers, allowing USDC to be transferred faster than finality.
+
+## Testing plan
+
+The testing engine should be designed in a functional way that allows for easy testing of the program instructions.
+
+The instructions passed to the testing engine should be able to be composed in a way where each instruction returns the updated state (not a mutating state).
+
+This state is predictable and has the benefit of being able to be tested in isolation and mocked (to an extent) for testing.
+
+

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

@@ -89,6 +89,20 @@ pub enum MatchingEngineError {
     AuctionHistoryFull = 0x504,
 
     InvalidVerifyVaaShimProgram = 0x600,
+
+    // Fallback matching engine errors
+    AccountAlreadyInitialized = 0x700,
+    AccountNotWritable = 0x702,
+    BorshDeserializationError = 0x704,
+    InvalidPda = 0x706,
+    AccountDataTooSmall = 0x708,
+    InvalidProgram = 0x70a,
+    TokenTransferFailed = 0x70c,
+    InvalidMint = 0x70e,
+
+    #[msg("From and to router endpoints are the same")]
+    SameEndpoints = 0x800,
+    InvalidCctpMessage = 0x802,
 }
 
 #[cfg(test)]

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

@@ -3,18 +3,22 @@ use anchor_lang::prelude::*;
 use solana_program::instruction::Instruction;
 use solana_program::program_error::ProgramError;
 
+use super::helpers::check_account_length;
 use super::FallbackMatchingEngineInstruction;
 
 pub struct CloseFastMarketOrderAccounts<'ix> {
+    /// The fast market order account created from the initialise fast market order instruction
     pub fast_market_order: &'ix Pubkey,
-    pub refund_recipient: &'ix Pubkey,
+    /// The account that will receive the refund. CHECK: Must be a signer.
+    /// CHECK: Must match the close account refund recipient in the fast market order account
+    pub close_account_refund_recipient: &'ix Pubkey,
 }
 
 impl<'ix> CloseFastMarketOrderAccounts<'ix> {
     pub fn to_account_metas(&self) -> Vec<AccountMeta> {
         vec![
             AccountMeta::new(*self.fast_market_order, false),
-            AccountMeta::new(*self.refund_recipient, false),
+            AccountMeta::new(*self.close_account_refund_recipient, true),
         ]
     }
 }
@@ -34,32 +38,43 @@ impl CloseFastMarketOrder<'_> {
     }
 }
 
+/// Closes the fast market order and transfers the lamports from the fast market order to the close account refund recipient
+///
+/// # Arguments
+///
+/// * `accounts` - The accounts of the fast market order and the close account refund recipient
+///
+/// # Returns
+///
+/// Result<()>
 pub fn close_fast_market_order(accounts: &[AccountInfo]) -> Result<()> {
-    if accounts.len() < 2 {
-        return Err(ProgramError::NotEnoughAccountKeys.into());
-    }
+    check_account_length(accounts, 2)?;
 
     let fast_market_order = &accounts[0];
-    let refund_recipient = &accounts[1];
+    let close_account_refund_recipient = &accounts[1];
 
-    if !refund_recipient.is_signer {
+    if !close_account_refund_recipient.is_signer {
         msg!("Refund recipient (account #2) is not a signer");
         return Err(ProgramError::InvalidAccountData.into());
     }
 
     let fast_market_order_data =
         FastMarketOrder::try_deserialize(&mut &fast_market_order.data.borrow()[..])?;
-    if fast_market_order_data.refund_recipient != refund_recipient.key().as_ref() {
-        msg!("Refund recipient (account #2) mismatch");
-        msg!("Actual:");
-        msg!("{:?}", refund_recipient.key.as_ref());
-        msg!("Expected:");
-        msg!("{:?}", fast_market_order_data.refund_recipient);
-        return Err(ProgramError::InvalidAccountData.into());
+    if fast_market_order_data.close_account_refund_recipient
+        != close_account_refund_recipient.key().as_ref()
+    {
+        return Err(ProgramError::InvalidAccountData.into()).map_err(|e: Error| {
+            e.with_pubkeys((
+                Pubkey::try_from(fast_market_order_data.close_account_refund_recipient)
+                    .expect("Failed to convert close account refund recipient to pubkey"),
+                close_account_refund_recipient.key(),
+            ))
+        });
     }
 
+    // Transfer the lamports from the fast market order to the close account refund recipient
     let mut fast_market_order_lamports = fast_market_order.lamports.borrow_mut();
-    **refund_recipient.lamports.borrow_mut() += **fast_market_order_lamports;
+    **close_account_refund_recipient.lamports.borrow_mut() += **fast_market_order_lamports;
     **fast_market_order_lamports = 0;
 
     Ok(())

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

@@ -1,3 +1,4 @@
+use super::helpers::check_account_length;
 use crate::state::{
     Auction, AuctionConfig, AuctionStatus, Custodian, FastMarketOrder as FastMarketOrderState,
     MessageProtocol, RouterEndpoint,
@@ -12,7 +13,6 @@ use solana_program::instruction::Instruction;
 use solana_program::program::invoke_signed_unchecked;
 
 use super::burn_and_post::{burn_and_post, PostMessageAccounts};
-use super::errors::FallbackError;
 use super::FallbackMatchingEngineInstruction;
 use crate::error::MatchingEngineError;
 
@@ -153,7 +153,11 @@ impl ExecuteOrderCctpShim<'_> {
         }
     }
 }
+
 pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
+    // This saves stack space whereas having that in the body does not
+    check_account_length(accounts, 31)?;
+
     let program_id = &crate::ID;
 
     // Get the accounts
@@ -169,8 +173,6 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
     let initial_offer_token_account = &accounts[9];
     let initial_participant_account = &accounts[10];
     let to_router_endpoint_account = &accounts[11];
-    // TODO: These are not used, so can I just ignore them?
-    // TODO: Check that this is the correct program id for the post message shim program
     let _post_message_shim_program_account = &accounts[12];
     let _post_message_sequence_account = &accounts[13];
     let _post_message_message_account = &accounts[14];
@@ -202,7 +204,7 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
     // Check cctp message is mutable
     if !cctp_message_account.is_writable {
         msg!("Cctp message is not writable");
-        return Err(FallbackError::AccountNotWritable.into())
+        return Err(MatchingEngineError::AccountNotWritable.into())
             .map_err(|e: Error| e.with_account_name("cctp_message"));
     }
 
@@ -244,7 +246,9 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
     let fast_market_order_seeds = [
         FastMarketOrderState::SEED_PREFIX,
         fast_market_order_digest.as_ref(),
-        fast_market_order_zero_copy.refund_recipient.as_ref(),
+        fast_market_order_zero_copy
+            .close_account_refund_recipient
+            .as_ref(),
     ];
 
     let (fast_market_order_pda, _fast_market_order_bump) =
@@ -274,8 +278,6 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
     let mut active_auction =
         Auction::try_deserialize(&mut &active_auction_account.data.borrow()[..])?;
 
-    // TODO: Check that the auction has reached its deadline
-
     // Correct way to use create_program_address with existing seeds and bump
     let active_auction_pda = Pubkey::create_program_address(
         &[
@@ -287,7 +289,7 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
     )
     .map_err(|_| {
         msg!("Failed to create program address with known bump");
-        FallbackError::InvalidPda
+        MatchingEngineError::InvalidPda
     })?;
     if active_auction_pda != active_auction_account.key() {
         msg!("Active auction pda is invalid");
@@ -314,7 +316,7 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
     )
     .map_err(|_| {
         msg!("Failed to create program address with known bump");
-        FallbackError::InvalidPda
+        MatchingEngineError::InvalidPda
     })?;
     if active_auction_custody_token_pda != active_auction_custody_token_account.key() {
         msg!("Active auction custody token pda is invalid");
@@ -335,6 +337,14 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
             .map_err(|e: Error| e.with_account_name("active_auction_config"));
     };
 
+    // Check that the auction has reached its deadline
+    let auction_info = active_auction.info.as_ref().unwrap();
+    if auction_info.within_auction_duration(&active_auction_config.parameters) {
+        msg!("Auction has not reached its deadline");
+        return Err(MatchingEngineError::AuctionPeriodNotExpired.into())
+            .map_err(|e: Error| e.with_account_name("active_auction"));
+    }
+
     // Check active auction best offer token address
     if active_auction_best_offer_token_account.key()
         != active_auction.info.as_ref().unwrap().best_offer_token

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

@@ -1,10 +1,20 @@
 use anchor_lang::prelude::*;
+
 use solana_program::{
     entrypoint::ProgramResult,
     instruction::{AccountMeta, Instruction},
     program::invoke_signed_unchecked,
     system_instruction,
 };
+
+#[inline(always)]
+pub fn check_account_length(accounts: &[AccountInfo], len: usize) -> Result<()> {
+    if accounts.len() < len {
+        return Err(ErrorCode::AccountNotEnoughKeys.into());
+    }
+    Ok(())
+}
+
 pub fn create_account_reliably(
     payer_key: &Pubkey,
     account_key: &Pubkey,