@bitgo-beta/sdk-coin-dot 2.2.8-beta.167 → 2.2.8-beta.1670

package/dist/cjs/test/unit/wasmBuilderByteComparison.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * WASM Builder Byte Comparison Tests
+ *
+ * Compare serialized output between:
+ * 1. Legacy approach (using @substrate/txwrapper-polkadot)
+ * 2. WASM approach (using @bitgo/wasm-dot buildTransaction)
+ *
+ * For unsigned transactions, legacy toBroadcastFormat() returns the signing payload
+ * (via construct.signingPayload). We compare WASM signablePayload() against it.
+ *
+ * Format difference: txwrapper encodes the call as `Bytes` (Vec<u8>) which includes
+ * a SCALE compact-length prefix. subxt encodes it as raw `Call` (no prefix).
+ * We strip this prefix from the legacy side before comparing, since the actual
+ * call data, era, nonce, tip, and chain context are identical.
+ *
+ * Note: wasm-dot@1.3.0 uses high-level business intents (payment, stake, unstake,
+ * claim, consolidate) instead of low-level call types. Batch and proxy operations
+ * are composed automatically from the intent (e.g., stake with proxyAddress
+ * produces batchAll(bond, addProxy)).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const statics_1 = require("@bitgo-beta/statics");
+const transactionBuilderFactory_1 = require("../../src/lib/transactionBuilderFactory");
+const fixtures_1 = require("../fixtures");
+const utils_1 = __importDefault(require("../../src/lib/utils"));
+// Import WASM builder
+const wasm_dot_1 = require("@bitgo/wasm-dot");
+describe('WASM vs Legacy Builder Byte Comparison', function () {
+    const coin = statics_1.coins.get('tdot');
+    // Get material from utils to ensure same metadata as legacy builder
+    const material = utils_1.default.getMaterial(coin);
+    function createWasmContext(overrides = {}) {
+        return {
+            sender: fixtures_1.accounts.account1.address,
+            nonce: 0,
+            tip: 0n,
+            material: material,
+            validity: {
+                firstValid: fixtures_1.westendBlock.blockNumber,
+                maxDuration: 2400,
+            },
+            referenceBlock: fixtures_1.westendBlock.hash,
+            ...overrides,
+        };
+    }
+    /**
+     * Strip SCALE compact-length prefix from the legacy signing payload.
+     *
+     * Legacy (txwrapper) encodes the call as `Bytes` type, which adds a compact-length
+     * prefix. subxt encodes it as raw `Call` (no prefix). Both produce identical
+     * call data + era + nonce + tip + chain context after this prefix.
+     */
+    function stripCompactPrefix(hex) {
+        const data = hex.startsWith('0x') ? hex.slice(2) : hex;
+        const bytes = Buffer.from(data, 'hex');
+        const mode = bytes[0] & 0b11;
+        let offset;
+        if (mode === 0b00)
+            offset = 1;
+        else if (mode === 0b01)
+            offset = 2;
+        else if (mode === 0b10)
+            offset = 4;
+        else
+            throw new Error('Big compact not supported');
+        return '0x' + bytes.slice(offset).toString('hex');
+    }
+    // ===========================================================================
+    // Transfer Transaction Tests
+    // ===========================================================================
+    describe('Transfer Transactions', function () {
+        it('should produce identical signing payload for transfer', async function () {
+            const to = fixtures_1.accounts.account2.address;
+            const amount = '1000000000000'; // 1 DOT
+            const factory = new transactionBuilderFactory_1.TransactionBuilderFactory(coin);
+            const legacyBuilder = factory.getTransferBuilder();
+            legacyBuilder
+                .sender({ address: fixtures_1.accounts.account1.address })
+                .to({ address: to })
+                .amount(amount)
+                .validity({ firstValid: fixtures_1.westendBlock.blockNumber, maxDuration: 2400 })
+                .referenceBlock(fixtures_1.westendBlock.hash)
+                .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 0 });
+            const legacyTx = await legacyBuilder.build();
+            const legacyHex = legacyTx.toBroadcastFormat();
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'payment', to, amount: BigInt(amount), keepAlive: true }, createWasmContext());
+            const wasmHex = '0x' + Buffer.from(wasmTx.signablePayload()).toString('hex');
+            assert_1.default.strictEqual(wasmHex, stripCompactPrefix(legacyHex), 'Signing payload should match');
+        });
+        it('should produce identical signing payload for transferKeepAlive with different nonce', async function () {
+            const to = fixtures_1.accounts.account2.address;
+            const amount = '5000000000000'; // 5 DOT
+            const factory = new transactionBuilderFactory_1.TransactionBuilderFactory(coin);
+            const legacyBuilder = factory.getTransferBuilder();
+            legacyBuilder
+                .sender({ address: fixtures_1.accounts.account1.address })
+                .to({ address: to })
+                .amount(amount)
+                .validity({ firstValid: fixtures_1.westendBlock.blockNumber, maxDuration: 2400 })
+                .referenceBlock(fixtures_1.westendBlock.hash)
+                .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 5 });
+            const legacyTx = await legacyBuilder.build();
+            const legacyHex = legacyTx.toBroadcastFormat();
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'payment', to, amount: BigInt(amount), keepAlive: true }, createWasmContext({ nonce: 5 }));
+            const wasmHex = '0x' + Buffer.from(wasmTx.signablePayload()).toString('hex');
+            assert_1.default.strictEqual(wasmHex, stripCompactPrefix(legacyHex), 'Signing payload should match');
+        });
+    });
+    // ===========================================================================
+    // Staking Transaction Tests
+    // ===========================================================================
+    describe('Staking Transactions', function () {
+        // Note: wasm-dot@1.3.0 `stake` without proxyAddress produces bondExtra (top-up),
+        // while the legacy getStakingBuilder() produces bond (initial stake). These are
+        // different extrinsic calls so byte comparison is not applicable. The bond call
+        // is now only produced via `stake` with proxyAddress (which creates a batch).
+        // See Intent-based Transaction Building tests below for stake sanity checks.
+        it('should produce identical signing payload for unstake (unbond)', async function () {
+            const amount = '5000000000000'; // 5 DOT
+            const factory = new transactionBuilderFactory_1.TransactionBuilderFactory(coin);
+            const legacyBuilder = factory.getUnstakeBuilder();
+            legacyBuilder
+                .sender({ address: fixtures_1.accounts.account1.address })
+                .amount(amount)
+                .validity({ firstValid: fixtures_1.westendBlock.blockNumber, maxDuration: 2400 })
+                .referenceBlock(fixtures_1.westendBlock.hash)
+                .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 0 });
+            const legacyTx = await legacyBuilder.build();
+            const legacyHex = legacyTx.toBroadcastFormat();
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'unstake', amount: BigInt(amount) }, createWasmContext());
+            const wasmHex = '0x' + Buffer.from(wasmTx.signablePayload()).toString('hex');
+            assert_1.default.strictEqual(wasmHex, stripCompactPrefix(legacyHex), 'Signing payload should match');
+        });
+        it('should produce identical signing payload for withdrawUnbonded (claim)', async function () {
+            const slashingSpans = 0;
+            const factory = new transactionBuilderFactory_1.TransactionBuilderFactory(coin);
+            const legacyBuilder = factory.getWithdrawUnstakedBuilder();
+            legacyBuilder
+                .sender({ address: fixtures_1.accounts.account1.address })
+                .slashingSpans(slashingSpans)
+                .validity({ firstValid: fixtures_1.westendBlock.blockNumber, maxDuration: 2400 })
+                .referenceBlock(fixtures_1.westendBlock.hash)
+                .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 0 });
+            const legacyTx = await legacyBuilder.build();
+            const legacyHex = legacyTx.toBroadcastFormat();
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'claim', slashingSpans }, createWasmContext());
+            const wasmHex = '0x' + Buffer.from(wasmTx.signablePayload()).toString('hex');
+            assert_1.default.strictEqual(wasmHex, stripCompactPrefix(legacyHex), 'Signing payload should match');
+        });
+    });
+    // ===========================================================================
+    // Intent-based Transaction Building (sanity checks)
+    // ===========================================================================
+    describe('Intent-based Transaction Building', function () {
+        it('should build payment from intent', async function () {
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'payment', to: fixtures_1.accounts.account2.address, amount: 1000000000000n, keepAlive: true }, createWasmContext());
+            const serialized = wasmTx.toBroadcastFormat();
+            (0, assert_1.default)(serialized.startsWith('0x'), 'Should be hex encoded');
+            (0, assert_1.default)(serialized.length > 10, 'Should have content');
+        });
+        it('should build stake (top-up) from intent', async function () {
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'stake', amount: 5000000000000n, payee: { type: 'staked' } }, createWasmContext());
+            (0, assert_1.default)(wasmTx.toBroadcastFormat().startsWith('0x'));
+        });
+        it('should build stake with proxy (new stake / batchAll(bond, addProxy)) from intent', async function () {
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'stake', amount: 10000000000000n, proxyAddress: fixtures_1.accounts.account2.address, payee: { type: 'staked' } }, createWasmContext());
+            (0, assert_1.default)(wasmTx.toBroadcastFormat().startsWith('0x'));
+        });
+        it('should build claim (withdrawUnbonded) from intent', async function () {
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'claim', slashingSpans: 0 }, createWasmContext());
+            (0, assert_1.default)(wasmTx.toBroadcastFormat().startsWith('0x'));
+        });
+        it('should build unstake (partial / unbond) from intent', async function () {
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'unstake', amount: 5000000000000n }, createWasmContext());
+            (0, assert_1.default)(wasmTx.toBroadcastFormat().startsWith('0x'));
+        });
+        it('should build unstake with stopStaking (full / batchAll(removeProxy, chill, unbond)) from intent', async function () {
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({
+                type: 'unstake',
+                amount: 5000000000000n,
+                stopStaking: true,
+                proxyAddress: fixtures_1.accounts.account2.address,
+            }, createWasmContext());
+            (0, assert_1.default)(wasmTx.toBroadcastFormat().startsWith('0x'));
+        });
+        it('should build consolidate (transferAll) from intent', async function () {
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'consolidate', to: fixtures_1.accounts.account2.address }, createWasmContext());
+            (0, assert_1.default)(wasmTx.toBroadcastFormat().startsWith('0x'));
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wasmBuilderByteComparison.js","sourceRoot":"","sources":["../../../../test/unit/wasmBuilderByteComparison.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * WASM Builder Byte Comparison Tests\n *\n * Compare serialized output between:\n * 1. Legacy approach (using @substrate/txwrapper-polkadot)\n * 2. WASM approach (using @bitgo/wasm-dot buildTransaction)\n *\n * For unsigned transactions, legacy toBroadcastFormat() returns the signing payload\n * (via construct.signingPayload). We compare WASM signablePayload() against it.\n *\n * Format difference: txwrapper encodes the call as `Bytes` (Vec<u8>) which includes\n * a SCALE compact-length prefix. subxt encodes it as raw `Call` (no prefix).\n * We strip this prefix from the legacy side before comparing, since the actual\n * call data, era, nonce, tip, and chain context are identical.\n *\n * Note: wasm-dot@1.3.0 uses high-level business intents (payment, stake, unstake,\n * claim, consolidate) instead of low-level call types. Batch and proxy operations\n * are composed automatically from the intent (e.g., stake with proxyAddress\n * produces batchAll(bond, addProxy)).\n */\n\nimport assert from 'assert';\nimport { coins } from '@bitgo-beta/statics';\nimport { TransactionBuilderFactory } from '../../src/lib/transactionBuilderFactory';\nimport { TransferBuilder } from '../../src/lib/transferBuilder';\nimport { accounts, westendBlock } from '../fixtures';\nimport utils from '../../src/lib/utils';\n\n// Import WASM builder\nimport { buildTransaction, type BuildContext, type Material } from '@bitgo/wasm-dot';\n\ndescribe('WASM vs Legacy Builder Byte Comparison', function () {\n  const coin = coins.get('tdot');\n\n  // Get material from utils to ensure same metadata as legacy builder\n  const material = utils.getMaterial(coin);\n\n  function createWasmContext(overrides: Partial<BuildContext> = {}): BuildContext {\n    return {\n      sender: accounts.account1.address,\n      nonce: 0,\n      tip: 0n,\n      material: material as Material,\n      validity: {\n        firstValid: westendBlock.blockNumber,\n        maxDuration: 2400,\n      },\n      referenceBlock: westendBlock.hash,\n      ...overrides,\n    };\n  }\n\n  /**\n   * Strip SCALE compact-length prefix from the legacy signing payload.\n   *\n   * Legacy (txwrapper) encodes the call as `Bytes` type, which adds a compact-length\n   * prefix. subxt encodes it as raw `Call` (no prefix). Both produce identical\n   * call data + era + nonce + tip + chain context after this prefix.\n   */\n  function stripCompactPrefix(hex: string): string {\n    const data = hex.startsWith('0x') ? hex.slice(2) : hex;\n    const bytes = Buffer.from(data, 'hex');\n    const mode = bytes[0] & 0b11;\n    let offset: number;\n    if (mode === 0b00) offset = 1;\n    else if (mode === 0b01) offset = 2;\n    else if (mode === 0b10) offset = 4;\n    else throw new Error('Big compact not supported');\n    return '0x' + bytes.slice(offset).toString('hex');\n  }\n\n  // ===========================================================================\n  // Transfer Transaction Tests\n  // ===========================================================================\n  describe('Transfer Transactions', function () {\n    it('should produce identical signing payload for transfer', async function () {\n      const to = accounts.account2.address;\n      const amount = '1000000000000'; // 1 DOT\n\n      const factory = new TransactionBuilderFactory(coin);\n      const legacyBuilder = factory.getTransferBuilder() as TransferBuilder;\n\n      legacyBuilder\n        .sender({ address: accounts.account1.address })\n        .to({ address: to })\n        .amount(amount)\n        .validity({ firstValid: westendBlock.blockNumber, maxDuration: 2400 })\n        .referenceBlock(westendBlock.hash)\n        .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 0 });\n\n      const legacyTx = await legacyBuilder.build();\n      const legacyHex = legacyTx.toBroadcastFormat();\n\n      const wasmTx = buildTransaction(\n        { type: 'payment', to, amount: BigInt(amount), keepAlive: true },\n        createWasmContext()\n      );\n      const wasmHex = '0x' + Buffer.from(wasmTx.signablePayload()).toString('hex');\n\n      assert.strictEqual(wasmHex, stripCompactPrefix(legacyHex), 'Signing payload should match');\n    });\n\n    it('should produce identical signing payload for transferKeepAlive with different nonce', async function () {\n      const to = accounts.account2.address;\n      const amount = '5000000000000'; // 5 DOT\n\n      const factory = new TransactionBuilderFactory(coin);\n      const legacyBuilder = factory.getTransferBuilder() as TransferBuilder;\n\n      legacyBuilder\n        .sender({ address: accounts.account1.address })\n        .to({ address: to })\n        .amount(amount)\n        .validity({ firstValid: westendBlock.blockNumber, maxDuration: 2400 })\n        .referenceBlock(westendBlock.hash)\n        .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 5 });\n\n      const legacyTx = await legacyBuilder.build();\n      const legacyHex = legacyTx.toBroadcastFormat();\n\n      const wasmTx = buildTransaction(\n        { type: 'payment', to, amount: BigInt(amount), keepAlive: true },\n        createWasmContext({ nonce: 5 })\n      );\n      const wasmHex = '0x' + Buffer.from(wasmTx.signablePayload()).toString('hex');\n\n      assert.strictEqual(wasmHex, stripCompactPrefix(legacyHex), 'Signing payload should match');\n    });\n  });\n\n  // ===========================================================================\n  // Staking Transaction Tests\n  // ===========================================================================\n  describe('Staking Transactions', function () {\n    // Note: wasm-dot@1.3.0 `stake` without proxyAddress produces bondExtra (top-up),\n    // while the legacy getStakingBuilder() produces bond (initial stake). These are\n    // different extrinsic calls so byte comparison is not applicable. The bond call\n    // is now only produced via `stake` with proxyAddress (which creates a batch).\n    // See Intent-based Transaction Building tests below for stake sanity checks.\n\n    it('should produce identical signing payload for unstake (unbond)', async function () {\n      const amount = '5000000000000'; // 5 DOT\n\n      const factory = new TransactionBuilderFactory(coin);\n      const legacyBuilder = factory.getUnstakeBuilder();\n\n      legacyBuilder\n        .sender({ address: accounts.account1.address })\n        .amount(amount)\n        .validity({ firstValid: westendBlock.blockNumber, maxDuration: 2400 })\n        .referenceBlock(westendBlock.hash)\n        .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 0 });\n\n      const legacyTx = await legacyBuilder.build();\n      const legacyHex = legacyTx.toBroadcastFormat();\n\n      const wasmTx = buildTransaction({ type: 'unstake', amount: BigInt(amount) }, createWasmContext());\n      const wasmHex = '0x' + Buffer.from(wasmTx.signablePayload()).toString('hex');\n\n      assert.strictEqual(wasmHex, stripCompactPrefix(legacyHex), 'Signing payload should match');\n    });\n\n    it('should produce identical signing payload for withdrawUnbonded (claim)', async function () {\n      const slashingSpans = 0;\n\n      const factory = new TransactionBuilderFactory(coin);\n      const legacyBuilder = factory.getWithdrawUnstakedBuilder();\n\n      legacyBuilder\n        .sender({ address: accounts.account1.address })\n        .slashingSpans(slashingSpans)\n        .validity({ firstValid: westendBlock.blockNumber, maxDuration: 2400 })\n        .referenceBlock(westendBlock.hash)\n        .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 0 });\n\n      const legacyTx = await legacyBuilder.build();\n      const legacyHex = legacyTx.toBroadcastFormat();\n\n      const wasmTx = buildTransaction({ type: 'claim', slashingSpans }, createWasmContext());\n      const wasmHex = '0x' + Buffer.from(wasmTx.signablePayload()).toString('hex');\n\n      assert.strictEqual(wasmHex, stripCompactPrefix(legacyHex), 'Signing payload should match');\n    });\n  });\n\n  // ===========================================================================\n  // Intent-based Transaction Building (sanity checks)\n  // ===========================================================================\n  describe('Intent-based Transaction Building', function () {\n    it('should build payment from intent', async function () {\n      const wasmTx = buildTransaction(\n        { type: 'payment', to: accounts.account2.address, amount: 1000000000000n, keepAlive: true },\n        createWasmContext()\n      );\n      const serialized = wasmTx.toBroadcastFormat();\n      assert(serialized.startsWith('0x'), 'Should be hex encoded');\n      assert(serialized.length > 10, 'Should have content');\n    });\n\n    it('should build stake (top-up) from intent', async function () {\n      const wasmTx = buildTransaction(\n        { type: 'stake', amount: 5000000000000n, payee: { type: 'staked' } },\n        createWasmContext()\n      );\n      assert(wasmTx.toBroadcastFormat().startsWith('0x'));\n    });\n\n    it('should build stake with proxy (new stake / batchAll(bond, addProxy)) from intent', async function () {\n      const wasmTx = buildTransaction(\n        { type: 'stake', amount: 10000000000000n, proxyAddress: accounts.account2.address, payee: { type: 'staked' } },\n        createWasmContext()\n      );\n      assert(wasmTx.toBroadcastFormat().startsWith('0x'));\n    });\n\n    it('should build claim (withdrawUnbonded) from intent', async function () {\n      const wasmTx = buildTransaction({ type: 'claim', slashingSpans: 0 }, createWasmContext());\n      assert(wasmTx.toBroadcastFormat().startsWith('0x'));\n    });\n\n    it('should build unstake (partial / unbond) from intent', async function () {\n      const wasmTx = buildTransaction({ type: 'unstake', amount: 5000000000000n }, createWasmContext());\n      assert(wasmTx.toBroadcastFormat().startsWith('0x'));\n    });\n\n    it('should build unstake with stopStaking (full / batchAll(removeProxy, chill, unbond)) from intent', async function () {\n      const wasmTx = buildTransaction(\n        {\n          type: 'unstake',\n          amount: 5000000000000n,\n          stopStaking: true,\n          proxyAddress: accounts.account2.address,\n        },\n        createWasmContext()\n      );\n      assert(wasmTx.toBroadcastFormat().startsWith('0x'));\n    });\n\n    it('should build consolidate (transferAll) from intent', async function () {\n      const wasmTx = buildTransaction({ type: 'consolidate', to: accounts.account2.address }, createWasmContext());\n      assert(wasmTx.toBroadcastFormat().startsWith('0x'));\n    });\n  });\n});\n"]}

package/dist/cjs/test/unit/wasmParserExplanation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM Parser Explanation Tests
+ *
+ * Tests for explainDotTransaction, specifically verifying batch transaction
+ * handling with proxy deposit costs matches legacy account-lib behavior.
+ *
+ * Uses WASM-built transactions (not legacy rawTx fixtures) since the WASM
+ * parser requires metadata-compatible signed extension encoding.
+ *
+ * Note: wasm-dot@1.3.0 uses high-level business intents. Batch transactions
+ * are produced automatically from the intent (e.g., unstake with stopStaking
+ * produces batchAll(removeProxy, chill, unbond)).
+ */
+export {};
+//# sourceMappingURL=wasmParserExplanation.d.ts.map

package/dist/cjs/test/unit/wasmParserExplanation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasmParserExplanation.d.ts","sourceRoot":"","sources":["../../../../test/unit/wasmParserExplanation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/dist/cjs/test/unit/wasmParserExplanation.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * WASM Parser Explanation Tests
+ *
+ * Tests for explainDotTransaction, specifically verifying batch transaction
+ * handling with proxy deposit costs matches legacy account-lib behavior.
+ *
+ * Uses WASM-built transactions (not legacy rawTx fixtures) since the WASM
+ * parser requires metadata-compatible signed extension encoding.
+ *
+ * Note: wasm-dot@1.3.0 uses high-level business intents. Batch transactions
+ * are produced automatically from the intent (e.g., unstake with stopStaking
+ * produces batchAll(removeProxy, chill, unbond)).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const statics_1 = require("@bitgo-beta/statics");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const wasmParser_1 = require("../../src/lib/wasmParser");
+const wasm_dot_1 = require("@bitgo/wasm-dot");
+const fixtures_1 = require("../fixtures");
+const utils_1 = __importDefault(require("../../src/lib/utils"));
+describe('WASM Parser Explanation', function () {
+    const coin = statics_1.coins.get('tdot');
+    // utils.getMaterial returns the iface Material shape; cast to WasmMaterial for buildTransaction
+    const material = utils_1.default.getMaterial(coin);
+    function createWasmContext(overrides = {}) {
+        return {
+            sender: fixtures_1.accounts.account1.address,
+            nonce: 0,
+            tip: 0n,
+            material,
+            validity: {
+                firstValid: fixtures_1.westendBlock.blockNumber,
+                maxDuration: 2400,
+            },
+            referenceBlock: fixtures_1.westendBlock.hash,
+            ...overrides,
+        };
+    }
+    describe('Batch unstake (removeProxy + chill + unbond)', function () {
+        it('should explain batch unstake with proxy deposit cost', function () {
+            const unbondAmount = 5000000000000n; // 5 DOT
+            const proxyDelegate = fixtures_1.accounts.account2.address;
+            // Build a full unstake: produces batchAll(removeProxy, chill, unbond)
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({
+                type: 'unstake',
+                amount: unbondAmount,
+                stopStaking: true,
+                proxyAddress: proxyDelegate,
+            }, createWasmContext());
+            const txHex = wasmTx.toBroadcastFormat();
+            const explanation = (0, wasmParser_1.explainDotTransaction)({
+                txHex,
+                material,
+                senderAddress: fixtures_1.accounts.account1.address,
+            });
+            // Should be Batch type
+            assert_1.default.strictEqual(explanation.type, sdk_core_1.TransactionType.Batch);
+            assert_1.default.ok(explanation.methodName.includes('batchAll'), `Expected batchAll, got ${explanation.methodName}`);
+            // Outputs should contain proxy deposit cost, NOT the unbond amount
+            assert_1.default.strictEqual(explanation.outputs.length, 1, 'Should have exactly one output (proxy deposit cost)');
+            const output = explanation.outputs[0];
+            assert_1.default.strictEqual(output.address, fixtures_1.accounts.account1.address, 'Output should go to sender (deposit refund)');
+            const proxyDepositCost = BigInt(output.amount);
+            assert_1.default.ok(proxyDepositCost > 0n, 'Proxy deposit cost should be positive');
+            // The proxy deposit cost should NOT equal the unbond amount
+            assert_1.default.notStrictEqual(proxyDepositCost, unbondAmount, 'Should use proxy deposit cost, not unbond amount');
+            // Input should come from the proxy delegate address
+            assert_1.default.strictEqual(explanation.inputs.length, 1, 'Should have exactly one input');
+            assert_1.default.strictEqual(explanation.inputs[0].address, proxyDelegate, 'Input should come from proxy delegate');
+            assert_1.default.strictEqual(explanation.inputs[0].valueString, output.amount, 'Input value should equal proxy deposit cost');
+        });
+        it('proxy deposit cost should be consistent across calls', function () {
+            const proxyDelegate = fixtures_1.accounts.account2.address;
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({
+                type: 'unstake',
+                amount: 1000000000000n,
+                stopStaking: true,
+                proxyAddress: proxyDelegate,
+            }, createWasmContext());
+            const txHex = wasmTx.toBroadcastFormat();
+            const explanation1 = (0, wasmParser_1.explainDotTransaction)({ txHex, material, senderAddress: fixtures_1.accounts.account1.address });
+            const explanation2 = (0, wasmParser_1.explainDotTransaction)({ txHex, material, senderAddress: fixtures_1.accounts.account1.address });
+            assert_1.default.strictEqual(explanation1.outputs[0].amount, explanation2.outputs[0].amount);
+        });
+    });
+    describe('Batch stake (bond + addProxy)', function () {
+        it('should explain batch stake with bond amount and proxy deposit cost', function () {
+            const bondAmount = 10000000000000n; // 10 DOT
+            const proxyDelegate = fixtures_1.accounts.account2.address;
+            // Build a new stake with proxy: produces batchAll(bond, addProxy)
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({
+                type: 'stake',
+                amount: bondAmount,
+                proxyAddress: proxyDelegate,
+                payee: { type: 'staked' },
+            }, createWasmContext());
+            const txHex = wasmTx.toBroadcastFormat();
+            const explanation = (0, wasmParser_1.explainDotTransaction)({ txHex, material, senderAddress: fixtures_1.accounts.account1.address });
+            assert_1.default.strictEqual(explanation.type, sdk_core_1.TransactionType.Batch);
+            // Should have two outputs: bond amount (to STAKING_DESTINATION sentinel) + proxy deposit cost (to proxy delegate)
+            assert_1.default.strictEqual(explanation.outputs.length, 2, 'Should have bond + proxy deposit outputs');
+            const stakingOutput = explanation.outputs.find((o) => o.address === '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM');
+            assert_1.default.ok(stakingOutput, 'Should have STAKING_DESTINATION sentinel output for bond amount');
+            assert_1.default.strictEqual(BigInt(stakingOutput.amount), bondAmount, 'Bond amount should match');
+            const proxyOutput = explanation.outputs.find((o) => o.address !== '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM');
+            assert_1.default.ok(proxyOutput, 'Should have proxy deposit output');
+            assert_1.default.strictEqual(proxyOutput.address, proxyDelegate);
+            assert_1.default.ok(BigInt(proxyOutput.amount) > 0n, 'Proxy deposit cost should be positive');
+            // All inputs should come from sender
+            assert_1.default.strictEqual(explanation.inputs.length, 2);
+            for (const input of explanation.inputs) {
+                assert_1.default.strictEqual(input.address, fixtures_1.accounts.account1.address);
+            }
+        });
+    });
+    describe('Non-batch transactions (should not be affected)', function () {
+        it('should explain transfer normally', function () {
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'payment', to: fixtures_1.accounts.account2.address, amount: 1000000000000n, keepAlive: true }, createWasmContext());
+            const explanation = (0, wasmParser_1.explainDotTransaction)({
+                txHex: wasmTx.toBroadcastFormat(),
+                material,
+                senderAddress: fixtures_1.accounts.account1.address,
+            });
+            assert_1.default.strictEqual(explanation.type, sdk_core_1.TransactionType.Send);
+            assert_1.default.strictEqual(explanation.outputs.length, 1);
+            assert_1.default.strictEqual(explanation.outputs[0].address, fixtures_1.accounts.account2.address);
+            assert_1.default.strictEqual(explanation.outputs[0].amount, '1000000000000');
+        });
+        it('should explain single unstake (unbond) normally', function () {
+            const wasmTx = (0, wasm_dot_1.buildTransaction)({ type: 'unstake', amount: 5000000000000n }, createWasmContext());
+            const explanation = (0, wasmParser_1.explainDotTransaction)({
+                txHex: wasmTx.toBroadcastFormat(),
+                material,
+                senderAddress: fixtures_1.accounts.account1.address,
+            });
+            assert_1.default.strictEqual(explanation.type, sdk_core_1.TransactionType.StakingUnlock);
+            // Unbond has no outputs (balance stays in account as unlocking, matching legacy behavior)
+            assert_1.default.strictEqual(explanation.outputs.length, 0);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wasmParserExplanation.js","sourceRoot":"","sources":["../../../../test/unit/wasmParserExplanation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * WASM Parser Explanation Tests\n *\n * Tests for explainDotTransaction, specifically verifying batch transaction\n * handling with proxy deposit costs matches legacy account-lib behavior.\n *\n * Uses WASM-built transactions (not legacy rawTx fixtures) since the WASM\n * parser requires metadata-compatible signed extension encoding.\n *\n * Note: wasm-dot@1.3.0 uses high-level business intents. Batch transactions\n * are produced automatically from the intent (e.g., unstake with stopStaking\n * produces batchAll(removeProxy, chill, unbond)).\n */\n\nimport assert from 'assert';\nimport { coins } from '@bitgo-beta/statics';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\nimport { explainDotTransaction } from '../../src/lib/wasmParser';\nimport { buildTransaction, type BuildContext, type Material as WasmMaterial } from '@bitgo/wasm-dot';\nimport type { Material } from '../../src/lib/iface';\nimport { accounts, westendBlock } from '../fixtures';\nimport utils from '../../src/lib/utils';\n\ndescribe('WASM Parser Explanation', function () {\n  const coin = coins.get('tdot');\n  // utils.getMaterial returns the iface Material shape; cast to WasmMaterial for buildTransaction\n  const material = utils.getMaterial(coin) as Material & WasmMaterial;\n\n  function createWasmContext(overrides: Partial<BuildContext> = {}): BuildContext {\n    return {\n      sender: accounts.account1.address,\n      nonce: 0,\n      tip: 0n,\n      material,\n      validity: {\n        firstValid: westendBlock.blockNumber,\n        maxDuration: 2400,\n      },\n      referenceBlock: westendBlock.hash,\n      ...overrides,\n    };\n  }\n\n  describe('Batch unstake (removeProxy + chill + unbond)', function () {\n    it('should explain batch unstake with proxy deposit cost', function () {\n      const unbondAmount = 5000000000000n; // 5 DOT\n      const proxyDelegate = accounts.account2.address;\n\n      // Build a full unstake: produces batchAll(removeProxy, chill, unbond)\n      const wasmTx = buildTransaction(\n        {\n          type: 'unstake',\n          amount: unbondAmount,\n          stopStaking: true,\n          proxyAddress: proxyDelegate,\n        },\n        createWasmContext()\n      );\n\n      const txHex = wasmTx.toBroadcastFormat();\n      const explanation = explainDotTransaction({\n        txHex,\n        material,\n        senderAddress: accounts.account1.address,\n      });\n\n      // Should be Batch type\n      assert.strictEqual(explanation.type, TransactionType.Batch);\n      assert.ok(explanation.methodName.includes('batchAll'), `Expected batchAll, got ${explanation.methodName}`);\n\n      // Outputs should contain proxy deposit cost, NOT the unbond amount\n      assert.strictEqual(explanation.outputs.length, 1, 'Should have exactly one output (proxy deposit cost)');\n      const output = explanation.outputs[0];\n      assert.strictEqual(output.address, accounts.account1.address, 'Output should go to sender (deposit refund)');\n      const proxyDepositCost = BigInt(output.amount);\n      assert.ok(proxyDepositCost > 0n, 'Proxy deposit cost should be positive');\n      // The proxy deposit cost should NOT equal the unbond amount\n      assert.notStrictEqual(proxyDepositCost, unbondAmount, 'Should use proxy deposit cost, not unbond amount');\n\n      // Input should come from the proxy delegate address\n      assert.strictEqual(explanation.inputs.length, 1, 'Should have exactly one input');\n      assert.strictEqual(explanation.inputs[0].address, proxyDelegate, 'Input should come from proxy delegate');\n      assert.strictEqual(\n        explanation.inputs[0].valueString,\n        output.amount,\n        'Input value should equal proxy deposit cost'\n      );\n    });\n\n    it('proxy deposit cost should be consistent across calls', function () {\n      const proxyDelegate = accounts.account2.address;\n      const wasmTx = buildTransaction(\n        {\n          type: 'unstake',\n          amount: 1000000000000n,\n          stopStaking: true,\n          proxyAddress: proxyDelegate,\n        },\n        createWasmContext()\n      );\n\n      const txHex = wasmTx.toBroadcastFormat();\n      const explanation1 = explainDotTransaction({ txHex, material, senderAddress: accounts.account1.address });\n      const explanation2 = explainDotTransaction({ txHex, material, senderAddress: accounts.account1.address });\n\n      assert.strictEqual(explanation1.outputs[0].amount, explanation2.outputs[0].amount);\n    });\n  });\n\n  describe('Batch stake (bond + addProxy)', function () {\n    it('should explain batch stake with bond amount and proxy deposit cost', function () {\n      const bondAmount = 10000000000000n; // 10 DOT\n      const proxyDelegate = accounts.account2.address;\n\n      // Build a new stake with proxy: produces batchAll(bond, addProxy)\n      const wasmTx = buildTransaction(\n        {\n          type: 'stake',\n          amount: bondAmount,\n          proxyAddress: proxyDelegate,\n          payee: { type: 'staked' },\n        },\n        createWasmContext()\n      );\n\n      const txHex = wasmTx.toBroadcastFormat();\n      const explanation = explainDotTransaction({ txHex, material, senderAddress: accounts.account1.address });\n\n      assert.strictEqual(explanation.type, TransactionType.Batch);\n\n      // Should have two outputs: bond amount (to STAKING_DESTINATION sentinel) + proxy deposit cost (to proxy delegate)\n      assert.strictEqual(explanation.outputs.length, 2, 'Should have bond + proxy deposit outputs');\n\n      const stakingOutput = explanation.outputs.find(\n        (o) => o.address === '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM'\n      );\n      assert.ok(stakingOutput, 'Should have STAKING_DESTINATION sentinel output for bond amount');\n      assert.strictEqual(BigInt(stakingOutput!.amount), bondAmount, 'Bond amount should match');\n\n      const proxyOutput = explanation.outputs.find(\n        (o) => o.address !== '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM'\n      );\n      assert.ok(proxyOutput, 'Should have proxy deposit output');\n      assert.strictEqual(proxyOutput!.address, proxyDelegate);\n      assert.ok(BigInt(proxyOutput!.amount) > 0n, 'Proxy deposit cost should be positive');\n\n      // All inputs should come from sender\n      assert.strictEqual(explanation.inputs.length, 2);\n      for (const input of explanation.inputs) {\n        assert.strictEqual(input.address, accounts.account1.address);\n      }\n    });\n  });\n\n  describe('Non-batch transactions (should not be affected)', function () {\n    it('should explain transfer normally', function () {\n      const wasmTx = buildTransaction(\n        { type: 'payment', to: accounts.account2.address, amount: 1000000000000n, keepAlive: true },\n        createWasmContext()\n      );\n\n      const explanation = explainDotTransaction({\n        txHex: wasmTx.toBroadcastFormat(),\n        material,\n        senderAddress: accounts.account1.address,\n      });\n\n      assert.strictEqual(explanation.type, TransactionType.Send);\n      assert.strictEqual(explanation.outputs.length, 1);\n      assert.strictEqual(explanation.outputs[0].address, accounts.account2.address);\n      assert.strictEqual(explanation.outputs[0].amount, '1000000000000');\n    });\n\n    it('should explain single unstake (unbond) normally', function () {\n      const wasmTx = buildTransaction({ type: 'unstake', amount: 5000000000000n }, createWasmContext());\n\n      const explanation = explainDotTransaction({\n        txHex: wasmTx.toBroadcastFormat(),\n        material,\n        senderAddress: accounts.account1.address,\n      });\n\n      assert.strictEqual(explanation.type, TransactionType.StakingUnlock);\n      // Unbond has no outputs (balance stays in account as unlocking, matching legacy behavior)\n      assert.strictEqual(explanation.outputs.length, 0);\n    });\n  });\n});\n"]}