place initial offer and prepare order response

Author: Bengt Lofgren

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

@@ -94,6 +94,7 @@ pub enum MatchingEngineError {
     AccountAlreadyInitialized = 0x700,
     AccountNotWritable = 0x702,
     BorshDeserializationError = 0x704,
+    BorshSerializationError = 0x705,
     InvalidPda = 0x706,
     AccountDataTooSmall = 0x708,
     InvalidProgram = 0x70a,

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

@@ -1,15 +1,18 @@
 use std::io::Cursor;
 
 use super::helpers::create_account_reliably;
+use super::place_initial_offer::VaaMessageBodyHeader;
 use super::FallbackMatchingEngineInstruction;
 use crate::fallback::helpers::check_account_length;
+use crate::fallback::helpers::create_token_account_reliably;
 use crate::state::PreparedOrderResponseInfo;
 use crate::state::PreparedOrderResponseSeeds;
 use crate::state::{
     Custodian, FastMarketOrder as FastMarketOrderState, MessageProtocol, PreparedOrderResponse,
     RouterEndpoint,
 };
 use crate::CCTP_MINT_RECIPIENT;
+use crate::ID;
 use anchor_lang::prelude::*;
 use anchor_spl::token::spl_token;
 use common::messages::SlowOrderResponse;
@@ -42,24 +45,18 @@ pub struct FinalizedVaaMessageArgs {
 }
 
 impl FinalizedVaaMessageArgs {
-    #[allow(clippy::too_many_arguments)]
     pub fn digest(
         &self,
-        sequence: u64,
-        timestamp: u32,
-        emitter_chain: u16,
-        emitter_address: [u8; 32],
-        nonce: u32,
-        consistency_level: u8,
+        vaa_message_body_header: VaaMessageBodyHeader,
         deposit_vaa_payload: Deposit,
     ) -> [u8; 32] {
         let message_hash = keccak::hashv(&[
-            timestamp.to_be_bytes().as_ref(),
-            nonce.to_be_bytes().as_ref(),
-            emitter_chain.to_be_bytes().as_ref(),
-            &emitter_address,
-            &sequence.to_be_bytes(),
-            &[consistency_level],
+            vaa_message_body_header.vaa_time.to_be_bytes().as_ref(),
+            vaa_message_body_header.nonce.to_be_bytes().as_ref(),
+            vaa_message_body_header.emitter_chain.to_be_bytes().as_ref(),
+            &vaa_message_body_header.emitter_address,
+            &vaa_message_body_header.sequence.to_be_bytes(),
+            &[vaa_message_body_header.consistency_level],
             deposit_vaa_payload.to_vec().as_ref(),
         ]);
         // Digest is the hash of the message
@@ -71,23 +68,9 @@ impl FinalizedVaaMessageArgs {
 }
 
 impl PrepareOrderResponseCctpShimData {
-    pub fn new(
-        encoded_cctp_message: Vec<u8>,
-        cctp_attestation: Vec<u8>,
-        finalized_vaa_message_args: FinalizedVaaMessageArgs,
-    ) -> Self {
-        Self {
-            encoded_cctp_message,
-            cctp_attestation,
-            finalized_vaa_message_args,
-        }
-    }
     pub fn from_bytes(data: &[u8]) -> Option<Self> {
         Self::try_from_slice(data).ok()
     }
-    pub fn to_bytes(&self) -> Vec<u8> {
-        self.try_to_vec().unwrap()
-    }
 
     pub fn to_receive_message_args(&self) -> ReceiveMessageArgs {
         let mut encoded_message = Vec::with_capacity(self.encoded_cctp_message.len());
@@ -188,7 +171,7 @@ pub fn prepare_order_response_cctp_shim(
     accounts: &[AccountInfo],
     data: PrepareOrderResponseCctpShimData,
 ) -> Result<()> {
-    let program_id = &crate::ID;
+    let program_id = &ID;
     check_account_length(accounts, 27)?;
 
     let signer = &accounts[0];
@@ -366,7 +349,6 @@ pub fn prepare_order_response_cctp_shim(
         let finalised_vaa_sequence = fast_market_order_zero_copy.vaa_sequence.saturating_sub(1);
         let finalised_vaa_emitter_chain = fast_market_order_zero_copy.vaa_emitter_chain;
         let finalised_vaa_emitter_address = fast_market_order_zero_copy.vaa_emitter_address;
-        let finalised_vaa_nonce = fast_market_order_zero_copy.vaa_nonce;
         let finalised_vaa_consistency_level = finalized_vaa_message_args.consistency_level;
         let slow_order_response = SlowOrderResponse {
             base_fee: finalized_vaa_message_args.base_fee,
@@ -383,12 +365,13 @@ pub fn prepare_order_response_cctp_shim(
         };
 
         finalized_vaa_message_args.digest(
-            finalised_vaa_sequence,
-            finalised_vaa_timestamp,
-            finalised_vaa_emitter_chain,
-            finalised_vaa_emitter_address,
-            finalised_vaa_nonce,
-            finalised_vaa_consistency_level,
+            VaaMessageBodyHeader::new(
+                finalised_vaa_consistency_level,
+                finalised_vaa_timestamp,
+                finalised_vaa_sequence,
+                finalised_vaa_emitter_chain,
+                finalised_vaa_emitter_address,
+            ),
             deposit_vaa_payload,
         )
     };
@@ -488,23 +471,17 @@ pub fn prepare_order_response_cctp_shim(
     ];
 
     let prepared_custody_token_signer_seeds = &[&create_prepared_custody_token_seeds[..]];
-    let prepared_custody_token_account_space = spl_token::state::Account::LEN;
-    create_account_reliably(
+    create_token_account_reliably(
         &signer.key(),
         &prepared_custody_token_pda,
+        &prepared_order_response_pda,
+        &usdc.key(),
+        spl_token::state::Account::LEN,
         prepared_custody_token.lamports(),
-        prepared_custody_token_account_space,
         accounts,
-        &spl_token::ID,
         prepared_custody_token_signer_seeds,
     )?;
-    let init_token_account_ix = spl_token::instruction::initialize_account3(
-        &spl_token::ID,
-        &prepared_custody_token_pda,
-        &usdc.key(),
-        &prepared_order_response_pda,
-    )?;
-    solana_program::program::invoke_signed_unchecked(&init_token_account_ix, accounts, &[])?;
+
     // End create prepared custody token account
     // ------------------------------------------------------------------------------------------------
 

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

@@ -149,7 +149,7 @@ impl FallbackMatchingEngineInstruction<'_> {
                 out
             }
             Self::PrepareOrderResponseCctpShim(data) => {
-                let data_slice = data.to_bytes();
+                let data_slice = data.try_to_vec().unwrap();
                 let total_capacity = 8_usize.saturating_add(data_slice.len()); // 8 for the selector, plus the data length
 
                 let mut out = Vec::with_capacity(total_capacity);