refactored execute_fast_order fn to be reused

Author: Bengt Lofgren

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

@@ -9,8 +9,8 @@ use solana_program::{instruction::Instruction, program::invoke_signed_unchecked}
 
 use crate::{
     error::MatchingEngineError,
+    processor::{get_user_amount_and_new_status_and_penalized, ActiveAuctionAccountInfos},
     state::{Auction, AuctionStatus, Custodian, MessageProtocol},
-    utils::{self, auction::DepositPenalty},
     ID,
 };
 
@@ -346,193 +346,28 @@ pub(super) fn process(accounts: &[AccountInfo]) -> Result<()> {
     // TODO: Do we have to verify the CCTP message transmitter program is passed
     // in?
 
-    ////////////////////////////////////////////////////////////////////////////
-    //
-    // TODO: This execute order logic has been taken from the original execute
-    // order instructions. We plan on using a helper method instead of copy-
-    // pasting the same logic here.
-    //
-    ////////////////////////////////////////////////////////////////////////////
-
     // Prepare the execute order (get the user amount, fill, and order executed event)
-    let current_slot = Clock::get().unwrap().slot;
-
-    // We extend the grace period for locally executed orders. Reserving a sequence number for
-    // the fast fill will most likely require an additional transaction, so this buffer allows
-    // the best offer participant to perform his duty without the risk of getting slashed by
-    // another executor.
-    let additional_grace_period = match active_auction.target_protocol {
-        MessageProtocol::Local { .. } => {
-            crate::EXECUTE_FAST_ORDER_LOCAL_ADDITIONAL_GRACE_PERIOD.into()
-        }
-        _ => None,
+    let active_auction_accounts = ActiveAuctionAccountInfos {
+        auction_best_offer_token: auction_best_offer_token_info.to_account_info(),
+        auction_executor_token: executor_token_info.to_account_info(),
+        auction_initial_offer_token: auction_initial_offer_token_info.to_account_info(),
+        auction_custody_token: auction_custody_info.to_account_info(),
+        active_auction: active_auction_info.to_account_info(),
+        auction_custodian: custodian_info.to_account_info(),
     };
-
-    let DepositPenalty {
-        penalty,
-        user_reward,
-    } = utils::auction::compute_deposit_penalty(
-        &auction_config,
-        active_auction_inner_info,
-        current_slot,
-        additional_grace_period,
-    );
-
-    let init_auction_fee = fast_market_order.init_auction_fee;
-
-    let user_amount = active_auction_inner_info
-        .amount_in
-        .saturating_sub(active_auction_inner_info.offer_price)
-        .saturating_sub(init_auction_fee)
-        .saturating_add(user_reward);
-
-    // Keep track of the remaining amount in the custody token account. Whatever remains will go
-    // to the executor.
-
     let custody_token =
         TokenAccount::try_deserialize(&mut &auction_custody_info.data.borrow()[..])?;
-    let mut remaining_custodied_amount = custody_token.amount.saturating_sub(user_amount);
-
-    // Offer price + security deposit was checked in placing the initial offer.
-    let mut deposit_and_fee = active_auction_inner_info
-        .offer_price
-        .saturating_add(active_auction_inner_info.security_deposit)
-        .saturating_sub(user_reward);
-
-    let penalized = penalty > 0;
-
-    if penalized && auction_best_offer_token_info.key != executor_token_info.key {
-        deposit_and_fee = deposit_and_fee.saturating_sub(penalty);
-    }
-
-    // Need these seeds in order to transfer tokens and then set authority of auction custody token account to the custodian
-    let auction_signer_seeds = &[
-        Auction::SEED_PREFIX,
-        active_auction.vaa_hash.as_ref(),
-        &[active_auction.bump],
-    ];
-
-    // If the initial offer token account doesn't exist anymore, we have nowhere to send the
-    // 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(
-        auction_initial_offer_token_info,
-        &common::USDC_MINT,
-    )
-    .is_some()
-    {
-        if auction_best_offer_token_info.key() != auction_initial_offer_token_info.key() {
-            // Pay the auction initiator their fee.
-            let transfer_ix = spl_token::instruction::transfer(
-                &spl_token::ID,
-                &auction_custody_info.key(),
-                &auction_initial_offer_token_info.key(),
-                &active_auction_info.key(),
-                &[],
-                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 =
-                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.
-    if auction_best_offer_token_info.key == executor_token_info.key {
-        // If the best offer token is equal to the executor token, just send whatever remains in
-        // the custody token account.
-        //
-        // NOTE: This will revert if the best offer token does not exist. But this will present
-        // an opportunity for another executor to execute this order and take what the best
-        // offer token would have received.
-        let transfer_ix = spl_token::instruction::transfer(
-            &spl_token::ID,
-            &auction_custody_info.key(),
-            &auction_best_offer_token_info.key(),
-            &active_auction_info.key(),
-            &[],
-            deposit_and_fee,
-        )
-        .unwrap();
-        msg!(
-            "Sending deposit and fee amount {} to best offer token account",
-            deposit_and_fee
-        );
-        invoke_signed_unchecked(&transfer_ix, accounts, &[auction_signer_seeds])?;
-    } else {
-        // 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(
-            auction_best_offer_token_info,
-            &common::USDC_MINT,
-        )
-        .is_some()
-        {
-            let transfer_ix = spl_token::instruction::transfer(
-                &spl_token::ID,
-                &auction_custody_info.key(),
-                &auction_best_offer_token_info.key(),
-                &active_auction_info.key(),
-                &[],
-                deposit_and_fee,
-            )
-            .unwrap();
-            msg!(
-                "Sending deposit and fee {} to best offer token account",
-                deposit_and_fee
-            );
-            invoke_signed_unchecked(&transfer_ix, accounts, &[auction_signer_seeds])?;
-            remaining_custodied_amount = remaining_custodied_amount.saturating_sub(deposit_and_fee);
-        }
-
-        // And pay the executor whatever remains in the auction custody token account.
-        if remaining_custodied_amount > 0 {
-            let instruction = spl_token::instruction::transfer(
-                &spl_token::ID,
-                auction_custody_info.key,
-                executor_token_info.key,
-                &active_auction_info.key(),
-                &[],
-                remaining_custodied_amount,
-            )
-            .unwrap();
-            msg!(
-                "Sending remaining custodied amount {} to executor token account",
-                remaining_custodied_amount
-            );
-            invoke_signed_unchecked(&instruction, accounts, &[auction_signer_seeds])?;
-        }
-    }
-
-    // Set the authority of the custody token account to the custodian. He will take over from
-    // here.
-    let set_authority_ix = spl_token::instruction::set_authority(
-        &spl_token::ID,
-        auction_custody_info.key,
-        Some(custodian_info.key),
-        spl_token::instruction::AuthorityType::AccountOwner,
-        active_auction_info.key,
-        &[],
-    )
-    .unwrap();
-
-    invoke_signed_unchecked(&set_authority_ix, accounts, &[auction_signer_seeds])?;
+    let (user_amount, new_status, _penalized) = get_user_amount_and_new_status_and_penalized(
+        &active_auction,
+        &custody_token,
+        &auction_config,
+        fast_market_order.init_auction_fee,
+        active_auction_accounts,
+        accounts,
+    )?;
 
     // Set the active auction status
-    active_auction.status = AuctionStatus::Completed {
-        slot: current_slot,
-        execute_penalty: if penalized { penalty.into() } else { None },
-    };
+    active_auction.status = new_status;
 
     let active_auction_info_data: &mut [u8] = &mut active_auction_info.data.borrow_mut();
     let mut active_auction_cursor = std::io::Cursor::new(active_auction_info_data);
@@ -549,12 +384,6 @@ pub(super) fn process(accounts: &[AccountInfo]) -> Result<()> {
             .unwrap(),
     };
 
-    ////////////////////////////////////////////////////////////////////////////
-    //
-    // TODO: See above TODO. This is the end of the copy-pasted logic.
-    //
-    ////////////////////////////////////////////////////////////////////////////
-
     // TODO: Write test that passes in random keypair for CCTP message account
     // to show that not having to check the PDA address is safe.
     let (_, new_cctp_message_bump) = Pubkey::find_program_address(