feat: add WASM-based DOT transaction parsing and explanation

Add @bitgo/wasm-dot integration for parsing, explaining, and building
DOT transactions using Rust/WASM instead of @polkadot/api.

- wasmParser.ts: adapter that maps wasm-dot's explainTransaction()
  output to BitGoJS TransactionExplanation format (type mapping,
  output/input extraction, fee handling)
- wasmBuilderByteComparison.ts: tests verifying WASM-built transactions
  produce byte-identical signing payloads to legacy txwrapper-polkadot
- Covers: transfers, staking (bond/unbond/withdraw/chill), proxy
  (add/remove), and batch transactions

BTC-0

TICKET: BTC-0

Author: lcovar

modules/sdk-coin-dot/bitgo-wasm-dot-0.0.1.tgz

@@ -43,6 +43,7 @@
     "@bitgo/sdk-core": "^36.30.0",
     "@bitgo/sdk-lib-mpc": "^10.9.0",
     "@bitgo/statics": "^58.24.0",
+    "@bitgo/wasm-dot": "file:bitgo-wasm-dot-0.0.1.tgz",
     "@polkadot/api": "14.1.1",
     "@polkadot/api-augment": "14.1.1",
     "@polkadot/keyring": "13.3.1",

modules/sdk-coin-dot/package.json

@@ -16,4 +16,6 @@ export { TransactionBuilderFactory } from './transactionBuilderFactory';
 export { SingletonRegistry } from './singletonRegistry';
 export { NativeTransferBuilder } from './nativeTransferBuilder';
 export { RemoveProxyBuilder } from './proxyBuilder';
+export { explainTransactionFromHex } from './wasmParser';
+export type { DotWasmExplanation, DotInput } from './wasmParser';
 export { Interface, Utils };

modules/sdk-coin-dot/src/lib/index.ts

@@ -0,0 +1,107 @@
+import { TransactionType } from '@bitgo/sdk-core';
+import {
+  explainTransaction,
+  TransactionType as WasmTransactionType,
+  type ExplainedTransaction as WasmExplainedTransaction,
+} from '@bitgo/wasm-dot';
+import type { TransactionExplanation, Material } from './iface';
+
+/**
+ * Input entry for a DOT transaction.
+ * For account-model chains, there's typically one input (the sender).
+ */
+export interface DotInput {
+  address: string;
+  value: number;
+  valueString: string;
+}
+
+/**
+ * Extended explanation returned by WASM-based parsing.
+ * Includes fields needed by wallet-platform that aren't in the base TransactionExplanation.
+ */
+export interface DotWasmExplanation extends TransactionExplanation {
+  sender: string;
+  nonce: number;
+  isSigned: boolean;
+  methodName: string;
+  inputs: DotInput[];
+}
+
+/** Map WASM TransactionType to sdk-core TransactionType */
+function mapTransactionType(wasmType: WasmTransactionType): TransactionType {
+  switch (wasmType) {
+    case WasmTransactionType.Send:
+      return TransactionType.Send;
+    case WasmTransactionType.StakingActivate:
+      return TransactionType.StakingActivate;
+    case WasmTransactionType.StakingUnlock:
+      return TransactionType.StakingUnlock;
+    case WasmTransactionType.StakingWithdraw:
+      return TransactionType.StakingWithdraw;
+    case WasmTransactionType.StakingUnvote:
+      return TransactionType.StakingUnvote;
+    case WasmTransactionType.StakingClaim:
+      return TransactionType.StakingClaim;
+    case WasmTransactionType.AddressInitialization:
+      return TransactionType.AddressInitialization;
+    case WasmTransactionType.Batch:
+      return TransactionType.Batch;
+    default:
+      return TransactionType.Send;
+  }
+}
+
+/**
+ * Explain a DOT transaction from raw hex using the WASM parser.
+ *
+ * This is the single source of truth for parsing DOT transactions from bytes.
+ * Uses explainTransaction() which handles type derivation, output/input extraction,
+ * and recursive batch/proxy unwrapping.
+ *
+ * @param txHex - Hex-encoded extrinsic bytes
+ * @param material - Chain metadata needed for decoding
+ * @param senderAddress - Optional sender address fallback (for unsigned txs)
+ * @returns Parsed and explained transaction
+ */
+export function explainTransactionFromHex(
+  txHex: string,
+  material: Material,
+  senderAddress?: string
+): DotWasmExplanation {
+  const explained: WasmExplainedTransaction = explainTransaction(txHex, {
+    context: { material, sender: senderAddress },
+  });
+
+  const sender = explained.sender || senderAddress || '';
+  const type = mapTransactionType(explained.type);
+  const methodName = `${explained.method.pallet}.${explained.method.name}`;
+
+  // Map WASM outputs to BitGoJS format
+  const outputs = explained.outputs.map((o) => ({
+    address: o.address,
+    amount: o.amount === 'ALL' ? '0' : o.amount,
+  }));
+
+  // Map WASM inputs to BitGoJS format (with numeric value for legacy compat)
+  const inputs: DotInput[] = explained.inputs.map((i) => {
+    const value = i.value === 'ALL' ? 0 : parseInt(i.value || '0', 10);
+    return { address: i.address, value, valueString: i.value };
+  });
+
+  return {
+    displayOrder: ['outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'type', 'sequenceId', 'id'],
+    id: explained.id || '',
+    outputs,
+    outputAmount: explained.outputAmount,
+    changeOutputs: [],
+    changeAmount: '0',
+    fee: { fee: explained.tip || '0', type: 'tip' },
+    type,
+    sender,
+    nonce: explained.nonce,
+    isSigned: explained.isSigned,
+    methodName,
+    inputs,
+  };
+}