solana: fix beneficiary for reserved sequence

Author: a5-pickle

solana/programs/matching-engine/src/composite/mod.rs

@@ -566,7 +566,7 @@ impl<'info> VaaDigest for ClosePreparedOrderResponse<'info> {
 #[derive(Accounts)]
 pub struct ReserveFastFillSequence<'info> {
     #[account(mut)]
-    payer: Signer<'info>,
+    pub payer: Signer<'info>,
 
     pub fast_order_path: FastOrderPath<'info>,
 

solana/programs/matching-engine/src/processor/auction/execute_fast_order/mod.rs

@@ -99,32 +99,33 @@ fn handle_execute_fast_order<'info>(
         // init auction fee. The executor will get these funds instead.
         //
         // We check that this is a legitimate token account.
-        if utils::checked_deserialize_token_account(initial_offer_token, &custody_token.mint)
+        if utils::checked_deserialize_token_account(initial_offer_token, &common::USDC_MINT)
             .is_some()
-            && best_offer_token.key() != initial_offer_token.key()
         {
-            // Pay the auction initiator their fee.
-            token::transfer(
-                CpiContext::new_with_signer(
-                    token_program.to_account_info(),
-                    token::Transfer {
-                        from: custody_token.to_account_info(),
-                        to: initial_offer_token.to_account_info(),
-                        authority: auction.to_account_info(),
-                    },
-                    &[auction_signer_seeds],
-                ),
-                init_auction_fee,
-            )?;
+            if best_offer_token.key() != initial_offer_token.key() {
+                // Pay the auction initiator their fee.
+                token::transfer(
+                    CpiContext::new_with_signer(
+                        token_program.to_account_info(),
+                        token::Transfer {
+                            from: custody_token.to_account_info(),
+                            to: initial_offer_token.to_account_info(),
+                            authority: auction.to_account_info(),
+                        },
+                        &[auction_signer_seeds],
+                    ),
+                    init_auction_fee,
+                )?;
 
-            // Because the initial offer token was paid this fee, we account for it here.
-            remaining_custodied_amount =
-                remaining_custodied_amount.saturating_sub(init_auction_fee);
-        } else {
-            // Add it to the reimbursement.
-            deposit_and_fee = deposit_and_fee
-                .checked_add(init_auction_fee)
-                .ok_or_else(|| MatchingEngineError::U64Overflow)?;
+                // Because the initial offer token was paid this fee, we account for it here.
+                remaining_custodied_amount =
+                    remaining_custodied_amount.saturating_sub(init_auction_fee);
+            } else {
+                // Add it to the reimbursement.
+                deposit_and_fee = deposit_and_fee
+                    .checked_add(init_auction_fee)
+                    .ok_or_else(|| MatchingEngineError::U64Overflow)?;
+            }
         }
 
         // Return the security deposit and the fee to the highest bidder.
@@ -152,7 +153,7 @@ fn handle_execute_fast_order<'info>(
             // Otherwise, send the deposit and fee to the best offer token. If the best offer token
             // doesn't exist at this point (which would be unusual), we will reserve these funds
             // for the executor token.
-            if utils::checked_deserialize_token_account(best_offer_token, &custody_token.mint)
+            if utils::checked_deserialize_token_account(best_offer_token, &common::USDC_MINT)
                 .is_some()
             {
                 token::transfer(

solana/programs/matching-engine/src/processor/auction/offer/improve.rs

@@ -79,7 +79,7 @@ pub fn improve_offer(ctx: Context<ImproveOffer>, offer_price: u64) -> Result<()>
             // If the best offer token happens to be closed, we will just keep the funds in the
             // auction custody account. The executor token account will collect these funds when the
             // order is executed.
-            if utils::checked_deserialize_token_account(best_offer_token, &custody_token.mint)
+            if utils::checked_deserialize_token_account(best_offer_token, &common::USDC_MINT)
                 .is_some()
             {
                 token::transfer(

solana/programs/matching-engine/src/processor/auction/settle/complete.rs

@@ -2,6 +2,7 @@ use crate::{
     error::MatchingEngineError,
     events::SettledTokenAccountInfo,
     state::{Auction, AuctionStatus, PreparedOrderResponse},
+    utils,
 };
 use anchor_lang::prelude::*;
 use anchor_spl::{
@@ -116,23 +117,24 @@ fn handle_settle_auction_complete(
     let (executor_result, best_offer_result) = match execute_penalty {
         None => {
             // If the token account happens to not exist anymore, we will revert.
-            match TokenAccount::try_deserialize(&mut &best_offer_token.data.borrow()[..]) {
-                Ok(best_offer) => (
-                    None, // executor_result
-                    TokenAccountResult {
-                        balance_before: best_offer.amount,
-                        amount: repayment,
-                    }
-                    .into(),
-                ),
-                Err(err) => return Err(err),
-            }
+            let best_offer =
+                utils::checked_deserialize_token_account(best_offer_token, &common::USDC_MINT)
+                    .ok_or_else(|| MatchingEngineError::BestOfferTokenRequired)?;
+
+            (
+                None, // executor_result
+                TokenAccountResult {
+                    balance_before: best_offer.amount,
+                    amount: repayment,
+                }
+                .into(),
+            )
         }
         _ => {
             // If the token account happens to not exist anymore, we will give everything to the
             // executor.
-            match TokenAccount::try_deserialize(&mut &best_offer_token.data.borrow()[..]) {
-                Ok(best_offer) => {
+            match utils::checked_deserialize_token_account(best_offer_token, &common::USDC_MINT) {
+                Some(best_offer) => {
                     if executor_token.key() == best_offer_token.key() {
                         (
                             None, // executor_result
@@ -179,7 +181,7 @@ fn handle_settle_auction_complete(
                         )
                     }
                 }
-                Err(_) => (
+                None => (
                     TokenAccountResult {
                         balance_before: executor_token.amount,
                         amount: repayment,

solana/programs/matching-engine/src/processor/fast_fill/reserve_sequence/active_auction.rs

@@ -1,6 +1,5 @@
 use crate::{composite::*, error::MatchingEngineError, state::AuctionConfig};
 use anchor_lang::prelude::*;
-use anchor_spl::token;
 
 #[derive(Accounts)]
 pub struct ReserveFastFillSequenceActiveAuction<'info> {
@@ -27,56 +26,12 @@ pub struct ReserveFastFillSequenceActiveAuction<'info> {
         }
     )]
     auction_config: Account<'info, AuctionConfig>,
-
-    /// Best offer token account, whose owner will be the beneficiary of the reserved fast fill
-    /// sequence account when it is closed.
-    ///
-    /// CHECK: This account may not exist. If it does, it should equal the best offer token pubkey
-    /// in the auction account.
-    #[account(
-        constraint = {
-            // We know from the auction constraint that the auction is active, so the auction info
-            // is safe to unwrap.
-            let info = reserve_sequence.auction.info.as_ref().unwrap();
-
-            // Best offer token must equal the one in the auction account.
-            //
-            // NOTE: Unwrapping the auction info is safe because we know this is an active auction.
-            require_keys_eq!(
-                best_offer_token.key(),
-                info.best_offer_token,
-                MatchingEngineError::BestOfferTokenMismatch
-            );
-
-            true
-        }
-    )]
-    best_offer_token: UncheckedAccount<'info>,
-
-    /// CHECK: If the best offer token does not exist anymore, this executor will be the beneficiary
-    /// of the reserved fast fill sequence account when it is closed. Otherwise, this account must
-    /// equal the best offer token account's owner.
-    executor: UncheckedAccount<'info>,
 }
 
 pub fn reserve_fast_fill_sequence_active_auction(
     ctx: Context<ReserveFastFillSequenceActiveAuction>,
 ) -> Result<()> {
-    let best_offer_token = &ctx.accounts.best_offer_token;
-    let beneficiary = ctx.accounts.executor.key();
-
-    // If the token account does exist, we will constrain that the executor is the best offer token.
-    if let Ok(token) =
-        token::TokenAccount::try_deserialize(&mut &best_offer_token.data.borrow()[..])
-    {
-        require_keys_eq!(
-            *best_offer_token.owner,
-            token::ID,
-            ErrorCode::ConstraintTokenTokenProgram
-        );
-        require_keys_eq!(token.owner, beneficiary, ErrorCode::ConstraintTokenOwner);
-    }
-
+    let beneficiary = ctx.accounts.reserve_sequence.payer.key();
     let fast_vaa_hash = ctx.accounts.reserve_sequence.auction.vaa_hash;
 
     super::set_reserved_sequence_data(

solana/ts/tests/04__interaction.ts

@@ -1091,7 +1091,7 @@ describe("Matching Engine <> Token Router", function () {
         const { success, result } = await invokeReserveFastFillSequence(
             ix,
             fastVaaAccount,
-            playerOne.publicKey,
+            payer.publicKey,
             testOpts,
         );