fix(tron): address PR #2714 review comments (batch 2)

- Stricter error assertions in blockID deserialization tests: use
  unwrap_err() + is_data() + contains() instead of plain is_err()
- Add expiration_seconds to WithdrawRequest for customizable tx expiry

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: shamardy

mm2src/coins/eth/eth_withdraw.rs

@@ -364,6 +364,7 @@ where
             resources,
             prices,
             fee_coin: ticker,
+            expiration_seconds: req.expiration_seconds,
         };
         let (raw, tron_fee_details, final_amount) = match &coin.coin_type {
             EthCoinType::Eth => {

mm2src/coins/eth/tron/api.rs

@@ -1193,16 +1193,28 @@ mod tests {
     /// Non-hex `blockID` must fail deserialization (triggers `BadResponse` → node rotation).
     #[test]
     fn parse_getnowblock_rejects_invalid_block_id_hex() {
-        let json = r#"{ "blockID": "not_valid_hex!!", "block_header": { "raw_data": { "number": 1 } } }"#;
-        assert!(serde_json::from_str::<GetNowBlockResponse>(json).is_err());
+        let json = r#"{ "blockID": "zz00000000000000000000000000000000000000000000000000000000000000", "block_header": { "raw_data": { "number": 1 } } }"#;
+        let err = serde_json::from_str::<GetNowBlockResponse>(json).unwrap_err();
+        assert!(err.is_data(), "Expected data error for invalid hex, got: {}", err);
+        assert!(
+            err.to_string().contains("Invalid character"),
+            "Expected hex parse error, got: {}",
+            err
+        );
     }
 
     /// `blockID` that isn't exactly 32 bytes must fail deserialization.
     #[test]
     fn parse_getnowblock_rejects_wrong_length_block_id() {
         // 31 bytes (62 hex chars) — too short
         let json = r#"{ "blockID": "00000000033bab42e37d025dc14e9ebc26e8f6cb6b6e26e08d2bf2db29c3b4", "block_header": { "raw_data": { "number": 1 } } }"#;
-        assert!(serde_json::from_str::<GetNowBlockResponse>(json).is_err());
+        let err = serde_json::from_str::<GetNowBlockResponse>(json).unwrap_err();
+        assert!(err.is_data(), "Expected data error for wrong length, got: {}", err);
+        assert!(
+            err.to_string().contains("blockID must be 32 bytes"),
+            "Expected length error, got: {}",
+            err
+        );
     }
 
     #[test]

mm2src/coins/eth/tron/tx_builder.rs

@@ -13,7 +13,7 @@ use ethereum_types::U256;
 use prost::Message;
 
 /// Default transaction expiration window (60 seconds from block timestamp).
-const TX_EXPIRATION_MS: i64 = 60_000;
+const DEFAULT_TX_EXPIRATION_MS: i64 = 60_000;
 
 /// Extract TAPOS reference fields from a recent block.
 ///
@@ -48,14 +48,18 @@ pub(super) fn wrap_contract(contract_type: ContractType, type_url: &str, value:
 ///
 /// Timestamp and expiration are derived from `block_data`:
 /// - `timestamp` = block timestamp (not validated by java-tron; matches TronWeb)
-/// - `expiration` = block timestamp + 60s
+/// - `expiration` = block timestamp + `expiration_sec` (converted to ms)
 pub fn build_trx_transfer(
     from: &TronAddress,
     to: &TronAddress,
     amount_sun: i64,
     block_data: &TaposBlockData,
+    expiration_seconds: Option<u64>,
 ) -> TransactionRaw {
     let (ref_block_bytes, ref_block_hash) = tapos_from_block(block_data.number, &block_data.block_id);
+    let expiration_ms = expiration_seconds
+        .map(|s| (s as i64).saturating_mul(1000))
+        .unwrap_or(DEFAULT_TX_EXPIRATION_MS);
 
     let transfer = TransferContract {
         owner_address: tron_addr_bytes(from),
@@ -71,7 +75,7 @@ pub fn build_trx_transfer(
     TransactionRaw {
         ref_block_bytes,
         ref_block_hash,
-        expiration: block_data.timestamp.saturating_add(TX_EXPIRATION_MS),
+        expiration: block_data.timestamp.saturating_add(expiration_ms),
         data: Vec::new(),
         contract: vec![contract],
         timestamp: block_data.timestamp,
@@ -89,8 +93,12 @@ pub fn build_trc20_transfer(
     amount: U256,
     fee_limit: i64,
     block_data: &TaposBlockData,
+    expiration_seconds: Option<u64>,
 ) -> Result<TransactionRaw, ethabi::Error> {
     let (ref_block_bytes, ref_block_hash) = tapos_from_block(block_data.number, &block_data.block_id);
+    let expiration_ms = expiration_seconds
+        .map(|s| (s as i64).saturating_mul(1000))
+        .unwrap_or(DEFAULT_TX_EXPIRATION_MS);
 
     let trigger = TriggerSmartContract {
         owner_address: tron_addr_bytes(from),
@@ -109,7 +117,7 @@ pub fn build_trc20_transfer(
     Ok(TransactionRaw {
         ref_block_bytes,
         ref_block_hash,
-        expiration: block_data.timestamp.saturating_add(TX_EXPIRATION_MS),
+        expiration: block_data.timestamp.saturating_add(expiration_ms),
         data: Vec::new(),
         contract: vec![contract],
         timestamp: block_data.timestamp,
@@ -146,10 +154,10 @@ mod tests {
         let from = TronAddress::from_hex(TEST_FROM_HEX).unwrap();
         let to = TronAddress::from_hex(TEST_TO_HEX).unwrap();
 
-        let mut raw = build_trx_transfer(&from, &to, 1000, &block_data);
+        let mut raw = build_trx_transfer(&from, &to, 1000, &block_data, None);
         // Verify timestamp/expiration derived from block_data
         assert_eq!(raw.timestamp, block_data.timestamp);
-        assert_eq!(raw.expiration, block_data.timestamp + TX_EXPIRATION_MS);
+        assert_eq!(raw.expiration, block_data.timestamp + DEFAULT_TX_EXPIRATION_MS);
         // Override to match the real broadcast tx values for golden vector comparison.
         raw.timestamp = 1_770_522_424_709;
         raw.expiration = 1_770_522_483_000;
@@ -179,10 +187,11 @@ mod tests {
         let amount = U256::from(2_380_000u64);
         let fee_limit = 2_172_000i64;
 
-        let mut raw = build_trc20_transfer(&from, &contract_addr, &recipient, amount, fee_limit, &block_data).unwrap();
+        let mut raw =
+            build_trc20_transfer(&from, &contract_addr, &recipient, amount, fee_limit, &block_data, None).unwrap();
         // Verify timestamp/expiration derived from block_data
         assert_eq!(raw.timestamp, block_data.timestamp);
-        assert_eq!(raw.expiration, block_data.timestamp + TX_EXPIRATION_MS);
+        assert_eq!(raw.expiration, block_data.timestamp + DEFAULT_TX_EXPIRATION_MS);
         // Override to match the real broadcast tx values for golden vector comparison.
         raw.timestamp = 1_770_972_831_784;
         raw.expiration = 1_770_972_891_000;

mm2src/coins/eth/tron/withdraw.rs

@@ -31,6 +31,8 @@ pub struct TronWithdrawContext<'a> {
     pub resources: TronAccountResources,
     pub prices: TronChainPrices,
     pub fee_coin: &'a str,
+    /// Transaction expiration window in seconds. `None` uses the protocol default (60s).
+    pub expiration_seconds: Option<u64>,
 }
 
 /// Reject EVM gas fee policies for TRON. TRON always auto-estimates fees.
@@ -73,7 +75,7 @@ pub fn build_tron_trx_withdraw(
     let mut amount_sun_i64: i64 = amount_sun
         .try_into()
         .map_to_mm(|_| WithdrawError::InternalError(format!("amount {amount_sun} exceeds i64::MAX")))?;
-    let mut raw = build_trx_transfer(ctx.from, ctx.to, amount_sun_i64, ctx.block_data);
+    let mut raw = build_trx_transfer(ctx.from, ctx.to, amount_sun_i64, ctx.block_data, ctx.expiration_seconds);
 
     // Iteratively estimate fee and adjust amount until stable.
     // Non-max: runs once — amount is fixed, just checks balance sufficiency.
@@ -120,7 +122,7 @@ pub fn build_tron_trx_withdraw(
         amount_sun_i64 = amount_sun
             .try_into()
             .map_to_mm(|_| WithdrawError::InternalError(format!("amount {amount_sun} exceeds i64::MAX")))?;
-        raw = build_trx_transfer(ctx.from, ctx.to, amount_sun_i64, ctx.block_data);
+        raw = build_trx_transfer(ctx.from, ctx.to, amount_sun_i64, ctx.block_data, ctx.expiration_seconds);
     }
 }
 
@@ -152,6 +154,7 @@ pub async fn build_tron_trc20_withdraw(
         amount_base_units,
         fee_limit_i64,
         ctx.block_data,
+        ctx.expiration_seconds,
     )
     .map_to_mm(|e| WithdrawError::InternalError(format!("TRC20 ABI encoding failed: {e}")))?;
 
@@ -238,7 +241,7 @@ mod tests {
         };
         let from = TronAddress::from_hex(TEST_FROM_HEX).unwrap();
         let to = TronAddress::from_hex(TEST_TO_HEX).unwrap();
-        let raw = build_trx_transfer(&from, &to, 1_000_000, &block_data);
+        let raw = build_trx_transfer(&from, &to, 1_000_000, &block_data, None);
 
         // Sign with a deterministic test key
         let secret = ethkey::Secret::from_slice(&[1u8; 32]).expect("valid test secret");
@@ -272,6 +275,7 @@ mod tests {
             resources,
             prices,
             fee_coin: "TRX",
+            expiration_seconds: None,
         };
         let (raw, fee_details, final_amount) =
             build_tron_trx_withdraw(&ctx, balance, balance, &balance_dec, true).unwrap();
@@ -309,6 +313,7 @@ mod tests {
             resources,
             prices,
             fee_coin: "TRX",
+            expiration_seconds: None,
         };
         let result = build_tron_trx_withdraw(&ctx, amount, balance, &balance_dec, false);
 

mm2src/coins/lp_coins.rs

@@ -2342,6 +2342,9 @@ pub struct WithdrawRequest {
     /// Currently, this flag is used by ETH/ERC20 coins activated with MetaMask/WalletConnect(Some wallets e.g Metamask) **only**.
     #[serde(default)]
     broadcast: bool,
+    /// Transaction expiration window in seconds. Currently only used by TRON (default 60s),
+    /// but can be expanded to any protocol that supports transaction expiry.
+    pub expiration_seconds: Option<u64>,
 }
 
 #[derive(Debug, Deserialize)]