Detect cross-chain swaps using Transaction + tx data

Refactor cross-chain swap detection to accept a primitives::Transaction instead of separate chain/to/memo parameters, and propagate transaction data throughout the stack. Key changes:

- Change CrossChainProvider::is_swap to take &Transaction and update swap_provider/is_cross_chain_swap accordingly.
- Update Across and Thorchain providers to detect swaps from the full Transaction (Across checks transaction.to, Thorchain checks memo or hex-decoded tx.data and router addresses).
- Add Transaction.data field + with_data builder in primitives::Transaction and wire EVM mapper to store input data for native transfers.
- Add primitives::hex::decode_hex_utf8 helper and use it for XRP memo decoding and Thorchain provider data decoding.
- Move/add THORChain value conversion helpers (value_from/value_to) into thorchain asset code and update Thorchain provider to use them with proper error handling.
- Add native_value/decimals handling to Thorchain TransactionCoin and use it when mapping swap results.
- Update consumers/workers/storage to pass primitives::Transaction into cross-chain checks and ensure data is preserved where applicable.
- Update/adapt unit tests for the new transaction-based detection and added data-based Thorchain detection.

These changes unify swap detection on a single Transaction model, enable detection from EVM input data, and centralize THORChain asset value conversions.

Author: gemcoder21

apps/daemon/src/consumers/store/store_transactions_consumer.rs

@@ -15,12 +15,14 @@ const TRANSACTION_BATCH_SIZE: usize = 100;
 fn set_cross_chain_in_transit(transactions: Vec<Transaction>) -> Vec<Transaction> {
     transactions
         .into_iter()
-        .map(|mut tx| {
-            if tx.state == TransactionState::Confirmed && tx.transaction_type != TransactionType::Swap && cross_chain::is_cross_chain_swap(&tx.id.chain, &tx.to, tx.memo.as_deref())
+        .map(|mut transaction| {
+            if transaction.state == TransactionState::Confirmed
+                && transaction.transaction_type != TransactionType::Swap
+                && cross_chain::is_cross_chain_swap(&transaction)
             {
-                tx.state = TransactionState::InTransit;
+                transaction.state = TransactionState::InTransit;
             }
-            tx
+            transaction
         })
         .collect()
 }
@@ -113,7 +115,9 @@ impl MessageConsumer<TransactionsPayload, usize> for StoreTransactionsConsumer {
                 txn_ids.insert(transaction.id.clone());
                 asset_ids.extend(transaction_asset_ids.iter().cloned());
 
-                let is_outdated = self.config.is_transaction_outdated(transaction.created_at.naive_utc(), chain, transaction.transaction_type.clone());
+                let is_outdated = self
+                    .config
+                    .is_transaction_outdated(transaction.created_at.naive_utc(), chain, transaction.transaction_type.clone());
                 let should_notify = !is_outdated && is_notify_devices;
 
                 if should_notify {

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

@@ -59,8 +59,9 @@ impl InTransitUpdater {
 
     async fn process_transaction(&self, row: &TransactionRow, cutoff: NaiveDateTime) -> Result<bool, Box<dyn Error + Send + Sync>> {
         let chain = row.chain();
+        let transaction = row.as_primitive(row.get_addresses());
 
-        let Some(provider) = cross_chain::swap_provider(&chain, row.to_address.as_deref(), row.memo.as_deref()) else {
+        let Some(provider) = cross_chain::swap_provider(&transaction) else {
             info_with_fields!("in_transit unknown provider", chain = chain.as_ref(), hash = row.hash);
             return Ok(false);
         };

crates/gem_evm/src/rpc/mapper.rs

@@ -74,6 +74,7 @@ impl EthereumMapper {
             && Self::get_data_cost(&transaction.input).is_some_and(|data_cost| transaction_reciept.gas_used <= BigUint::from(TRANSFER_GAS_LIMIT + data_cost));
 
         if is_native_transfer || is_native_transfer_with_data {
+            let data = if is_native_transfer_with_data { Some(transaction.input.clone()) } else { None };
             let transaction = primitives::Transaction::new(
                 hash,
                 chain.as_asset_id(),
@@ -88,7 +89,8 @@ impl EthereumMapper {
                 None,
                 None,
                 created_at,
-            );
+            )
+            .with_data(data);
             return Some(transaction);
         }
 

crates/gem_xrp/src/models/rpc.rs

@@ -163,9 +163,7 @@ pub struct TransactionMemoData {
 
 impl TransactionMemo {
     pub fn decoded_data(&self) -> Option<String> {
-        let data = self.memo.data.as_ref()?;
-        let bytes = hex::decode(data).ok()?;
-        String::from_utf8(bytes).ok()
+        primitives::hex::decode_hex_utf8(self.memo.data.as_ref()?)
     }
 }
 

crates/primitives/src/hex.rs

@@ -22,6 +22,11 @@ pub fn encode_with_0x(data: &[u8]) -> String {
     format!("0x{}", hex::encode(data))
 }
 
+pub fn decode_hex_utf8(value: &str) -> Option<String> {
+    let bytes = decode_hex(value).ok()?;
+    String::from_utf8(bytes).ok()
+}
+
 pub fn decode_hex(value: &str) -> Result<Vec<u8>, HexError> {
     let stripped = value.trim().strip_prefix("0x").unwrap_or(value.trim());
     if stripped.is_empty() {

crates/primitives/src/transaction.rs

@@ -56,6 +56,9 @@ pub struct Transaction {
     pub utxo_outputs: Option<Vec<TransactionUtxoInput>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub metadata: Option<serde_json::Value>,
+    #[typeshare(skip)]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
     #[serde(rename = "createdAt")]
     pub created_at: DateTime<Utc>,
 }
@@ -95,6 +98,7 @@ impl Transaction {
             utxo_inputs: vec![].into(),
             utxo_outputs: vec![].into(),
             metadata,
+            data: None,
             created_at,
         }
     }
@@ -132,6 +136,7 @@ impl Transaction {
             utxo_inputs: utxo_inputs.unwrap_or_default().into(),
             utxo_outputs: utxo_outputs.unwrap_or_default().into(),
             metadata,
+            data: None,
             created_at,
         }
     }
@@ -236,6 +241,7 @@ impl Transaction {
             utxo_inputs: self.utxo_inputs.clone(),
             utxo_outputs: self.utxo_outputs.clone(),
             metadata: self.metadata.clone(),
+            data: self.data.clone(),
             created_at: self.created_at,
         }
     }
@@ -326,6 +332,11 @@ impl Transaction {
             ..self
         }
     }
+
+    pub fn with_data(mut self, data: Option<String>) -> Self {
+        self.data = data;
+        self
+    }
 }
 
 #[cfg(test)]

crates/storage/src/models/transaction.rs

@@ -94,6 +94,7 @@ impl TransactionRow {
             utxo_inputs: inputs.unwrap_or_default().into(),
             utxo_outputs: outputs.unwrap_or_default().into(),
             metadata: self.metadata.clone(),
+            data: None,
             created_at: self.created_at.and_utc(),
         }
     }

crates/swapper/src/across/provider.rs

@@ -48,9 +48,11 @@ impl crate::cross_chain::CrossChainProvider for AcrossCrossChain {
         SwapperProvider::Across
     }
 
-    fn is_swap(&self, chain: &Chain, to_address: Option<&str>, _memo: Option<&str>) -> bool {
-        let Some(to_address) = to_address else { return false };
-        AcrossDeployment::deployment_by_chain(chain).is_some_and(|d| d.spoke_pool.eq_ignore_ascii_case(to_address))
+    fn is_swap(&self, transaction: &primitives::Transaction) -> bool {
+        if transaction.to.is_empty() {
+            return false;
+        }
+        AcrossDeployment::deployment_by_chain(&transaction.asset_id.chain).is_some_and(|d| d.spoke_pool.eq_ignore_ascii_case(&transaction.to))
     }
 }
 

crates/swapper/src/cross_chain.rs

@@ -1,105 +1,143 @@
+use primitives::Transaction;
+
 use crate::SwapperProvider;
 use crate::across::AcrossCrossChain;
 use crate::thorchain::ThorchainCrossChain;
-use primitives::Chain;
 
 pub trait CrossChainProvider: Send + Sync {
     fn provider(&self) -> SwapperProvider;
-    fn is_swap(&self, chain: &Chain, to_address: Option<&str>, memo: Option<&str>) -> bool;
+    fn is_swap(&self, transaction: &Transaction) -> bool;
 }
 
 const PROVIDERS: [&dyn CrossChainProvider; 2] = [&ThorchainCrossChain, &AcrossCrossChain];
 
-pub fn swap_provider(chain: &Chain, to_address: Option<&str>, memo: Option<&str>) -> Option<SwapperProvider> {
-    PROVIDERS.iter().find(|p| p.is_swap(chain, to_address, memo)).map(|p| p.provider())
+pub fn swap_provider(transaction: &Transaction) -> Option<SwapperProvider> {
+    PROVIDERS.iter().find(|p| p.is_swap(transaction)).map(|p| p.provider())
 }
 
-pub fn is_cross_chain_swap(chain: &Chain, to_address: &str, memo: Option<&str>) -> bool {
-    swap_provider(chain, Some(to_address), memo).is_some()
+pub fn is_cross_chain_swap(transaction: &Transaction) -> bool {
+    swap_provider(transaction).is_some()
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use primitives::Chain;
 
     #[test]
     fn test_thorchain_swap_detected() {
-        let memo = "=:ETH.USDT:0x858734a6353C9921a78fB3c937c8E20Ba6f36902:1635978e6/1/0";
-        assert_eq!(
-            swap_provider(&Chain::Ethereum, Some("0x0000000000000000000000000000000000000000"), Some(memo)),
-            Some(SwapperProvider::Thorchain),
-        );
+        let transaction = Transaction {
+            memo: Some("=:ETH.USDT:0x858734a6353C9921a78fB3c937c8E20Ba6f36902:1635978e6/1/0".to_string()),
+            ..Transaction::mock()
+        };
+        assert_eq!(swap_provider(&transaction), Some(SwapperProvider::Thorchain));
     }
 
     #[test]
     fn test_thorchain_non_swap_memo() {
-        assert!(!is_cross_chain_swap(
-            &Chain::Ethereum,
-            "0x0000000000000000000000000000000000000000",
-            Some("ADD:ETH.ETH:0x123"),
-        ));
+        assert!(!is_cross_chain_swap(&Transaction {
+            memo: Some("ADD:ETH.ETH:0x123".to_string()),
+            ..Transaction::mock()
+        }));
     }
 
     #[test]
     fn test_no_memo() {
-        assert!(swap_provider(&Chain::Ethereum, Some("0x0000000000000000000000000000000000000000"), None).is_none());
+        assert!(swap_provider(&Transaction::mock()).is_none());
     }
 
     #[test]
     fn test_across_swap_detected() {
-        assert_eq!(
-            swap_provider(&Chain::Ethereum, Some("0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5"), None),
-            Some(SwapperProvider::Across),
-        );
+        let transaction = Transaction {
+            to: "0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5".to_string(),
+            ..Transaction::mock()
+        };
+        assert_eq!(swap_provider(&transaction), Some(SwapperProvider::Across));
     }
 
     #[test]
     fn test_across_swap_case_insensitive() {
-        assert!(is_cross_chain_swap(&Chain::Ethereum, "0x5c7bcd6e7de5423a257d81b442095a1a6ced35c5", None));
+        let transaction = Transaction {
+            to: "0x5c7bcd6e7de5423a257d81b442095a1a6ced35c5".to_string(),
+            ..Transaction::mock()
+        };
+        assert_eq!(swap_provider(&transaction), Some(SwapperProvider::Across));
     }
 
     #[test]
     fn test_across_unsupported_chain() {
-        assert!(!is_cross_chain_swap(&Chain::Fantom, "0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5", None));
+        let transaction = Transaction {
+            asset_id: Chain::Fantom.as_asset_id(),
+            to: "0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5".to_string(),
+            ..Transaction::mock()
+        };
+        assert!(swap_provider(&transaction).is_none());
     }
 
     #[test]
     fn test_across_arbitrum() {
-        assert_eq!(
-            swap_provider(&Chain::Arbitrum, Some("0xe35e9842fceaca96570b734083f4a58e8f7c5f2a"), None),
-            Some(SwapperProvider::Across),
-        );
+        let transaction = Transaction {
+            asset_id: Chain::Arbitrum.as_asset_id(),
+            to: "0xe35e9842fceaca96570b734083f4a58e8f7c5f2a".to_string(),
+            ..Transaction::mock()
+        };
+        assert_eq!(swap_provider(&transaction), Some(SwapperProvider::Across));
     }
 
     #[test]
     fn test_thorchain_takes_priority_over_across() {
-        let memo = "=:ETH.USDT:0x858734a6353C9921a78fB3c937c8E20Ba6f36902:1635978e6/1/0";
-        assert_eq!(
-            swap_provider(&Chain::Ethereum, Some("0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5"), Some(memo)),
-            Some(SwapperProvider::Thorchain),
-        );
+        let transaction = Transaction {
+            to: "0x5c7BCd6E7De5423a257D81B442095A1a6ced35C5".to_string(),
+            memo: Some("=:ETH.USDT:0x858734a6353C9921a78fB3c937c8E20Ba6f36902:1635978e6/1/0".to_string()),
+            ..Transaction::mock()
+        };
+        assert_eq!(swap_provider(&transaction), Some(SwapperProvider::Thorchain));
     }
 
     #[test]
     fn test_non_evm_chains_no_panic() {
-        assert!(!is_cross_chain_swap(&Chain::Bitcoin, "bc1qaddress", None));
-        assert!(!is_cross_chain_swap(&Chain::Solana, "So1111111111111111111111111111111111111111", None));
-        assert!(!is_cross_chain_swap(&Chain::Ton, "EQAddress", None));
-        assert!(!is_cross_chain_swap(&Chain::Cosmos, "cosmos1address", None));
-        assert!(!is_cross_chain_swap(&Chain::Sui, "0xaddress", None));
+        let btc = Transaction {
+            asset_id: Chain::Bitcoin.as_asset_id(),
+            to: "bc1qaddress".to_string(),
+            ..Transaction::mock()
+        };
+        let sol = Transaction {
+            asset_id: Chain::Solana.as_asset_id(),
+            to: "So1111111111111111111111111111111111111111".to_string(),
+            ..Transaction::mock()
+        };
+        assert!(swap_provider(&btc).is_none());
+        assert!(swap_provider(&sol).is_none());
     }
 
     #[test]
     fn test_thorchain_swap_no_to_address() {
-        let memo = "=:s:0xBA4D1d35bCe0e8F28E5a3403e7a0b996c5d50AC4:0/1/0:g1:50";
-        assert_eq!(swap_provider(&Chain::Litecoin, None, Some(memo)), Some(SwapperProvider::Thorchain));
+        let transaction = Transaction {
+            asset_id: Chain::Litecoin.as_asset_id(),
+            to: String::new(),
+            memo: Some("=:s:0xBA4D1d35bCe0e8F28E5a3403e7a0b996c5d50AC4:0/1/0:g1:50".to_string()),
+            ..Transaction::mock()
+        };
+        assert_eq!(swap_provider(&transaction), Some(SwapperProvider::Thorchain));
     }
 
     #[test]
     fn test_thorchain_evm_router_detected() {
-        assert_eq!(
-            swap_provider(&Chain::Ethereum, Some("0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146"), None),
-            Some(SwapperProvider::Thorchain),
-        );
+        let transaction = Transaction {
+            to: "0xD37BbE5744D730a1d98d8DC97c42F0Ca46aD7146".to_string(),
+            ..Transaction::mock()
+        };
+        assert_eq!(swap_provider(&transaction), Some(SwapperProvider::Thorchain));
+    }
+
+    #[test]
+    fn test_thorchain_evm_data_detected() {
+        let data = "0x3d3a623a626331713965797870616730777875386a74756b7a747a6b636876637a65793039616134397632326c353a302f312f303a67313a3530";
+        let transaction = Transaction {
+            to: "0xdfb89f7b854b79fdac99ddeb55921349ca649def".to_string(),
+            data: Some(data.to_string()),
+            ..Transaction::mock()
+        };
+        assert_eq!(swap_provider(&transaction), Some(SwapperProvider::Thorchain));
     }
 }

crates/swapper/src/thorchain/asset.rs

@@ -1,9 +1,27 @@
+use num_bigint::BigInt;
 use primitives::{Asset, AssetId};
+use std::str::FromStr;
 
 use crate::asset::*;
 
 use super::chain::THORChainName;
 
+const THORCHAIN_DECIMALS: i32 = 8;
+
+pub fn value_from(value: &str, decimals: i32) -> BigInt {
+    let value = BigInt::from_str(value).unwrap_or_default();
+    let diff = decimals - THORCHAIN_DECIMALS;
+    let factor = BigInt::from(10).pow(diff.unsigned_abs());
+    if diff > 0 { value / factor } else { value * factor }
+}
+
+pub fn value_to(value: &str, decimals: i32) -> BigInt {
+    let value = BigInt::from_str(value).unwrap_or_default();
+    let diff = decimals - THORCHAIN_DECIMALS;
+    let factor = BigInt::from(10).pow(diff.unsigned_abs());
+    if diff > 0 { value * factor } else { value / factor }
+}
+
 #[derive(Clone, Debug)]
 pub struct THORChainAsset {
     pub symbol: String,
@@ -206,6 +224,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_value_from() {
+        assert_eq!(value_from("1000000000000000000", 18), BigInt::from(100000000));
+        assert_eq!(value_from("1000000000", 10), BigInt::from(10000000));
+        assert_eq!(value_from("1000000000", 6), BigInt::from_str("100000000000").unwrap());
+        assert_eq!(value_from("1000000000", 8), BigInt::from(1000000000));
+    }
+
+    #[test]
+    fn test_value_to() {
+        assert_eq!(value_to("2509674", 18), BigInt::from_str("25096740000000000").unwrap());
+        assert_eq!(value_to("10000000", 10), BigInt::from(1000000000));
+        assert_eq!(value_to("79158429", 6), BigInt::from(791584));
+        assert_eq!(value_to("160661010", 8), BigInt::from(160661010));
+    }
+
     #[test]
     fn test_tron_usdt_memo() {
         let tron_destination = "TEB39Rt69QkgD1BKhqaRNqGxfQzCarkRCb".to_string();