feat: return a quote when not enough funds

auction-server/Cargo.toml

@@ -57,6 +57,7 @@ strum.workspace = true
 spl-associated-token-account = { workspace = true }
 spl-token = { workspace = true }
 mockall_double = "0.3.1"
+spl-token-2022 = "5.0.0"
 
 [dev-dependencies]
 mockall = "0.13.1"

auction-server/src/auction/service/verification.rs

@@ -70,19 +70,26 @@ use {
             U256,
         },
     },
+    express_relay::error::ErrorCode,
     litesvm::types::FailedTransactionMetadata,
     solana_sdk::{
         address_lookup_table::state::AddressLookupTable,
         clock::Slot,
         commitment_config::CommitmentConfig,
         compute_budget,
-        instruction::CompiledInstruction,
+        instruction::{
+            CompiledInstruction,
+            InstructionError,
+        },
         pubkey::Pubkey,
         signature::Signature,
         signer::Signer as _,
         system_instruction::SystemInstruction,
         system_program,
-        transaction::VersionedTransaction,
+        transaction::{
+            TransactionError,
+            VersionedTransaction,
+        },
     },
     spl_associated_token_account::{
         get_associated_token_address,
@@ -1245,7 +1252,19 @@ impl Service<Svm> {
             .await;
         match simulation {
             Ok(simulation) => {
-                if simulation.value.err.is_some() {
+                if let Some(transaction_error) = simulation.value.err {
+                    if let TransactionError::InstructionError(_, instruction_error) =
+                        transaction_error
+                    {
+                        if instruction_error
+                            == InstructionError::Custom(ErrorCode::InsufficientUserFunds.into())
+                        {
+                            // This path only works as long as none of the other accepted programs use this error number, which is currently true since express relay is the only program in the whitelist that uses anchor error codes
+                            // TODO: Also check the instruction index here so we are sure it's coming from the swap instruction
+                            return Ok(());
+                        }
+                    }
+
                     let msgs = simulation.value.logs.unwrap_or_default();
                     Err(RestError::SimulationError {
                         result: Default::default(),
@@ -1255,6 +1274,7 @@ impl Service<Svm> {
                     Ok(())
                 }
             }
+
             Err(e) => {
                 tracing::error!("Error while simulating swap bid: {:?}", e);
                 Err(RestError::TemporarilyUnavailable)

auction-server/src/opportunity/service/check_user_token_account_balance.rs

@@ -0,0 +1,84 @@
+use {
+    super::{
+        get_token_program::GetTokenProgramInput,
+        ChainTypeSvm,
+        Service,
+    },
+    crate::{
+        api::RestError,
+        kernel::entities::ChainId,
+    },
+    solana_sdk::{
+        commitment_config::CommitmentConfig,
+        pubkey::Pubkey,
+    },
+    spl_associated_token_account::get_associated_token_address_with_program_id,
+    spl_token_2022::{
+        extension::StateWithExtensions as TokenAccountWithExtensions,
+        state::Account as TokenAccount,
+    },
+};
+
+pub struct CheckUserTokenBalanceInput {
+    pub chain_id:    ChainId,
+    pub user:        Pubkey,
+    pub mint_user:   Pubkey,
+    pub amount_user: u64,
+}
+
+impl Service<ChainTypeSvm> {
+    pub async fn check_user_token_balance(
+        &self,
+        input: CheckUserTokenBalanceInput,
+    ) -> Result<bool, RestError> {
+        let config = self.get_config(&input.chain_id)?;
+
+        let native_amount_user = if input.mint_user == spl_token::native_mint::id() {
+            config
+                .rpc_client
+                .get_account_with_commitment(&input.user, CommitmentConfig::processed())
+                .await
+                .map_err(|err| {
+                    tracing::error!(error = ?err, "Failed to get user wallet");
+                    RestError::TemporarilyUnavailable
+                })?
+                .value
+                .map(|account| account.lamports)
+                .unwrap_or_default()
+        } else {
+            0
+        };
+
+        let user_ata_mint_user = get_associated_token_address_with_program_id(
+            &input.user,
+            &input.mint_user,
+            &self
+                .get_token_program(GetTokenProgramInput {
+                    chain_id: input.chain_id.clone(),
+                    mint:     input.mint_user,
+                })
+                .await?,
+        );
+        let amount_user: u64 = config
+            .rpc_client
+            .get_account_with_commitment(&user_ata_mint_user, CommitmentConfig::processed())
+            .await
+            .map_err(|err| {
+                tracing::error!(error = ?err, "Failed to get user token account");
+                RestError::TemporarilyUnavailable
+            })?
+            .value
+            .map(|account| {
+                TokenAccountWithExtensions::<TokenAccount>::unpack(account.data.as_slice())
+                    .map_err(|err| {
+                        tracing::error!(error = ?err, "Failed to deserialize user token account");
+                        RestError::TemporarilyUnavailable
+                    })
+                    .map(|token_account_with_extensions| token_account_with_extensions.base.amount)
+            })
+            .transpose()?
+            .unwrap_or_default();
+
+        Ok(input.amount_user <= amount_user.saturating_add(native_amount_user))
+    }
+}