Add Chainflip swap mapping & Solana tx parsing

Add end-to-end support for Chainflip swap result mapping and improve Solana transaction parsing. Key changes:

- Implement Transaction::with_swap_state and use it when publishing swap updates in the daemon.
- Enhance gem_solana models: record meta.err, add Instruction struct and instructions on TransactionMessage, add get_balance_change utility and unit tests, and introduce SYSTEM_PROGRAMS constant and extra program IDs.
- Update transaction_mapper to only accept single-signature transactions, mark failed transactions when meta.err is present, compute transfer values via get_balance_change, and detect smart-contract calls (skipping known system programs). Add test and testdata for a Chainflip vault swap.
- Implement Chainflip mapping in swapper: new SwapTxResponse parsing, map_swap_result to produce SwapResult with TransactionSwapMetadata, add test fixtures for various swap scenarios, and wire map_swap_result into the provider. Also expose vault addresses for deposit lookups.
- Adjust Mayan proxy mapping logic and tests to treat non-InProgress statuses as final and assert expected metadata.

These changes enable accurate extraction of value/contract info from Solana transactions and populate swap metadata from Chainflip responses for downstream processing and tests.

Author: gemcoder21

apps/daemon/src/worker/transactions/in_transit_updater.rs

@@ -119,10 +119,7 @@ impl InTransitUpdater {
         }
         self.database.transactions()?.update_transaction(chain.as_ref(), &row.hash, updates)?;
 
-        let mut transaction = row.as_primitive(row.get_addresses());
-        transaction.state = state.clone().into();
-        transaction.transaction_type = TransactionType::Swap;
-        transaction.metadata = metadata;
+        let transaction = row.as_primitive(row.get_addresses()).with_swap_state(state.clone().into(), metadata.clone());
         self.stream_producer
             .publish_transactions(TransactionsPayload::new(chain, vec![0], vec![transaction]))
             .await?;

crates/gem_solana/src/lib.rs

@@ -37,7 +37,30 @@ pub const SYSTEM_PROGRAM_ID: &str = "11111111111111111111111111111111";
 pub const COMPUTE_BUDGET_PROGRAM_ID: &str = "ComputeBudget111111111111111111111111111111";
 pub const COMPUTE_UNIT_LIMIT_DISCRIMINANT: u8 = 2;
 pub const COMPUTE_UNIT_PRICE_DISCRIMINANT: u8 = 3;
+pub const VOTE_PROGRAM_ID: &str = "Vote111111111111111111111111111111111111111";
+pub const STAKE_PROGRAM_ID: &str = "Stake11111111111111111111111111111111111111";
+pub const SYSVAR_CLOCK_ID: &str = "SysvarC1ock11111111111111111111111111111111";
+pub const SYSVAR_RENT_ID: &str = "SysvarRent111111111111111111111111111111111";
+pub const SYSVAR_INSTRUCTIONS_ID: &str = "Sysvar1nstructions1111111111111111111111111";
+pub const BPF_LOADER_PROGRAM_ID: &str = "BPFLoaderUpgradeab1e11111111111111111111111";
+pub const MEMO_PROGRAM_ID: &str = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+pub const JITO_TIP_PROGRAM_ID: &str = "9H6tua7jkLhdm3w8BvgpTn5LZNU7g4ZynDmCiNN3q6Rp";
 pub const JUPITER_PROGRAM_ID: &str = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
+pub const SYSTEM_PROGRAMS: &[&str] = &[
+    SYSTEM_PROGRAM_ID,
+    COMPUTE_BUDGET_PROGRAM_ID,
+    TOKEN_PROGRAM,
+    TOKEN_PROGRAM_2022,
+    ASSOCIATED_TOKEN_ACCOUNT_PROGRAM,
+    VOTE_PROGRAM_ID,
+    STAKE_PROGRAM_ID,
+    SYSVAR_CLOCK_ID,
+    SYSVAR_RENT_ID,
+    SYSVAR_INSTRUCTIONS_ID,
+    BPF_LOADER_PROGRAM_ID,
+    MEMO_PROGRAM_ID,
+    JITO_TIP_PROGRAM_ID,
+];
 pub const COMMITMENT_CONFIRMED: &str = "confirmed";
 
 use primitives::{AssetId, SolanaTokenProgramId};

crates/gem_solana/src/models/transaction.rs

@@ -23,6 +23,7 @@ pub struct SolanaTransactionError {}
 #[derive(Debug, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct Meta {
+    pub err: Option<serde_json::Value>,
     pub fee: u64,
     pub pre_balances: Vec<u64>,
     pub post_balances: Vec<u64>,
@@ -110,10 +111,18 @@ pub struct Signature {
     pub signature: String,
 }
 
+#[derive(Debug, Deserialize, Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Instruction {
+    pub program_id_index: usize,
+}
+
 #[derive(Debug, Deserialize, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct TransactionMessage {
     pub account_keys: Vec<String>,
+    #[serde(default)]
+    pub instructions: Vec<Instruction>,
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -128,6 +137,18 @@ impl BlockTransaction {
         BigUint::from(self.meta.fee)
     }
 
+    pub fn get_balance_change(&self, address: &str) -> u64 {
+        let index = self.transaction.message.account_keys.iter().position(|k| k == address);
+        match index {
+            Some(i) => {
+                let pre = self.meta.pre_balances.get(i).copied().unwrap_or(0);
+                let post = self.meta.post_balances.get(i).copied().unwrap_or(0);
+                pre.saturating_sub(post).saturating_sub(self.meta.fee)
+            }
+            None => 0,
+        }
+    }
+
     pub fn get_balance_changes_by_owner(&self, owner: &str) -> TokenBalanceChange {
         // Find all account indices that belong to the owner
         let account_indices: Vec<usize> = self
@@ -176,3 +197,52 @@ pub struct SingleTransaction {
     pub meta: Meta,
     pub transaction: Transaction,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn block_transaction(fee: u64, keys: Vec<&str>, pre: Vec<u64>, post: Vec<u64>) -> BlockTransaction {
+        BlockTransaction {
+            meta: Meta {
+                err: None,
+                fee,
+                pre_balances: pre,
+                post_balances: post,
+                pre_token_balances: vec![],
+                post_token_balances: vec![],
+            },
+            transaction: Transaction {
+                message: TransactionMessage {
+                    account_keys: keys.into_iter().map(String::from).collect(),
+                    instructions: vec![],
+                },
+                signatures: vec![],
+            },
+        }
+    }
+
+    #[test]
+    fn test_balance_change() {
+        let tx = block_transaction(5000, vec!["sender", "recipient"], vec![100_000, 0], vec![85_000, 10_000]);
+        assert_eq!(tx.get_balance_change("sender"), 10_000);
+    }
+
+    #[test]
+    fn test_balance_change_no_change() {
+        let tx = block_transaction(5000, vec!["sender"], vec![100_000], vec![95_000]);
+        assert_eq!(tx.get_balance_change("sender"), 0);
+    }
+
+    #[test]
+    fn test_balance_change_received() {
+        let tx = block_transaction(5000, vec!["sender"], vec![100_000], vec![200_000]);
+        assert_eq!(tx.get_balance_change("sender"), 0);
+    }
+
+    #[test]
+    fn test_balance_change_unknown_address() {
+        let tx = block_transaction(5000, vec!["sender"], vec![100_000], vec![85_000]);
+        assert_eq!(tx.get_balance_change("unknown"), 0);
+    }
+}

crates/gem_solana/src/provider/transaction_mapper.rs

@@ -2,7 +2,7 @@ use chrono::DateTime;
 use num_bigint::Sign;
 
 use crate::{
-    COMPUTE_BUDGET_PROGRAM_ID, JUPITER_PROGRAM_ID, SYSTEM_PROGRAM_ID, TOKEN_PROGRAM,
+    COMPUTE_BUDGET_PROGRAM_ID, JUPITER_PROGRAM_ID, SYSTEM_PROGRAMS, SYSTEM_PROGRAM_ID, TOKEN_PROGRAM,
     models::{BlockTransaction, BlockTransactions, Signature},
 };
 use primitives::{AssetId, Chain, SwapProvider, Transaction, TransactionState, TransactionSwapMetadata, TransactionType};
@@ -26,28 +26,27 @@ pub fn map_signatures_transactions(transactions: Vec<BlockTransaction>, signatur
 }
 
 pub fn map_transaction(transaction: &BlockTransaction, block_time: i64) -> Option<primitives::Transaction> {
+    // only accept single signature transactions
+    if transaction.transaction.signatures.len() != 1 {
+        return None;
+    }
+
     let chain = CHAIN;
     let account_keys = transaction.transaction.message.account_keys.clone();
-    let signatures = transaction.transaction.signatures.clone();
     let hash = transaction.transaction.signatures.first()?.to_string();
     let fee = transaction.meta.fee;
-    let state = TransactionState::Confirmed;
+    let state = if transaction.meta.err.is_some() { TransactionState::Failed } else { TransactionState::Confirmed };
     let fee_asset_id = chain.as_asset_id();
     let created_at = DateTime::from_timestamp(block_time, 0)?;
 
-    // only accept single signature transactions
-    if signatures.len() != 1 {
-        return None;
-    }
-
     // system transfer
     if (account_keys.len() == 3) && account_keys.last()? == SYSTEM_PROGRAM_ID
         || (account_keys.len() == 4 && account_keys.last()? == SYSTEM_PROGRAM_ID && account_keys.contains(&COMPUTE_BUDGET_PROGRAM_ID.to_string()))
     {
         let from = account_keys.first()?.clone();
         let to = account_keys[1].clone();
 
-        let value = transaction.meta.pre_balances[0] - transaction.meta.post_balances[0] - fee;
+        let value = transaction.get_balance_change(&from);
 
         let transaction = Transaction::new(
             hash,
@@ -168,7 +167,32 @@ pub fn map_transaction(transaction: &BlockTransaction, block_time: i64) -> Optio
         return Some(transaction);
     }
 
-    None
+    // smart contract call
+    let contract = transaction
+        .transaction
+        .message
+        .instructions
+        .iter()
+        .map(|ix| &account_keys[ix.program_id_index])
+        .find(|key| !SYSTEM_PROGRAMS.contains(&key.as_str()))?;
+    let sender = account_keys.first()?.clone();
+    let value = transaction.get_balance_change(&sender);
+
+    Some(Transaction::new(
+        hash,
+        chain.as_asset_id(),
+        sender.clone(),
+        sender,
+        Some(contract.to_string()),
+        TransactionType::SmartContractCall,
+        state,
+        fee.to_string(),
+        fee_asset_id,
+        value.to_string(),
+        None,
+        None,
+        created_at,
+    ))
 }
 
 #[cfg(test)]
@@ -323,6 +347,17 @@ mod tests {
         assert_eq!(transaction.slot, 361169359);
     }
 
+    #[test]
+    fn test_transaction_chainflip_vault_swap() {
+        let result: JsonRpcResult<BlockTransaction> = serde_json::from_str(include_str!("../../testdata/chainflip_vault_swap.json")).unwrap();
+        let transaction = map_transaction(&result.result, 1772283531).unwrap();
+
+        assert_eq!(transaction.transaction_type, TransactionType::SmartContractCall);
+        assert_eq!(transaction.from, "CabroWmzUzcqqGvprUoC7RnJznuwX6qf5W1tSSaomri7");
+        assert_eq!(transaction.contract, Some("J88B7gmadHzTNGiy54c9Ms8BsEXNdB2fntFyhKpk3qoT".to_string()));
+        assert_eq!(transaction.value, "152686560");
+    }
+
     #[test]
     fn test_transaction_broadcast_error() {
         let error_response: JsonRpcErrorResponse = serde_json::from_str(include_str!("../../testdata/transaction_broadcast_swap_error.json")).unwrap();

crates/gem_solana/src/rpc/client.rs

@@ -1,4 +1,4 @@
-use crate::COMMITMENT_CONFIRMED;
+use crate::{COMMITMENT_CONFIRMED, STAKE_PROGRAM_ID};
 use crate::models::{
     EpochInfo, InflationRate, ResultTokenInfo, Signature, TokenAccountInfo, ValueResult, VoteAccounts,
     balances::SolanaBalance,
@@ -108,9 +108,8 @@ impl<C: Client + Clone> SolanaClient<C> {
     }
 
     pub async fn get_staking_balance(&self, address: &str) -> Result<Vec<TokenAccountInfo>, JsonRpcError> {
-        let stake_program_id = "Stake11111111111111111111111111111111111111";
         let params = serde_json::json!([
-            stake_program_id,
+            STAKE_PROGRAM_ID,
             {
                 "encoding": "jsonParsed",
                 "filters": [