Add Chainflip tron support

core/crates/gem_tron/src/address/mod.rs

@@ -25,14 +25,17 @@ pub struct TronAddress([u8; PREFIXED_ADDRESS_LEN]);
 impl TronAddress {
     pub fn from_hex(hex_value: &str) -> Option<Self> {
         let bytes = decode_hex(hex_value).ok()?;
-        if bytes.len() != PREFIXED_ADDRESS_LEN || bytes.first() != Some(&ADDRESS_PREFIX) {
-            return None;
+        match bytes.as_slice() {
+            [ADDRESS_PREFIX, payload @ ..] if payload.len() == ADDRESS_LEN => Some(Self(bytes.try_into().ok()?)),
+            payload if payload.len() == ADDRESS_LEN => {
+                let account_id: [u8; ADDRESS_LEN] = payload.try_into().ok()?;
+                Some(Self::from(account_id))
+            }
+            _ => None,
         }
-        Some(Self(bytes.try_into().ok()?))
     }
 
-    #[cfg(feature = "signer")]
-    pub(crate) fn from_hex_or_base58(value: &str) -> Option<Self> {
+    pub fn from_hex_or_base58(value: &str) -> Option<Self> {
         // v3-compatible raw transaction parsing prefers base58 when both formats are technically valid.
         Self::try_parse(value).or_else(|| Self::from_hex(value))
     }
@@ -123,6 +126,10 @@ mod tests {
             TronAddress::from_hex("41357a7401a0f0c2d4a44a1881a0c622f15d986291").unwrap().to_string(),
             "TEqyWRKCzREYC2bK2fc3j7pp8XjAa6tJK1"
         );
+        assert_eq!(
+            TronAddress::from_hex("357a7401a0f0c2d4a44a1881a0c622f15d986291").unwrap().to_string(),
+            "TEqyWRKCzREYC2bK2fc3j7pp8XjAa6tJK1"
+        );
         assert_eq!(TronAddress::from_hex("42357a7401a0f0c2d4a44a1881a0c622f15d986291"), None);
     }
 
@@ -155,13 +162,26 @@ mod tests {
         assert_eq!(TronAddress::try_parse(&unprefixed).unwrap().as_bytes(), expected);
     }
 
-    #[cfg(feature = "signer")]
     #[test]
     fn test_from_hex_or_base58() {
         let expected = hex::decode("41357a7401a0f0c2d4a44a1881a0c622f15d986291").unwrap();
+        let chainflip_expected = hex::decode("412523ae929fecd9d665f472f59b99a8ce6b179510").unwrap();
 
         assert_eq!(TronAddress::from_hex_or_base58("TEqyWRKCzREYC2bK2fc3j7pp8XjAa6tJK1").unwrap().as_bytes(), expected);
         assert_eq!(TronAddress::from_hex_or_base58("41357a7401a0f0c2d4a44a1881a0c622f15d986291").unwrap().as_bytes(), expected);
+        assert_eq!(TronAddress::from_hex_or_base58("357a7401a0f0c2d4a44a1881a0c622f15d986291").unwrap().as_bytes(), expected);
+        assert_eq!(
+            TronAddress::from_hex_or_base58("TDMakP1fbWc7XXoSWZpujpjRAuePPEn4oi").unwrap().as_bytes(),
+            chainflip_expected
+        );
+        assert_eq!(
+            TronAddress::from_hex_or_base58("412523ae929fecd9d665f472f59b99a8ce6b179510").unwrap().as_bytes(),
+            chainflip_expected
+        );
+        assert_eq!(
+            TronAddress::from_hex_or_base58("2523ae929fecd9d665f472f59b99a8ce6b179510").unwrap().as_bytes(),
+            chainflip_expected
+        );
         assert_eq!(TronAddress::from_hex_or_base58("invalid"), None);
     }
 

core/crates/gem_tron/src/models/signing/raw_data.rs

@@ -24,7 +24,7 @@ pub(crate) struct TronRawData {
 }
 
 impl TronRawData {
-    pub(crate) fn from_input(input: &SignerInput, contract: TronContract, fee_limit: u64) -> Result<Self, SignerError> {
+    pub(crate) fn from_input_with_data(input: &SignerInput, contract: TronContract, fee_limit: u64, data: Option<Vec<u8>>) -> Result<Self, SignerError> {
         let TransactionLoadMetadata::Tron {
             block_number,
             block_version,
@@ -62,7 +62,7 @@ impl TronRawData {
             expiration: block_timestamp
                 .checked_add(EXPIRATION_DURATION_MS)
                 .ok_or_else(|| SignerError::invalid_input("Tron expiration overflow"))?,
-            data: input.get_memo().map(|memo| memo.as_bytes().to_vec()),
+            data: data.or_else(|| input.get_memo().map(|memo| memo.as_bytes().to_vec())),
             contract,
             timestamp: *block_timestamp,
             fee_limit,

core/crates/gem_tron/src/provider/preload.rs

@@ -9,7 +9,8 @@ use gem_client::Client;
 use number_formatter::BigNumberFormatter;
 use primitives::{
     AssetSubtype, FeePriority, FeeRate, GasPriceType, TransactionFee, TransactionInputType, TransactionLoadData, TransactionLoadInput, TransactionLoadMetadata,
-    TransactionPreloadInput, TransferDataOutputAction, TronStakeData,
+    TransactionPreloadInput, TransferDataOutputAction, TronStakeData, decode_hex,
+    swap::{SwapQuoteData, SwapQuoteDataType},
 };
 
 use crate::{
@@ -72,20 +73,28 @@ impl<C: Client> ChainTransactionLoad for TronClient<C> {
                 TransferDataOutputAction::Sign => TransactionFee::new_from_fee(calculate_transfer_fee_rate(&chain_parameters, &account_usage, is_new_account, false)?),
             },
             TransactionInputType::Stake(_asset, stake_type) => TransactionFee::new_from_fee(calculate_stake_fee_rate(&chain_parameters, &account_usage, stake_type)?),
-            TransactionInputType::Swap(from_asset, _, swap_data) => match &from_asset.id.token_id {
-                None => TransactionFee::new_from_fee(calculate_transfer_fee_rate(&chain_parameters, &account_usage, is_new_account, has_memo)?),
-                Some(token_id) => {
-                    self.estimate_token_transfer_fee(
-                        input.sender_address.clone(),
-                        swap_data.data.to.clone(),
-                        token_id.clone(),
-                        input.value.clone(),
-                        &chain_parameters,
-                        &account_usage,
-                    )
-                    .await?
+            TransactionInputType::Swap(from_asset, _, swap_data) => {
+                let has_swap_memo = has_swap_quote_memo(has_memo, &swap_data.data);
+                match (&from_asset.id.token_id, &swap_data.data.data_type) {
+                    (_, SwapQuoteDataType::Contract) if !swap_data.data.data.is_empty() => {
+                        self.estimate_swap_contract_fee(&input.sender_address, &swap_data.data, &chain_parameters, &account_usage)
+                            .await?
+                    }
+                    (None, _) => TransactionFee::new_from_fee(calculate_transfer_fee_rate(&chain_parameters, &account_usage, is_new_account, has_swap_memo)?),
+                    (Some(token_id), SwapQuoteDataType::Transfer) => {
+                        self.estimate_token_transfer_fee(
+                            input.sender_address.clone(),
+                            swap_data.data.to.clone(),
+                            token_id.clone(),
+                            input.value.clone(),
+                            &chain_parameters,
+                            &account_usage,
+                        )
+                        .await?
+                    }
+                    (Some(_), SwapQuoteDataType::Contract) => return Err("Tron token contract swap calldata is required".into()),
                 }
-            },
+            }
             _ => TransactionFee::new_from_fee(calculate_transfer_fee_rate(&chain_parameters, &account_usage, is_new_account, has_memo)?),
         };
 
@@ -97,6 +106,10 @@ impl<C: Client> ChainTransactionLoad for TronClient<C> {
     }
 }
 
+fn has_swap_quote_memo(input_has_memo: bool, data: &SwapQuoteData) -> bool {
+    input_has_memo || data.memo.as_deref().is_some_and(|memo| !memo.is_empty())
+}
+
 impl<C: Client> TronClient<C> {
     async fn estimate_token_transfer_fee(
         &self,
@@ -119,6 +132,31 @@ impl<C: Client> TronClient<C> {
         ))
     }
 
+    async fn estimate_swap_contract_fee(
+        &self,
+        sender_address: &str,
+        data: &SwapQuoteData,
+        chain_parameters: &[ChainParameter],
+        account_usage: &TronAccountUsage,
+    ) -> Result<TransactionFee, Box<dyn Error + Send + Sync>> {
+        let contract_data = TriggerSmartContractData {
+            contract_address: data.to.clone(),
+            data: hex::encode(decode_hex(&data.data)?),
+            owner_address: sender_address.to_string(),
+            fee_limit: None,
+            call_value: Some(data.value.parse::<u64>()?).filter(|value| *value > 0),
+        };
+        let estimated_energy = self.estimate_energy_with_data(&contract_data).await?;
+        let token_fee = calculate_transfer_token_fee_rate(chain_parameters, account_usage, estimated_energy)?;
+
+        Ok(TransactionFee::new_gas_price_type(
+            GasPriceType::regular(BigInt::from(token_fee.energy_price)),
+            BigInt::from(token_fee.fee),
+            BigInt::from(token_fee.fee_limit),
+            HashMap::new(),
+        ))
+    }
+
     async fn estimate_fee_with_data(
         &self,
         sender_address: &str,
@@ -167,6 +205,25 @@ impl<C: Client> TronClient<C> {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::has_swap_quote_memo;
+    use primitives::swap::SwapQuoteData;
+
+    #[test]
+    fn test_swap_quote_memo_counts_for_fee_preload() {
+        let mut data = SwapQuoteData::new_contract("TDMakP1fbWc7XXoSWZpujpjRAuePPEn4oi".to_string(), "0".to_string(), String::new(), None, None);
+        assert!(!has_swap_quote_memo(false, &data));
+
+        data.memo = Some(String::new());
+        assert!(!has_swap_quote_memo(false, &data));
+
+        data.memo = Some("0x0100".to_string());
+        assert!(has_swap_quote_memo(false, &data));
+        assert!(has_swap_quote_memo(true, &data));
+    }
+}
+
 #[cfg(all(test, feature = "chain_integration_tests"))]
 mod chain_integration_tests {
     use super::*;