refactor: follow wasm-utxo parse convention (PR #145 feedback)

remove hex methods, move parse() to standalone function, use get wasm()

changes per otto's review:
- remove Transaction.fromHex(), .toHex(), .toBroadcastFormat(), .callDataHex, .signablePayloadHex()
- remove _context field and .parse() method from Transaction
- rename parseTransactionData → parseTransaction (the actual parser)
- rename getInner() → get wasm() (@internal)
- remove top-level parseTransaction function (callers use DotTransaction.fromBytes directly)
- move createParseContext to parser.ts (single source)
- update tests: DotTransaction.fromBytes() for signing, parseTransaction() for decoded data
- callers do their own base conversions (Uint8Array only on public API)

separation of concerns:
- Transaction.fromBytes(bytes) - deserialize for signing
- parseTransaction(bytes, context?) - decode into structured data
- explainTransaction(bytes, options) - high-level explanation

BTC-0

Author: lcovar

packages/wasm-dot/js/builder.ts

@@ -74,8 +74,7 @@ import type { TransactionIntent, BuildContext } from "./types";
  */
 export function buildTransaction(intent: TransactionIntent, context: BuildContext): DotTransaction {
   const inner = BuilderNamespace.buildTransaction(intent, context);
-  const parseContext = { material: context.material, sender: context.sender };
-  return DotTransaction.fromInner(inner as any, parseContext);
+  return DotTransaction.fromInner(inner as any);
 }
 
 // Re-export types for convenience

packages/wasm-dot/js/explain.ts

@@ -6,7 +6,7 @@
  * the structured ExplainedTransaction that consumers expect.
  */
 
-import { parseTransactionData, type TransactionInput } from "./parser";
+import { parseTransaction, type TransactionInput } from "./parser";
 import type { Era, ParseContext, ParsedMethod } from "./types";
 
 const MAX_NESTING_DEPTH = 10;
@@ -98,7 +98,7 @@ export function explainTransaction(
   input: TransactionInput,
   options?: { context?: ParseContext },
 ): ExplainedTransaction {
-  const parsed = parseTransactionData(input, options?.context);
+  const parsed = parseTransaction(input, options?.context);
   const type_ = deriveTransactionType(parsed.method, 0);
   const outputs = extractOutputs(parsed.method, 0);
   const sender = parsed.sender ?? undefined;

packages/wasm-dot/js/index.ts

@@ -2,14 +2,10 @@
  * wasm-dot: WASM bindings for Polkadot/DOT transaction operations
  *
  * This module provides:
- * - Transaction parsing: parseTransaction(bytes) → DotTransaction (inspect + sign)
+ * - Transaction parsing: parseTransaction(bytes, context) → ParsedTransaction
  * - Transaction explanation: explainTransaction(bytes, options) → ExplainedTransaction
  * - Transaction building: buildTransaction(intent, context) → DotTransaction
- *
- * Pattern matches wasm-solana:
- * - parseTransaction(bytes) returns a Transaction object (not plain data)
- * - Transaction.parse() returns decoded instruction/method data
- * - explainTransaction() is a standalone function for high-level explanation
+ * - Transaction signing: DotTransaction.fromBytes(bytes) → inspect + sign
  */
 
 import {
@@ -25,65 +21,15 @@ import {
 export {
   WasmTransaction,
   ParserNamespace,
-  ParserNamespace as DotParser,
   BuilderNamespace,
   MaterialJs,
   ValidityJs,
   ParseContextJs,
 };
 
-// Re-export types
+// Re-export all public API
 export * from "./types";
 export * from "./transaction";
 export * from "./parser";
 export * from "./builder";
 export * from "./explain";
-
-// =============================================================================
-// parseTransaction — Top-level entry point (returns DotTransaction)
-// =============================================================================
-
-import { DotTransaction } from "./transaction";
-import type { ParseContext } from "./types";
-
-/**
- * Parse a DOT transaction from bytes or hex, returning a DotTransaction
- * that can be both inspected and signed.
- *
- * This is the standard entry point for working with DOT transactions,
- * matching wasm-solana's `parseTransaction(bytes) → Transaction` pattern.
- *
- * Use `.parse()` for decoded method data, `.addSignature()` for signing,
- * `.toBytes()` for serialization.
- *
- * For low-level parsed data without a Transaction object, use
- * `parseTransactionData()` instead.
- *
- * @param input - Raw bytes or hex string (with or without 0x)
- * @param context - Parsing context with chain material
- * @returns DotTransaction instance
- *
- * @example
- * ```typescript
- * import { parseTransaction } from '@bitgo/wasm-dot';
- *
- * const tx = parseTransaction(txHex, { material });
- *
- * // Inspect decoded method data
- * const parsed = tx.parse();
- * console.log(parsed.method.pallet); // "balances"
- *
- * // Sign and serialize
- * tx.addSignature(signature, pubkey);
- * const signedBytes = tx.toBytes();
- * ```
- */
-export function parseTransaction(
-  input: Uint8Array | string,
-  context?: ParseContext,
-): DotTransaction {
-  if (typeof input === "string") {
-    return DotTransaction.fromHex(input, context);
-  }
-  return DotTransaction.fromBytes(input, context);
-}

packages/wasm-dot/js/parser.ts

@@ -1,11 +1,10 @@
 /**
- * Low-level transaction parsing.
+ * Transaction parsing — standalone function that decodes extrinsic bytes
+ * into structured data (pallet, method, args, nonce, etc.).
  *
- * Provides `parseTransactionData()` — the low-level parser that returns
- * a plain `ParsedTransaction` object (pallet, method, args, nonce, etc.).
- *
- * For the high-level entry point that returns a `DotTransaction` (with
- * signing + `.parse()` methods), use `parseTransaction()` from index.ts.
+ * This is separate from the DotTransaction class, which handles signing.
+ * Use DotTransaction.fromBytes() when you need to sign.
+ * Use parseTransaction() when you need decoded data.
  */
 
 import { ParserNamespace, MaterialJs, ParseContextJs } from "./wasm/wasm_dot";
@@ -18,44 +17,42 @@ import type { ParseContext, ParsedTransaction } from "./types";
 export type TransactionInput = Uint8Array | string | DotTransaction;
 
 /**
- * Parse a DOT transaction into structured data (low-level).
+ * Parse a DOT transaction into structured data.
  *
  * Returns a plain `ParsedTransaction` object with decoded pallet, method,
- * args, nonce, tip, era, etc. This is the raw decoded output — no type
- * derivation or output extraction.
+ * args, nonce, tip, era, etc.
  *
- * For a `DotTransaction` object (with signing methods + `.parse()`),
- * use `parseTransaction()` instead.
+ * For a signable `DotTransaction` object, use `DotTransaction.fromBytes()` instead.
  *
  * @param input - Raw bytes, hex string (with or without 0x), or DotTransaction
  * @param context - Parsing context with chain material (required for decoding)
  * @returns Parsed transaction data
  *
  * @example
  * ```typescript
- * import { parseTransactionData } from '@bitgo/wasm-dot';
+ * import { parseTransaction } from '@bitgo/wasm-dot';
  *
- * const parsed = parseTransactionData(txHex, { material });
+ * const parsed = parseTransaction(txBytes, { material });
  * console.log(parsed.method.pallet); // "balances"
  * console.log(parsed.method.name);   // "transferKeepAlive"
  * ```
  */
-export function parseTransactionData(
+export function parseTransaction(
   input: TransactionInput,
   context?: ParseContext,
 ): ParsedTransaction {
   const ctx = context ? createParseContext(context) : undefined;
 
-  if (typeof input === "string") {
-    return ParserNamespace.parseTransactionHex(input, ctx) as ParsedTransaction;
+  if (input instanceof DotTransaction) {
+    return ParserNamespace.parseTransaction(input.toBytes(), ctx) as ParsedTransaction;
   }
 
-  if (input instanceof DotTransaction) {
-    const hex = input.toHex();
-    return ParserNamespace.parseTransactionHex(hex, ctx) as ParsedTransaction;
+  if (input instanceof Uint8Array) {
+    return ParserNamespace.parseTransaction(input, ctx) as ParsedTransaction;
   }
 
-  return ParserNamespace.parseTransaction(input, ctx) as ParsedTransaction;
+  // String input — let WASM handle hex parsing
+  return ParserNamespace.parseTransactionHex(input, ctx) as ParsedTransaction;
 }
 
 /**