solana: handle non-existent best offer token for settle complete (#173)

Co-authored-by: A5 Pickle <[email protected]>

Author: a5-pickle

solana/programs/matching-engine/src/events/auction_settled.rs

@@ -1,18 +1,25 @@
 use crate::state::MessageProtocol;
 use anchor_lang::prelude::*;
 
+#[derive(Debug, AnchorSerialize, AnchorDeserialize)]
+pub struct SettledTokenAccountInfo {
+    pub key: Pubkey,
+    pub balance_after: u64,
+}
+
 #[event]
 #[derive(Debug)]
 pub struct AuctionSettled {
     /// The pubkey of the auction that was settled.
     pub auction: Pubkey,
 
-    /// If there was an active auction, this pubkey is the best offer token that was paid back.
-    pub best_offer_token: Option<Pubkey>,
+    /// If there was an active auction, this field will have the pubkey of the best offer token that
+    /// was paid back and its balance after repayment.
+    pub best_offer_token: Option<SettledTokenAccountInfo>,
 
-    /// Token account's new balance. If there was no auction, this balance will be of the fee
-    /// recipient token account.
-    pub token_balance_after: u64,
+    /// Depending on whether there was an active auction, this field will have the pubkey of the
+    /// executor token (if there was an auction) or fee recipient token (if there was no auction).
+    pub executor_token: Option<SettledTokenAccountInfo>,
 
     /// This value will only be some if there was no active auction.
     pub with_execute: Option<MessageProtocol>,

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

@@ -1,9 +1,13 @@
 use crate::{
     error::MatchingEngineError,
+    events::SettledTokenAccountInfo,
     state::{Auction, AuctionStatus, PreparedOrderResponse},
 };
 use anchor_lang::prelude::*;
-use anchor_spl::{associated_token::get_associated_token_address, token};
+use anchor_spl::{
+    associated_token::get_associated_token_address,
+    token::{self, TokenAccount},
+};
 
 #[derive(Accounts)]
 pub struct SettleAuctionComplete<'info> {
@@ -16,21 +20,22 @@ pub struct SettleAuctionComplete<'info> {
 
     #[account(
         mut,
-        token::mint = best_offer_token.mint,
+        token::mint = common::USDC_MINT,
         token::authority = executor,
     )]
-    executor_token: Account<'info, token::TokenAccount>,
+    executor_token: Account<'info, TokenAccount>,
 
     /// Destination token account, which the redeemer may not own. But because the redeemer is a
     /// signer and is the one encoded in the Deposit Fill message, he may have the tokens be sent
     /// to any account he chooses (this one).
     ///
-    /// CHECK: This token account must already exist.
+    /// CHECK: This token account may exist. If it doesn't and there is a penalty, we will send all
+    /// of the tokens to the executor token account.
     #[account(
         mut,
         address = auction.info.as_ref().unwrap().best_offer_token,
     )]
-    best_offer_token: Account<'info, token::TokenAccount>,
+    best_offer_token: UncheckedAccount<'info>,
 
     #[account(
         mut,
@@ -52,7 +57,7 @@ pub struct SettleAuctionComplete<'info> {
         ],
         bump,
     )]
-    prepared_custody_token: Account<'info, token::TokenAccount>,
+    prepared_custody_token: Account<'info, TokenAccount>,
 
     #[account(
         mut,
@@ -101,10 +106,14 @@ fn handle_settle_auction_complete(
     let token_program = &ctx.accounts.token_program;
     let prepared_custody_token = &ctx.accounts.prepared_custody_token;
 
-    // We may deduct from this account if the winning participant was penalized.
-    let mut repayment = ctx.accounts.prepared_custody_token.amount;
+    let repayment = ctx.accounts.prepared_custody_token.amount;
+
+    struct TokenAccountResult {
+        balance_before: u64,
+        amount: u64,
+    }
 
-    match execute_penalty {
+    let (executor_result, best_offer_result) = match execute_penalty {
         None => {
             // If there is no penalty, we require that the executor token and best offer token be
             // equal. The winning offer should not be penalized for calling this instruction when he
@@ -118,6 +127,19 @@ fn handle_settle_auction_complete(
                 best_offer_token.key(),
                 MatchingEngineError::ExecutorTokenMismatch
             );
+
+            // 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),
+            }
         }
         _ => {
             // If there is a penalty, we want to return the lamports back to the person who paid to
@@ -131,55 +153,121 @@ fn handle_settle_auction_complete(
                 MatchingEngineError::ExecutorNotPreparedBy
             );
 
-            if executor_token.key() != best_offer_token.key() {
-                // Because the auction participant was penalized for executing the order late, he
-                // will be deducted the base fee. This base fee will be sent to the executor token
-                // account if it is not the same as the best offer token account.
-
-                // We require that the executor token account be an ATA.
-                require_keys_eq!(
-                    executor_token.key(),
-                    get_associated_token_address(&executor_token.owner, &executor_token.mint),
-                    ErrorCode::AccountNotAssociatedTokenAccount
-                );
-
-                // Transfer base fee to the executor.
-                token::transfer(
-                    CpiContext::new_with_signer(
-                        token_program.to_account_info(),
-                        token::Transfer {
-                            from: prepared_custody_token.to_account_info(),
-                            to: executor_token.to_account_info(),
-                            authority: prepared_order_response.to_account_info(),
-                        },
-                        &[prepared_order_response_signer_seeds],
-                    ),
-                    base_fee,
-                )?;
-
-                repayment = repayment.saturating_sub(base_fee);
+            // 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) => {
+                    if executor_token.key() == best_offer_token.key() {
+                        (
+                            None, // executor_result
+                            TokenAccountResult {
+                                balance_before: best_offer.amount,
+                                amount: repayment,
+                            }
+                            .into(),
+                        )
+                    } else {
+                        // Because the auction participant was penalized for executing the order
+                        // late, he will be deducted the base fee. This base fee will be sent to the
+                        // executor token account if it is not the same as the best offer token
+                        // account.
+
+                        // We require that the executor token account be an ATA.
+                        require_keys_eq!(
+                            executor_token.key(),
+                            get_associated_token_address(
+                                &executor_token.owner,
+                                &executor_token.mint
+                            ),
+                            ErrorCode::AccountNotAssociatedTokenAccount
+                        );
+
+                        (
+                            TokenAccountResult {
+                                balance_before: executor_token.amount,
+                                amount: base_fee,
+                            }
+                            .into(),
+                            TokenAccountResult {
+                                balance_before: best_offer.amount,
+                                amount: repayment.saturating_sub(base_fee),
+                            }
+                            .into(),
+                        )
+                    }
+                }
+                Err(_) => (
+                    TokenAccountResult {
+                        balance_before: executor_token.amount,
+                        amount: repayment,
+                    }
+                    .into(),
+                    None, // best_offer_result
+                ),
+            }
+        }
+    };
+
+    // Transfer executor his bounty if there are any.
+    let settled_executor_result = match executor_result {
+        Some(TokenAccountResult {
+            balance_before,
+            amount,
+        }) => {
+            token::transfer(
+                CpiContext::new_with_signer(
+                    token_program.to_account_info(),
+                    token::Transfer {
+                        from: prepared_custody_token.to_account_info(),
+                        to: executor_token.to_account_info(),
+                        authority: prepared_order_response.to_account_info(),
+                    },
+                    &[prepared_order_response_signer_seeds],
+                ),
+                amount,
+            )?;
+
+            SettledTokenAccountInfo {
+                key: executor_token.key(),
+                balance_after: balance_before.saturating_add(amount),
             }
+            .into()
         }
+        None => None,
     };
 
-    // Transfer the funds back to the highest bidder.
-    token::transfer(
-        CpiContext::new_with_signer(
-            token_program.to_account_info(),
-            token::Transfer {
-                from: prepared_custody_token.to_account_info(),
-                to: best_offer_token.to_account_info(),
-                authority: prepared_order_response.to_account_info(),
-            },
-            &[prepared_order_response_signer_seeds],
-        ),
-        repayment,
-    )?;
+    // Transfer the funds back to the highest bidder if there are any.
+    let settled_best_offer_result = match best_offer_result {
+        Some(TokenAccountResult {
+            balance_before,
+            amount,
+        }) => {
+            token::transfer(
+                CpiContext::new_with_signer(
+                    token_program.to_account_info(),
+                    token::Transfer {
+                        from: prepared_custody_token.to_account_info(),
+                        to: best_offer_token.to_account_info(),
+                        authority: prepared_order_response.to_account_info(),
+                    },
+                    &[prepared_order_response_signer_seeds],
+                ),
+                amount,
+            )?;
+
+            SettledTokenAccountInfo {
+                key: best_offer_token.key(),
+                balance_after: balance_before.saturating_add(amount),
+            }
+            .into()
+        }
+        None => None,
+    };
 
     emit!(crate::events::AuctionSettled {
         auction: ctx.accounts.auction.key(),
-        best_offer_token: best_offer_token.key().into(),
-        token_balance_after: best_offer_token.amount.saturating_add(repayment),
+        best_offer_token: settled_best_offer_result,
+        executor_token: settled_executor_result,
         with_execute: Default::default(),
     });
 

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

@@ -96,7 +96,11 @@ fn settle_none_and_prepare_fill(
     emit!(crate::events::AuctionSettled {
         auction: auction.key(),
         best_offer_token: Default::default(),
-        token_balance_after: fee_recipient_token.amount.saturating_add(fee),
+        executor_token: crate::events::SettledTokenAccountInfo {
+            key: fee_recipient_token.key(),
+            balance_after: fee_recipient_token.amount.saturating_add(fee)
+        }
+        .into(),
         with_execute: auction.target_protocol.into(),
     });
 

solana/ts/src/idl/json/matching_engine.json

@@ -1860,7 +1860,8 @@
             "Destination token account, which the redeemer may not own. But because the redeemer is a",
             "signer and is the one encoded in the Deposit Fill message, he may have the tokens be sent",
             "to any account he chooses (this one).",
-            ""
+            "",
+            "of the tokens to the executor token account."
           ],
           "writable": true
         },
@@ -3459,19 +3460,30 @@
           {
             "name": "best_offer_token",
             "docs": [
-              "If there was an active auction, this pubkey is the best offer token that was paid back."
+              "If there was an active auction, this field will have the pubkey of the best offer token that",
+              "was paid back and its balance after repayment."
             ],
             "type": {
-              "option": "pubkey"
+              "option": {
+                "defined": {
+                  "name": "SettledTokenAccountInfo"
+                }
+              }
             }
           },
           {
-            "name": "token_balance_after",
+            "name": "executor_token",
             "docs": [
-              "Token account's new balance. If there was no auction, this balance will be of the fee",
-              "recipient token account."
+              "Depending on whether there was an active auction, this field will have the pubkey of the",
+              "executor token (if there was an auction) or fee recipient token (if there was no auction)."
             ],
-            "type": "u64"
+            "type": {
+              "option": {
+                "defined": {
+                  "name": "SettledTokenAccountInfo"
+                }
+              }
+            }
           },
           {
             "name": "with_execute",
@@ -4333,6 +4345,22 @@
           }
         ]
       }
+    },
+    {
+      "name": "SettledTokenAccountInfo",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "key",
+            "type": "pubkey"
+          },
+          {
+            "name": "balance_after",
+            "type": "u64"
+          }
+        ]
+      }
     }
   ]
 }