fix: wasm-ton parser gaps and tx id computation

- Parse withdraw amount from SingleNominator and Whales withdrawal
  message bodies, exposed as withdrawAmount on ParsedSendAction
- Fix Transaction.id() to use cell hash instead of SHA-256 of BOC bytes,
  matching TON blockchain convention and TonWeb behavior
- Expose withdrawAmount in JS via try_into_js_value and parser.ts types
- Strengthen transaction tests to assert exact id and withdrawAmount values

BTC-3246

Author: lcovar

packages/wasm-ton/js/parser.ts

@@ -27,6 +27,8 @@ export interface ParsedSendAction {
   bodyOpcode?: number;
   memo?: string;
   jettonTransfer?: JettonTransferFields;
+  /** Withdraw amount from the message body (SingleNominator/Whales withdrawal types). */
+  withdrawAmount?: bigint;
 }
 
 /** A fully parsed TON transaction */

packages/wasm-ton/src/parser.rs

@@ -5,8 +5,13 @@ use ton_contracts::wallet::v4r2::{WalletV4R2Op, WalletV4R2SignBody};
 use crate::error::WasmTonError;
 use crate::transaction::Transaction;
 
-/// Body parse result: (opcode, memo, jetton_transfer)
-type BodyParseResult = (Option<u32>, Option<String>, Option<JettonTransferFields>);
+/// Body parse result: (opcode, memo, jetton_transfer, withdraw_amount)
+type BodyParseResult = (
+    Option<u32>,
+    Option<String>,
+    Option<JettonTransferFields>,
+    Option<u64>,
+);
 
 /// Transaction type enum
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -65,6 +70,8 @@ pub struct ParsedSendAction {
     pub state_init: bool,
     pub memo: Option<String>,
     pub jetton_transfer: Option<JettonTransferFields>,
+    /// Withdraw amount encoded in the message body (SingleNominator/Whales withdrawal types).
+    pub withdraw_amount: Option<u64>,
 }
 
 /// A fully parsed TON transaction
@@ -143,7 +150,8 @@ fn parse_sign_body_actions(
                 let state_init = msg.init.is_some();
 
                 // Parse body
-                let (body_opcode, memo, jetton_transfer) = parse_message_body(&msg.body)?;
+                let (body_opcode, memo, jetton_transfer, withdraw_amount) =
+                    parse_message_body(&msg.body)?;
 
                 parsed.push(ParsedSendAction {
                     mode: action.mode,
@@ -159,6 +167,7 @@ fn parse_sign_body_actions(
                     state_init,
                     memo,
                     jetton_transfer,
+                    withdraw_amount,
                 });
             }
             Ok(parsed)
@@ -173,12 +182,12 @@ fn parse_message_body(body: &Cell) -> Result<BodyParseResult, WasmTonError> {
 
     // Empty body
     if bits_left == 0 {
-        return Ok((None, None, None));
+        return Ok((None, None, None, None));
     }
 
     // Need at least 32 bits for opcode
     if bits_left < 32 {
-        return Ok((None, None, None));
+        return Ok((None, None, None, None));
     }
 
     let opcode: u32 = parser
@@ -196,16 +205,34 @@ fn parse_message_body(body: &Cell) -> Result<BodyParseResult, WasmTonError> {
             };
         }
         let memo = String::from_utf8_lossy(&bytes).to_string();
-        return Ok((Some(0), Some(memo), None));
+        return Ok((Some(0), Some(memo), None, None));
     }
 
     if opcode == JETTON_TRANSFER_OPCODE {
         let jetton = parse_jetton_transfer_body(&mut parser)?;
-        return Ok((Some(opcode), None, Some(jetton)));
+        return Ok((Some(opcode), None, Some(jetton), None));
+    }
+
+    if opcode == WHALES_WITHDRAW_OPCODE || opcode == SINGLE_NOMINATOR_WITHDRAW_OPCODE {
+        let withdraw_amount = parse_withdraw_amount_body(&mut parser)?;
+        return Ok((Some(opcode), None, None, Some(withdraw_amount)));
     }
 
     // Other known opcodes
-    Ok((Some(opcode), None, None))
+    Ok((Some(opcode), None, None, None))
+}
+
+/// Parse query_id + amount from a withdrawal message body (Whales or SingleNominator).
+fn parse_withdraw_amount_body(
+    parser: &mut tlb_ton::de::CellParser<'_>,
+) -> Result<u64, WasmTonError> {
+    let _query_id: u64 = parser
+        .unpack(())
+        .map_err(|e| WasmTonError::new(&format!("withdraw: failed to read query_id: {e}")))?;
+    let amount_big: BigUint = parser
+        .unpack_as::<_, Grams>(())
+        .map_err(|e| WasmTonError::new(&format!("withdraw: failed to read amount: {e}")))?;
+    Ok(biguint_to_u64(&amount_big))
 }
 
 fn parse_jetton_transfer_body(

packages/wasm-ton/src/transaction.rs

@@ -106,10 +106,18 @@ impl Transaction {
         Ok(STANDARD.encode(&self.boc_bytes))
     }
 
-    /// Get the transaction ID (SHA-256 hash of the BOC, base64url encoded).
+    /// Get the transaction ID (cell hash of the root message cell, base64url encoded).
+    ///
+    /// Uses the standard TON cell hash algorithm, matching what TonWeb and TON explorers compute.
     pub fn id(&self) -> String {
-        let hash = Sha256::digest(&self.boc_bytes);
-        base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(hash)
+        self.message
+            .to_cell(())
+            .map(|cell| base64::engine::general_purpose::URL_SAFE.encode(cell.hash()))
+            .unwrap_or_else(|_| {
+                // Should never happen for a valid deserialized transaction
+                let hash = Sha256::digest(&self.boc_bytes);
+                base64::engine::general_purpose::URL_SAFE.encode(hash)
+            })
     }
 
     fn serialize_boc(&self) -> Result<Vec<u8>, WasmTonError> {

packages/wasm-ton/src/wasm/try_into_js_value.rs

@@ -209,6 +209,15 @@ impl TryIntoJsValue for ParsedSendAction {
             .map_err(|_| JsConversionError::new("Failed to set jettonTransfer"))?;
         }
 
+        if let Some(withdraw_amount) = self.withdraw_amount {
+            js_sys::Reflect::set(
+                &obj,
+                &JsValue::from_str("withdrawAmount"),
+                &TryIntoJsValue::try_to_js_value(&withdraw_amount)?,
+            )
+            .map_err(|_| JsConversionError::new("Failed to set withdrawAmount"))?;
+        }
+
         Ok(obj.into())
     }
 }

packages/wasm-ton/test/transaction.ts

@@ -20,10 +20,15 @@ describe("Transaction", () => {
     it("should deserialize a signed send transaction", () => {
       const tx = fromBase64(signedSendTx);
       assert.ok(tx);
-      assert.ok(tx.id);
       assert.ok(tx.destination);
     });
 
+    it("should compute cell hash as transaction id", () => {
+      const tx = fromBase64(signedSendTx);
+      // Cell hash of the root external message cell, base64url with padding
+      assert.equal(tx.id, "tuyOkyFUMv_neV_FeNBH24Nd4cML2jUgDP4zjGkuOFI=");
+    });
+
     it("should get signable payload", () => {
       const tx = fromBase64(signedSendTx);
       const payload = tx.signablePayload();
@@ -45,20 +50,24 @@ describe("Transaction", () => {
       assert.ok(parsed.sendActions.length > 0);
       assert.ok(parsed.sender);
       assert.ok(parsed.signature);
+      assert.equal(parsed.sendActions[0].withdrawAmount, undefined);
     });
 
     it("should parse a whales deposit transaction", () => {
       const tx = fromBase64(whalesDepositTx);
       const parsed = parseTransaction(tx);
       assert.equal(parsed.transactionType, "WhalesDeposit");
       assert.ok(parsed.sendActions.length > 0);
+      assert.equal(parsed.sendActions[0].withdrawAmount, undefined);
     });
 
-    it("should parse a single nominator withdraw transaction", () => {
+    it("should parse a single nominator withdraw transaction with withdrawAmount", () => {
       const tx = fromBase64(singleNominatorWithdrawTx);
       const parsed = parseTransaction(tx);
       assert.equal(parsed.transactionType, "SingleNominatorWithdraw");
       assert.ok(parsed.sendActions.length > 0);
+      assert.equal(typeof parsed.sendActions[0].withdrawAmount, "bigint");
+      assert.equal(parsed.sendActions[0].withdrawAmount, 932178112330000n);
     });
   });
 });