solana: clean up place initial offer

update helpers and fix existing instructions

Author: a5-pickle

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

@@ -364,7 +364,7 @@ pub async fn test_place_initial_offer_fails_if_fast_market_order_not_created() {
             fast_market_order_address: OverwriteCurrentState::Some(fake_fast_market_order_address),
             expected_error: Some(ExpectedError {
                 instruction_index: 0,
-                error_code: u32::from(ErrorCode::ConstraintOwner),
+                error_code: u32::from(ErrorCode::AccountDiscriminatorMismatch), // TODO: Revisit?
                 error_string: "Fast market order account owner is invalid".to_string(),
             }),
             ..PlaceInitialOfferInstructionConfig::default()

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

@@ -1,7 +1,7 @@
 use anchor_lang::prelude::*;
 use solana_program::instruction::Instruction;
 
-use crate::{error::MatchingEngineError, state::FastMarketOrder};
+use crate::error::MatchingEngineError;
 
 pub struct CloseFastMarketOrderAccounts<'ix> {
     /// The fast market order account to be closed.
@@ -43,13 +43,9 @@ pub fn process(accounts: &[AccountInfo]) -> Result<()> {
     // We need to check the refund recipient account against what we know as the
     // refund recipient encoded in the fast market order account.
     let fast_market_order_info = &accounts[0];
-    let refund_recipient_info = &accounts[1];
-
-    let fast_market_order_data = &fast_market_order_info.data.borrow()[..];
+    let fast_market_order = super::helpers::try_fast_market_order_account(fast_market_order_info)?;
 
-    // NOTE: We do not need to verify that the owner of this account is this
-    // program because the lamport transfer will fail otherwise.
-    let fast_market_order = FastMarketOrder::try_read(fast_market_order_data)?;
+    let refund_recipient_info = &accounts[1];
 
     // Check that the refund recipient provided in this instruction is the one
     // encoded in the fast market order account.

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

@@ -195,8 +195,9 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
     // Do checks
     // ------------------------------------------------------------------------------------------------
 
-    let fast_market_order_data = &fast_market_order_account.data.borrow()[..];
-    let fast_market_order_zero_copy = FastMarketOrderState::try_read(fast_market_order_data)?;
+    let fast_market_order_zero_copy =
+        super::helpers::try_fast_market_order_account(fast_market_order_account)?;
+
     // Bind value for compiler (needed for pda seeds)
     let active_auction_key = active_auction_account.key();
 
@@ -222,7 +223,7 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
     };
 
     // Check custodian owner
-    check_custodian_owner_is_program_id(custodian_account)?;
+    super::helpers::require_owned_by_this_program(custodian_account, "custodian")?;
 
     // Check custodian deserialises into a checked custodian account
     let _checked_custodian = Custodian::try_deserialize(&mut &custodian_account.data.borrow()[..])?;
@@ -471,7 +472,6 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
         .saturating_add(active_auction_info.security_deposit)
         .saturating_sub(user_reward);
 
-
     let penalized = penalty > 0;
 
     if penalized && active_auction_best_offer_token_account.key() != executor_token_account.key() {
@@ -503,7 +503,7 @@ pub fn handle_execute_order_shim(accounts: &[AccountInfo]) -> Result<()> {
                 init_auction_fee,
             )
             .unwrap();
-     
+
             invoke_signed_unchecked(&transfer_ix, accounts, &[auction_signer_seeds])?;
             // Because the initial offer token was paid this fee, we account for it here.
             remaining_custodied_amount =

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

@@ -1,14 +1,21 @@
-use anchor_lang::prelude::*;
+use std::cell::Ref;
+
+use anchor_lang::{prelude::*, Discriminator};
 use anchor_spl::token::spl_token;
 use solana_program::{
     entrypoint::ProgramResult,
     instruction::{AccountMeta, Instruction},
+    keccak,
     program::invoke_signed_unchecked,
     program_pack::Pack,
     system_instruction,
 };
 
-use crate::ID;
+use crate::{
+    error::MatchingEngineError,
+    state::{AuctionConfig, Custodian, FastMarketOrder, MessageProtocol, RouterEndpoint},
+    ID,
+};
 
 #[inline(always)]
 pub fn require_min_account_infos_len(accounts: &[AccountInfo], at_least_len: usize) -> Result<()> {
@@ -20,11 +27,119 @@ pub fn require_min_account_infos_len(accounts: &[AccountInfo], at_least_len: usi
 }
 
 #[inline(always)]
-pub fn check_custodian_owner_is_program_id(custodian: &AccountInfo) -> Result<()> {
-    require_eq!(custodian.owner, &ID, ErrorCode::ConstraintOwner);
+pub fn require_owned_by_this_program(account: &AccountInfo, account_name: &str) -> Result<()> {
+    if account.owner != &ID {
+        return Err(ErrorCode::ConstraintOwner.into())
+            .map_err(|e: Error| e.with_account_name(account_name));
+    }
+
     Ok(())
 }
 
+#[inline(always)]
+pub fn try_custodian_account(
+    custodian_info: &AccountInfo,
+    check_if_paused: bool,
+) -> Result<Box<Custodian>> {
+    super::helpers::require_owned_by_this_program(custodian_info, "custodian")?;
+
+    let custodian =
+        Custodian::try_deserialize(&mut &custodian_info.data.borrow()[..]).map(Box::new)?;
+
+    // Make sure the custodian is not paused.
+    if check_if_paused && custodian.paused {
+        return Err(MatchingEngineError::Paused.into());
+    }
+
+    Ok(custodian)
+}
+
+#[inline(always)]
+pub fn try_auction_config_account(
+    auction_config_info: &AccountInfo,
+    expected_config_id: Option<u32>,
+) -> Result<Box<AuctionConfig>> {
+    super::helpers::require_owned_by_this_program(auction_config_info, "auction_config")?;
+
+    let auction_config =
+        AuctionConfig::try_deserialize(&mut &auction_config_info.data.borrow()[..])
+            .map(Box::new)?;
+
+    // Make sure the custodian is not paused.
+    if let Some(expected_config_id) = expected_config_id {
+        if auction_config.id != expected_config_id {
+            msg!("Auction config id is invalid");
+            return Err(ErrorCode::ConstraintRaw.into())
+                .map_err(|e: Error| e.with_account_name("auction_config"));
+        }
+    }
+
+    Ok(auction_config)
+}
+
+#[inline(always)]
+pub fn try_live_endpoint_account(
+    endpoint_info: &AccountInfo,
+    endpoint_name: &str,
+) -> Result<Box<RouterEndpoint>> {
+    super::helpers::require_owned_by_this_program(endpoint_info, endpoint_name)?;
+
+    let endpoint =
+        RouterEndpoint::try_deserialize(&mut &endpoint_info.data.borrow()[..]).map(Box::new)?;
+
+    if endpoint.protocol == MessageProtocol::None {
+        return Err(MatchingEngineError::EndpointDisabled.into());
+    }
+
+    Ok(endpoint)
+}
+
+#[inline(always)]
+pub fn try_live_endpoint_accounts_path(
+    from_endpoint_info: &AccountInfo,
+    to_endpoint_info: &AccountInfo,
+) -> Result<(Box<RouterEndpoint>, Box<RouterEndpoint>)> {
+    let from_endpoint = try_live_endpoint_account(from_endpoint_info, "from_endpoint")?;
+    let to_endpoint = try_live_endpoint_account(to_endpoint_info, "to_endpoint")?;
+
+    if from_endpoint.chain == to_endpoint.chain {
+        return Err(MatchingEngineError::SameEndpoint.into());
+    }
+
+    Ok((from_endpoint, to_endpoint))
+}
+
+pub fn try_usdc_account<'a, 'b>(usdc_info: &'a AccountInfo<'b>) -> Result<&'a AccountInfo<'b>> {
+    if usdc_info.key != &common::USDC_MINT {
+        return Err(MatchingEngineError::InvalidMint.into())
+            .map_err(|e: Error| e.with_account_name("usdc"));
+    }
+
+    Ok(usdc_info)
+}
+
+/// Read from an account info
+pub fn try_fast_market_order_account<'a>(
+    fast_market_order_info: &'a AccountInfo,
+) -> Result<Ref<'a, FastMarketOrder>> {
+    let data = fast_market_order_info.data.borrow();
+
+    if data.len() < 8 {
+        return Err(ErrorCode::AccountDiscriminatorNotFound.into());
+    }
+
+    if &data[0..8] != &FastMarketOrder::DISCRIMINATOR {
+        return Err(ErrorCode::AccountDiscriminatorMismatch.into());
+    }
+
+    // TODO: Move up?
+    super::helpers::require_owned_by_this_program(fast_market_order_info, "fast_market_order")?;
+
+    Ok(Ref::map(data, |data| {
+        bytemuck::from_bytes(&data[8..8 + std::mem::size_of::<FastMarketOrder>()])
+    }))
+}
+
 pub fn create_account_reliably(
     payer_key: &Pubkey,
     account_key: &Pubkey,
@@ -180,3 +295,72 @@ pub fn create_usdc_token_account_reliably(
 
     solana_program::program::invoke_signed_unchecked(&init_token_account_ix, accounts, &[])
 }
+
+/// VaaMessageBodyHeader for the digest calculation
+///
+/// This is the header of the vaa message body. It is used to calculate the
+/// digest of the fast market order.
+#[derive(Debug)]
+pub struct VaaMessageBodyHeader {
+    pub consistency_level: u8,
+    pub timestamp: u32,
+    pub sequence: u64,
+    pub emitter_chain: u16,
+    pub emitter_address: [u8; 32],
+}
+
+impl VaaMessageBodyHeader {
+    // TODO: Remove
+    pub fn new(
+        consistency_level: u8,
+        timestamp: u32,
+        sequence: u64,
+        emitter_chain: u16,
+        emitter_address: [u8; 32],
+    ) -> Self {
+        Self {
+            consistency_level,
+            timestamp,
+            sequence,
+            emitter_chain,
+            emitter_address,
+        }
+    }
+
+    /// This function creates both the message body for the fast market order, including the payload.
+    pub fn message_body(&self, fast_market_order: &FastMarketOrder) -> Vec<u8> {
+        let mut message_body = vec![];
+        message_body.extend_from_slice(&self.timestamp.to_be_bytes());
+        message_body.extend_from_slice(&[0, 0, 0, 0]); // 0 nonce
+        message_body.extend_from_slice(&self.emitter_chain.to_be_bytes());
+        message_body.extend_from_slice(&self.emitter_address);
+        message_body.extend_from_slice(&self.sequence.to_be_bytes());
+        message_body.extend_from_slice(&[self.consistency_level]);
+        message_body.push(11_u8);
+        message_body.extend_from_slice(&fast_market_order.amount_in.to_be_bytes());
+        message_body.extend_from_slice(&fast_market_order.min_amount_out.to_be_bytes());
+        message_body.extend_from_slice(&fast_market_order.target_chain.to_be_bytes());
+        message_body.extend_from_slice(&fast_market_order.redeemer);
+        message_body.extend_from_slice(&fast_market_order.sender);
+        message_body.extend_from_slice(&fast_market_order.refund_address);
+        message_body.extend_from_slice(&fast_market_order.max_fee.to_be_bytes());
+        message_body.extend_from_slice(&fast_market_order.init_auction_fee.to_be_bytes());
+        message_body.extend_from_slice(&fast_market_order.deadline.to_be_bytes());
+        message_body.extend_from_slice(&fast_market_order.redeemer_message_length.to_be_bytes());
+        if fast_market_order.redeemer_message_length > 0 {
+            message_body.extend_from_slice(
+                &fast_market_order.redeemer_message
+                    [..usize::from(fast_market_order.redeemer_message_length)],
+            );
+        }
+        message_body
+    }
+
+    /// The digest is the hash of the message hash.
+    pub fn digest(&self, fast_market_order: &FastMarketOrder) -> keccak::Hash {
+        wormhole_svm_definitions::compute_keccak_digest(
+            keccak::hashv(&[&self.message_body(fast_market_order)]),
+            None,
+        )
+    }
+}

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

@@ -1,8 +1,10 @@
 pub mod burn_and_post;
 pub mod close_fast_market_order;
+// TODO: Rename module to "execute_order_cctp".
 pub mod execute_order;
 pub mod helpers;
 pub mod initialize_fast_market_order;
+// TODO: Rename module to "place_initial_offer_cctp".
 pub mod place_initial_offer;
 pub mod prepare_order_response;
 pub mod process_instruction;