@bitgo-beta/sdk-coin-eth 4.4.1-beta.21 → 4.4.1-beta.2100

package/dist/test/unit/erc7984Token.js

@@ -0,0 +1,1645 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for Erc7984Token.
+ *
+ * Covers:
+ *   - getTokenEnablementConfig
+ *   - verifyTransaction (TSS and multisig paths)
+ *   - verifyTransaction (confidential transfer / SendERC7984 path)
+ *   - decodeTokenAddressesFromDelegationCalldata (round-trip and forwarder-wrapped)
+ *   - recover() (ERC-7984 confidential token recovery)
+ *   - queryConfidentialBalance()
+ */
+const should_1 = __importDefault(require("should"));
+const sinon_1 = __importDefault(require("sinon"));
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
+const getBuilder_1 = require("./getBuilder");
+const register_1 = require("../../src/register");
+const testData = __importStar(require("../resources/eth"));
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+// Hoodi ACL contract address (Networks.test.hoodi.zamaAclContractAddress)
+const ZAMA_ACL_ADDRESS = '0x6d3faf6f86e1ff9f3b0831dda920aba1cbd5bd68';
+const DELEGATE_ADDRESS = '0x1111111111111111111111111111111111111111';
+// hteth:ctest1 token contract address (from statics/erc7984Tokens.ts)
+const CTEST1_TOKEN_ADDRESS = '0x7b1d59bbcd291daa59cb6c8c5bc04de1afc4aba1';
+// hteth:cusdt token contract address (from statics/erc7984Tokens.ts)
+const CUSDT_TOKEN_ADDRESS = '0x2debbe0487ef921df4457f9e36ed05be2df1ac75';
+const WRONG_TOKEN_ADDRESS = '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef';
+const WRONG_ACL_ADDRESS = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+const FORWARDER_ADDRESS = '0x1234567890123456789012345678901234567890';
+const EXPIRY = Math.floor(Date.now() / 1000) + 365 * 86400;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Builds a root-wallet delegation tx hex (to = ACL, data = multicall).
+ */
+async function buildDelegationTxHex(aclAddress, tokenAddresses, value = '0') {
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+    txBuilder.contract(aclAddress);
+    const calldata = (0, abstract_eth_1.buildMulticallDelegationCalldata)(DELEGATE_ADDRESS, tokenAddresses, EXPIRY);
+    txBuilder.data(calldata);
+    if (value !== '0') {
+        txBuilder.value(value);
+    }
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+/**
+ * Builds a forwarder delegation tx hex (to = forwarder, data = callFromParent(ACL, 0, multicall)).
+ * This mirrors what DecryptionDelegationBuilder.build() returns when forwarderAddress is set.
+ */
+async function buildForwarderDelegationTxHex(forwarderAddress, aclAddress, tokenAddresses) {
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+    txBuilder.contract(forwarderAddress);
+    const innerCalldata = (0, abstract_eth_1.buildMulticallDelegationCalldata)(DELEGATE_ADDRESS, tokenAddresses, EXPIRY);
+    const outerCalldata = (0, abstract_eth_1.wrapInCallFromParent)(aclAddress, innerCalldata);
+    txBuilder.data(outerCalldata);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('Erc7984Token', function () {
+    let bitgo;
+    let coin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+    });
+    // -------------------------------------------------------------------------
+    describe('getTokenEnablementConfig', function () {
+        it('should return requiresTokenEnablement: true', function () {
+            const config = coin.getTokenEnablementConfig();
+            config.requiresTokenEnablement.should.equal(true);
+        });
+        it('should return supportsMultipleTokenEnablements: true', function () {
+            const config = coin.getTokenEnablementConfig();
+            config.supportsMultipleTokenEnablements.should.equal(true);
+        });
+    });
+    // -------------------------------------------------------------------------
+    describe('verifyTransaction – non-enable-token', function () {
+        it('should route to confidential transfer path when type is not enabletoken', async function () {
+            // Non-enabletoken transactions route to verifyConfidentialTransfer.
+            // Empty recipients triggers our ERC7984-specific validation error,
+            // confirming the override only intercepts the enabletoken type.
+            await coin
+                .verifyTransaction({
+                txParams: { recipients: [] },
+                txPrebuild: {},
+                wallet: {},
+            })
+                .should.be.rejectedWith(/recipients must contain at least one entry/);
+        });
+    });
+    // -------------------------------------------------------------------------
+    describe('verifyTransaction – TSS path', function () {
+        it('should verify a valid single-token delegation tx', async function () {
+            const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS]);
+            const result = await coin.verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            });
+            result.should.equal(true);
+        });
+        it('should verify a valid multi-token delegation tx', async function () {
+            const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS, CUSDT_TOKEN_ADDRESS]);
+            const result = await coin.verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }, { name: 'hteth:cusdt' }],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            });
+            result.should.equal(true);
+        });
+        it('should throw when ACL address does not match', async function () {
+            const txHex = await buildDelegationTxHex(WRONG_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS]);
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            })
+                .should.be.rejectedWith(/does not match ACL contract/);
+        });
+        it('should throw when calldata contains wrong token address', async function () {
+            const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [WRONG_TOKEN_ADDRESS]);
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            })
+                .should.be.rejectedWith(/not found in delegation calldata/);
+        });
+        it('should verify a valid forwarder delegation tx (callFromParent shape)', async function () {
+            const txHex = await buildForwarderDelegationTxHex(FORWARDER_ADDRESS, ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS]);
+            const result = await coin.verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            });
+            result.should.equal(true);
+        });
+        it('should verify a forwarder delegation tx with multiple tokens', async function () {
+            const txHex = await buildForwarderDelegationTxHex(FORWARDER_ADDRESS, ZAMA_ACL_ADDRESS, [
+                CTEST1_TOKEN_ADDRESS,
+                CUSDT_TOKEN_ADDRESS,
+            ]);
+            const result = await coin.verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }, { name: 'hteth:cusdt' }],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            });
+            result.should.equal(true);
+        });
+        it('should throw when forwarder calldata contains wrong token address', async function () {
+            const txHex = await buildForwarderDelegationTxHex(FORWARDER_ADDRESS, ZAMA_ACL_ADDRESS, [WRONG_TOKEN_ADDRESS]);
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            })
+                .should.be.rejectedWith(/not found in delegation calldata/);
+        });
+        it('should throw when calldata has unrecognised method ID', async function () {
+            // Build a tx with arbitrary calldata that is neither multicall nor callFromParent
+            const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+            txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+            txBuilder.counter(1);
+            txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+            txBuilder.contract(ZAMA_ACL_ADDRESS);
+            txBuilder.data('0xdeadbeef');
+            const tx = await txBuilder.build();
+            const txHex = tx.toBroadcastFormat();
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            })
+                .should.be.rejectedWith(/unrecognised calldata method ID/);
+        });
+        it('should throw when transaction value is not 0', async function () {
+            const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS], '1');
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            })
+                .should.be.rejectedWith(/expected transaction value 0/);
+        });
+        it('should throw when enableTokens is empty', async function () {
+            const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS]);
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [],
+                },
+                txPrebuild: { txHex },
+                wallet: {},
+                walletType: 'tss',
+            })
+                .should.be.rejectedWith(/enableTokens must be non-empty/);
+        });
+        it('should throw when txHex is missing', async function () {
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    enableTokens: [{ name: 'hteth:ctest1' }],
+                },
+                txPrebuild: {},
+                wallet: {},
+                walletType: 'tss',
+            })
+                .should.be.rejectedWith(/missing txHex/);
+        });
+    });
+    // -------------------------------------------------------------------------
+    describe('verifyTransaction – multisig path', function () {
+        it('should verify valid buildParams recipients', async function () {
+            const result = await coin.verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' }],
+                },
+                txPrebuild: {
+                    buildParams: {
+                        type: 'enabletoken',
+                        recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' }],
+                    },
+                },
+                wallet: {},
+                walletType: 'onchain',
+            });
+            result.should.equal(true);
+        });
+        it('should verify multiple token recipients', async function () {
+            const result = await coin.verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    recipients: [
+                        { tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' },
+                        { tokenName: 'hteth:cusdt', address: '0xabc', amount: '0' },
+                    ],
+                },
+                txPrebuild: {
+                    buildParams: {
+                        type: 'enabletoken',
+                        recipients: [
+                            { tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' },
+                            { tokenName: 'hteth:cusdt', address: '0xabc', amount: '0' },
+                        ],
+                    },
+                },
+                wallet: {},
+                walletType: 'onchain',
+            });
+            result.should.equal(true);
+        });
+        it('should throw when buildParams recipients have wrong tokenName', async function () {
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' }],
+                },
+                txPrebuild: {
+                    buildParams: {
+                        type: 'enabletoken',
+                        recipients: [{ tokenName: 'hteth:wrongtoken', address: '0xabc', amount: '0' }],
+                    },
+                },
+                wallet: {},
+                walletType: 'onchain',
+            })
+                .should.be.rejectedWith(/not found in buildParams recipients/);
+        });
+        it('should throw when amount is not 0', async function () {
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                    recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' }],
+                },
+                txPrebuild: {
+                    buildParams: {
+                        type: 'enabletoken',
+                        recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '100' }],
+                    },
+                },
+                wallet: {},
+                walletType: 'onchain',
+            })
+                .should.be.rejectedWith(/expected amount 0/);
+        });
+        it('should throw when recipients is missing', async function () {
+            await coin
+                .verifyTransaction({
+                txParams: {
+                    type: 'enabletoken',
+                },
+                txPrebuild: {
+                    buildParams: {},
+                },
+                wallet: {},
+                walletType: 'onchain',
+            })
+                .should.be.rejectedWith(/missing buildParams.recipients/);
+        });
+    });
+});
+// ---------------------------------------------------------------------------
+// verifyTransaction – confidential transfer (SendERC7984) tests
+// ---------------------------------------------------------------------------
+/**
+ * Build a raw signed sendMultiSig tx hex that wraps a confidentialTransfer call.
+ * The wallet contract (sendMultiSig wrapper) is `walletContractAddress`.
+ */
+async function buildConfidentialTransferTxHex(opts) {
+    const key = testData.KEYPAIR_PRV.getKeys().prv;
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '12100000' });
+    txBuilder.counter(1);
+    txBuilder.contract(opts.walletContractAddress);
+    txBuilder.type(sdk_core_1.TransactionType.SendERC7984);
+    const transferBuilder = txBuilder.transfer();
+    transferBuilder
+        .from('0x19645032c7f1533395d44a629462e751084d3e4d')
+        .to(opts.recipientAddress)
+        .tokenContractAddress(opts.tokenContractAddress)
+        .encryptedHandle(opts.encryptedHandle)
+        .inputProof(opts.inputProof)
+        .contractSequenceId(1)
+        .expirationTime(Math.floor(Date.now() / 1000) + 3600)
+        .key(key);
+    txBuilder.sign({ key: testData.PRIVATE_KEY });
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+describe('verifyTransaction – confidential transfer (SendERC7984)', function () {
+    // Wallet contract that wraps the sendMultiSig call
+    const WALLET_CONTRACT = '0x8f977e912ef500548a0c3be6ddde9899f1199b81';
+    // Recipient of the confidential transfer
+    const RECIPIENT = '0x19645032c7f1533395d44a629462e751084d3e4c';
+    // Encrypted handle: synthetic 32 bytes
+    const HANDLE = '0x' + 'ab'.repeat(32);
+    // Input proof: synthetic 50 bytes
+    const PROOF = '0x' + 'cd'.repeat(50);
+    // A different recipient to trigger mismatch
+    const WRONG_RECIPIENT = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+    // A different token contract to trigger mismatch
+    const WRONG_TOKEN = '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
+    let bitgo;
+    let coin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+    });
+    // Representative plaintext amount in base units (e.g., 1 cTEST1 = 1_000_000 units at 6 decimals)
+    const AMOUNT = '1000000';
+    it('should verify a valid confidential transfer transaction with matching amounts', async function () {
+        const txHex = await buildConfidentialTransferTxHex({
+            walletContractAddress: WALLET_CONTRACT,
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        const result = await coin.verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: { txHex, buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] } },
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should throw when no recipient info is provided in either txParams or buildParams', async function () {
+        const txHex = await buildConfidentialTransferTxHex({
+            walletContractAddress: WALLET_CONTRACT,
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: {},
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/missing expected recipient/);
+    });
+    it('should verify successfully using buildParams.recipients when txParams has no recipients', async function () {
+        const txHex = await buildConfidentialTransferTxHex({
+            walletContractAddress: WALLET_CONTRACT,
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        const result = await coin.verifyTransaction({
+            txParams: {},
+            txPrebuild: {
+                txHex,
+                buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            },
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should throw when token contract address does not match this coin', async function () {
+        const txHex = await buildConfidentialTransferTxHex({
+            walletContractAddress: WALLET_CONTRACT,
+            tokenContractAddress: WRONG_TOKEN,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/token contract address mismatch/);
+    });
+    it('should throw when recipient address does not match txParams', async function () {
+        const txHex = await buildConfidentialTransferTxHex({
+            walletContractAddress: WALLET_CONTRACT,
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: WRONG_RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/recipient address mismatch/);
+    });
+    it('should throw when calldata is not a confidential transfer', async function () {
+        const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+        txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+        txBuilder.counter(1);
+        txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+        txBuilder.contract(WALLET_CONTRACT);
+        txBuilder.data('0xdeadbeef00000000000000000000000000000000000000000000000000000000');
+        const tx = await txBuilder.build();
+        const txHex = tx.toBroadcastFormat();
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/failed to decode confidential transfer calldata/);
+    });
+    it('should throw when txParams amount does not match buildParams amount (with txHex)', async function () {
+        const txHex = await buildConfidentialTransferTxHex({
+            walletContractAddress: WALLET_CONTRACT,
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: '9999999' }] },
+            txPrebuild: {
+                txHex,
+                buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/amount mismatch/);
+    });
+    it('should throw when txParams amount is 0 (with txHex)', async function () {
+        const txHex = await buildConfidentialTransferTxHex({
+            walletContractAddress: WALLET_CONTRACT,
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: '0' }] },
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/amount must be a positive integer string/);
+    });
+    // ── First-signer (no txHex) tests ──────────────────────────────────────────
+    it('should verify valid first-signer params when no txHex is present', async function () {
+        const result = await coin.verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: {},
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should verify first-signer params when txParams and buildParams amounts match', async function () {
+        const result = await coin.verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: { buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] } },
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should throw when recipients is empty and no txHex is present', async function () {
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [] },
+            txPrebuild: {},
+            wallet: {},
+        })
+            .should.be.rejectedWith(/recipients must contain at least one entry/);
+    });
+    it('should throw when recipient address is invalid and no txHex is present', async function () {
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: 'not-an-address', amount: AMOUNT }] },
+            txPrebuild: {},
+            wallet: {},
+        })
+            .should.be.rejectedWith(/recipient address is missing or invalid/);
+    });
+    it('should throw when amount is 0 and no txHex is present', async function () {
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: '0' }] },
+            txPrebuild: {},
+            wallet: {},
+        })
+            .should.be.rejectedWith(/amount must be a positive integer string/);
+    });
+    it('should throw when amount is empty and no txHex is present', async function () {
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: '' }] },
+            txPrebuild: {},
+            wallet: {},
+        })
+            .should.be.rejectedWith(/amount must be a positive integer string/);
+    });
+    it('should throw when txParams and buildParams amounts mismatch and no txHex is present', async function () {
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: '9999999' }] },
+            txPrebuild: { buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] } },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/amount mismatch/);
+    });
+    it('should throw when txParams and buildParams recipient addresses mismatch and no txHex is present', async function () {
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: {
+                buildParams: { recipients: [{ address: WRONG_RECIPIENT, amount: AMOUNT }] },
+            },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/recipient address mismatch/);
+    });
+    it('should verify when txHex absent and buildParams has matching recipient address', async function () {
+        const result = await coin.verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: {
+                buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            },
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should verify decoded recipient against buildParams when txParams.recipients is absent', async function () {
+        const txHex = await buildConfidentialTransferTxHex({
+            walletContractAddress: WALLET_CONTRACT,
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        // No recipients in txParams — falls back to buildParams for recipient verification
+        const result = await coin.verifyTransaction({
+            txParams: {},
+            txPrebuild: {
+                txHex,
+                buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            },
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should throw when decoded recipient does not match buildParams recipient (txParams absent)', async function () {
+        const txHex = await buildConfidentialTransferTxHex({
+            walletContractAddress: WALLET_CONTRACT,
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: {},
+            txPrebuild: {
+                txHex,
+                buildParams: { recipients: [{ address: WRONG_RECIPIENT, amount: AMOUNT }] },
+            },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/recipient address mismatch/);
+    });
+});
+// ---------------------------------------------------------------------------
+// verifyTransaction – direct confidentialTransfer (hot/TSS EOA wallet) tests
+// ---------------------------------------------------------------------------
+/**
+ * Builds a raw tx hex where the EOA calls confidentialTransfer directly on the token
+ * contract (no sendMultiSig wrapper). This is the hot/TSS wallet path.
+ */
+async function buildDirectConfidentialTransferTxHex(opts) {
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+    // tx.to = token contract (EOA calls it directly)
+    txBuilder.contract(opts.tokenContractAddress);
+    // Inner calldata: confidentialTransfer(address, bytes32, bytes) — no sendMultiSig wrapper
+    const calldata = new abstract_eth_1.TransferBuilderERC7984()
+        .to(opts.recipientAddress)
+        .tokenContractAddress(opts.tokenContractAddress)
+        .encryptedHandle(opts.encryptedHandle)
+        .inputProof(opts.inputProof)
+        .build();
+    txBuilder.data(calldata);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+describe('verifyTransaction – direct confidentialTransfer (hot/TSS EOA wallet)', function () {
+    const RECIPIENT = '0x19645032c7f1533395d44a629462e751084d3e4c';
+    const HANDLE = '0x' + 'ab'.repeat(32);
+    const PROOF = '0x' + 'cd'.repeat(50);
+    const WRONG_RECIPIENT = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+    const WRONG_TOKEN = '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
+    const AMOUNT = '1000000';
+    let bitgo;
+    let coin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+    });
+    it('should verify a valid direct confidentialTransfer tx', async function () {
+        const txHex = await buildDirectConfidentialTransferTxHex({
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        const result = await coin.verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: { txHex, buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] } },
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should verify using buildParams.recipients when txParams has no recipients', async function () {
+        const txHex = await buildDirectConfidentialTransferTxHex({
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        const result = await coin.verifyTransaction({
+            txParams: {},
+            txPrebuild: {
+                txHex,
+                buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            },
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should throw when token contract address (tx.to) does not match this coin', async function () {
+        const txHex = await buildDirectConfidentialTransferTxHex({
+            tokenContractAddress: WRONG_TOKEN,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/token contract address mismatch/);
+    });
+    it('should throw when recipient address does not match txParams', async function () {
+        const txHex = await buildDirectConfidentialTransferTxHex({
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: WRONG_RECIPIENT, amount: AMOUNT }] },
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/recipient address mismatch/);
+    });
+    it('should throw when no recipient info is provided in either txParams or buildParams', async function () {
+        const txHex = await buildDirectConfidentialTransferTxHex({
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: {},
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/missing expected recipient/);
+    });
+    it('should throw when txParams amount does not match buildParams amount', async function () {
+        const txHex = await buildDirectConfidentialTransferTxHex({
+            tokenContractAddress: CTEST1_TOKEN_ADDRESS,
+            recipientAddress: RECIPIENT,
+            encryptedHandle: HANDLE,
+            inputProof: PROOF,
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { recipients: [{ address: RECIPIENT, amount: '9999999' }] },
+            txPrebuild: {
+                txHex,
+                buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },
+            },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/amount mismatch/);
+    });
+});
+// ---------------------------------------------------------------------------
+// decodeTokenAddressesFromDelegationCalldata tests
+// ---------------------------------------------------------------------------
+describe('decodeTokenAddressesFromDelegationCalldata', function () {
+    it('should decode a single-token multicall calldata', function () {
+        const calldata = (0, abstract_eth_1.buildMulticallDelegationCalldata)(DELEGATE_ADDRESS, [CTEST1_TOKEN_ADDRESS], EXPIRY);
+        const addresses = (0, abstract_eth_1.decodeTokenAddressesFromDelegationCalldata)(calldata);
+        addresses.should.deepEqual([CTEST1_TOKEN_ADDRESS.toLowerCase()]);
+    });
+    it('should decode a multi-token multicall calldata', function () {
+        const calldata = (0, abstract_eth_1.buildMulticallDelegationCalldata)(DELEGATE_ADDRESS, [CTEST1_TOKEN_ADDRESS, CUSDT_TOKEN_ADDRESS], EXPIRY);
+        const addresses = (0, abstract_eth_1.decodeTokenAddressesFromDelegationCalldata)(calldata);
+        addresses.should.deepEqual([CTEST1_TOKEN_ADDRESS.toLowerCase(), CUSDT_TOKEN_ADDRESS.toLowerCase()]);
+    });
+    it('should return addresses in lowercase', function () {
+        const mixedCase = '0x7B1D59bbCD291daA59cB6C8C5bc04De1AFC4aBA1';
+        const calldata = (0, abstract_eth_1.buildMulticallDelegationCalldata)(DELEGATE_ADDRESS, [mixedCase], EXPIRY);
+        const addresses = (0, abstract_eth_1.decodeTokenAddressesFromDelegationCalldata)(calldata);
+        addresses[0].should.equal(mixedCase.toLowerCase());
+    });
+    it('should handle callFromParent-wrapped multicall calldata', function () {
+        const inner = (0, abstract_eth_1.buildMulticallDelegationCalldata)(DELEGATE_ADDRESS, [CTEST1_TOKEN_ADDRESS, CUSDT_TOKEN_ADDRESS], EXPIRY);
+        const wrapped = (0, abstract_eth_1.wrapInCallFromParent)(ZAMA_ACL_ADDRESS, inner);
+        const addresses = (0, abstract_eth_1.decodeTokenAddressesFromDelegationCalldata)(wrapped);
+        addresses.should.deepEqual([CTEST1_TOKEN_ADDRESS.toLowerCase(), CUSDT_TOKEN_ADDRESS.toLowerCase()]);
+    });
+    it('should work with calldata missing 0x prefix', function () {
+        const calldata = (0, abstract_eth_1.buildMulticallDelegationCalldata)(DELEGATE_ADDRESS, [CTEST1_TOKEN_ADDRESS], EXPIRY);
+        const noPrefix = calldata.slice(2); // strip 0x
+        const addresses = (0, abstract_eth_1.decodeTokenAddressesFromDelegationCalldata)(noPrefix);
+        addresses.should.deepEqual([CTEST1_TOKEN_ADDRESS.toLowerCase()]);
+    });
+    it('should throw for unrecognised calldata', function () {
+        should_1.default.throws(() => (0, abstract_eth_1.decodeTokenAddressesFromDelegationCalldata)('0xdeadbeef00000000'), /Not a valid delegation calldata/);
+    });
+});
+// ---------------------------------------------------------------------------
+// verifyTransaction – confidential consolidation (FlushERC7984ForwarderToken)
+// ---------------------------------------------------------------------------
+const MULTISIG_WALLET_CONTRACT = '0x3b58684525564b38a381e46a731703ed03f32122';
+const CONSOLIDATION_FORWARDER = '0xf4bcb366bb5e34ebbee51fae5de98cc876c0146f';
+const CONSOLIDATION_BASE_ADDRESS = '0x3b58684525564b38a381e46a731703ed03f32122';
+const CONSOLIDATION_HANDLE = '0x65df136b609ab395c1a99ae46f7939c7f8b20dff4bff0000000088bb0050';
+const DUMMY_MULTISIG_SIGNATURE = '0x' + '00'.repeat(65);
+async function buildMultisigConsolidationTxHex() {
+    const flushCalldata = (0, abstract_eth_1.buildFlushERC7984ForwarderTokenCalldata)(CTEST1_TOKEN_ADDRESS, CONSOLIDATION_BASE_ADDRESS, CONSOLIDATION_HANDLE);
+    const sendData = (0, abstract_eth_1.sendMultiSigData)(CONSOLIDATION_FORWARDER, '0', flushCalldata, Math.floor(Date.now() / 1000) + 3600, 14, DUMMY_MULTISIG_SIGNATURE);
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '12100000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+    txBuilder.contract(MULTISIG_WALLET_CONTRACT);
+    txBuilder.data(sendData);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+async function buildDirectConsolidationTxHex() {
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.FlushERC7984ForwarderToken);
+    txBuilder.contract(CONSOLIDATION_FORWARDER);
+    txBuilder.forwarderAddress(CONSOLIDATION_FORWARDER);
+    txBuilder.tokenContractAddress(CTEST1_TOKEN_ADDRESS);
+    txBuilder.parentAddress(CONSOLIDATION_BASE_ADDRESS);
+    txBuilder.encryptedHandle(CONSOLIDATION_HANDLE);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+describe('verifyTransaction – confidential consolidation (FlushERC7984ForwarderToken)', function () {
+    let bitgo;
+    let coin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+    });
+    it('should verify a valid multisig consolidation tx (sendMultiSig → callFromParent → confidentialTransferNoProof)', async function () {
+        const txHex = await buildMultisigConsolidationTxHex();
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },
+        });
+        const result = await coin.verifyTransaction({
+            txParams: { type: 'consolidate' },
+            txPrebuild: {
+                consolidateId: '6a44ebc0326e1be45c1d797542c8c634',
+                txHex,
+                recipients: [{ address: CONSOLIDATION_FORWARDER, amount: '0' }],
+            },
+            wallet,
+        });
+        result.should.equal(true);
+    });
+    it('should verify a valid direct callFromParent consolidation tx (TSS shape)', async function () {
+        const txHex = await buildDirectConsolidationTxHex();
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },
+        });
+        const result = await coin.verifyTransaction({
+            txParams: { type: 'consolidate' },
+            txPrebuild: {
+                consolidateId: '6a44ebc0326e1be45c1d797542c8c634',
+                txHex,
+            },
+            wallet,
+            verification: { consolidationToBaseAddress: true },
+        });
+        result.should.equal(true);
+    });
+    it('should reject multisig consolidation when parent address does not match wallet base address', async function () {
+        const txHex = await buildMultisigConsolidationTxHex();
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { type: 'consolidate' },
+            txPrebuild: { consolidateId: 'abc123', txHex },
+            wallet,
+        })
+            .should.be.rejectedWith(/parent address mismatch/);
+    });
+    it('should verify multisig consolidation using forwarder address from txPrebuild.txInfo.recipients', async function () {
+        const txHex = await buildMultisigConsolidationTxHex();
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },
+        });
+        // No top-level recipients; forwarder comes from txInfo.recipients
+        const result = await coin.verifyTransaction({
+            txParams: { type: 'consolidate' },
+            txPrebuild: {
+                consolidateId: '6a44ebc0326e1be45c1d797542c8c634',
+                txHex,
+                txInfo: { recipients: [{ address: CONSOLIDATION_FORWARDER, amount: '0' }] },
+            },
+            wallet,
+        });
+        result.should.equal(true);
+    });
+    it('should reject multisig consolidation when txInfo.recipients forwarder address does not match tx forwarder', async function () {
+        const txHex = await buildMultisigConsolidationTxHex();
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { type: 'consolidate' },
+            txPrebuild: {
+                consolidateId: 'abc123',
+                txHex,
+                txInfo: { recipients: [{ address: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', amount: '0' }] },
+            },
+            wallet,
+        })
+            .should.be.rejectedWith(/forwarder address mismatch/);
+    });
+    // TSS MPCv2 signing path — resolveEffectiveTxParams sets type from intent.intentType ('consolidateToken'),
+    // and txPrebuild has only txHex (no consolidateId, no recipients). This was the broken path before
+    // isConsolidationTransaction was updated to recognise 'consolidateToken'.
+    it('should verify a valid direct callFromParent consolidation tx when type is consolidateToken (TSS MPCv2 signing path)', async function () {
+        const txHex = await buildDirectConsolidationTxHex();
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },
+        });
+        const result = await coin.verifyTransaction({
+            txParams: {
+                type: 'consolidateToken',
+                recipients: [{ address: CONSOLIDATION_FORWARDER, amount: '0' }],
+            },
+            txPrebuild: { txHex },
+            wallet,
+        });
+        result.should.equal(true);
+    });
+    it('should reject callFromParent consolidation with type consolidateToken when parent address does not match wallet base address', async function () {
+        const txHex = await buildDirectConsolidationTxHex();
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },
+        });
+        await coin
+            .verifyTransaction({
+            txParams: {
+                type: 'consolidateToken',
+                recipients: [{ address: CONSOLIDATION_FORWARDER, amount: '0' }],
+            },
+            txPrebuild: { txHex },
+            wallet,
+        })
+            .should.be.rejectedWith(/parent address mismatch/);
+    });
+});
+// ---------------------------------------------------------------------------
+// recover() – ERC-7984 confidential token recovery
+// ---------------------------------------------------------------------------
+describe('Erc7984Token – recover()', function () {
+    let bitgo;
+    let coin;
+    let explorerStub;
+    const WALLET_CONTRACT = '0x8f977e912ef500548a0c3be6ddde9899f1199b81';
+    const RECOVERY_DEST = '0x19645032c7f1533395d44a629462e751084d3e4c';
+    const HANDLE = '0x' + 'ab'.repeat(32);
+    const ZERO_HANDLE = '0x' + '00'.repeat(32);
+    const USER_KEY = testData.PRIVATE_KEY;
+    const BACKUP_KEY = testData.PRIVATE_KEY;
+    const WALLET_PASSPHRASE = 'test wallet passphrase';
+    /**
+     * Function selector for `isSigner(address)` on the WalletSimple contract.
+     *
+     * EVM calldata starts with the first 4 bytes of the keccak256 hash of the
+     * function signature, i.e. `keccak256("isSigner(address)")[0..4]` = `7df73e27`.
+     * The explorer stub matches on this prefix to distinguish the signer probe
+     * from other `eth_call` queries (e.g. `getNextSequenceId` = `a0b7967b`).
+     */
+    const IS_SIGNER_SELECTOR = '7df73e27';
+    /**
+     * Solidity ABI-encoded boolean `true`.
+     *
+     * A `bool` in ABI encoding occupies a full 32-byte word: 31 zero bytes then
+     * `0x01` for true (all 32 zero bytes for false). `queryIsWalletSigner` decodes
+     * the explorer response with `ethAbi.rawDecode(['bool'], ...)`, so the stub
+     * must return this exact 32-byte shape — a shorter value like `0x01` would
+     * fail to decode.
+     *
+     * Written as an expression instead of a bare hex literal because the repo's
+     * test-fixture secret scrubber flags 64-hex literals.
+     */
+    const ABI_TRUE = '0x' + '00'.repeat(31) + '01';
+    /**
+     * Solidity ABI-encoded boolean `false` — a 32-byte word of all zeros.
+     * See `ABI_TRUE` above for the encoding rationale.
+     */
+    const ABI_FALSE = '0x' + '00'.repeat(32);
+    // Encrypted keys for test (encrypt with the test passphrase)
+    let encryptedUserKey;
+    let encryptedBackupKey;
+    before(async function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+        encryptedUserKey = await bitgo.encrypt({ input: USER_KEY, password: WALLET_PASSPHRASE });
+        encryptedBackupKey = await bitgo.encrypt({ input: BACKUP_KEY, password: WALLET_PASSPHRASE });
+    });
+    beforeEach(function () {
+        explorerStub = sinon_1.default.stub(coin, 'recoveryBlockchainExplorerQuery');
+    });
+    afterEach(function () {
+        sinon_1.default.restore();
+    });
+    function mockExplorerForRecovery(handle = HANDLE) {
+        explorerStub.callsFake(async (query) => {
+            if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {
+                return { result: ABI_TRUE };
+            }
+            if (query.action === 'txlist') {
+                // getAddressNonce: return empty tx list (nonce = 0)
+                return { result: [] };
+            }
+            if (query.action === 'balance') {
+                // queryAddressBalance: return enough ETH for gas
+                return { result: '100000000000000000' }; // 0.1 ETH
+            }
+            if (query.action === 'eth_call' && query.data?.startsWith('a0b7967b')) {
+                // querySequenceId: getNextSequenceId
+                return { result: '0x0000000000000000000000000000000000000000000000000000000000000005' };
+            }
+            if (query.action === 'eth_call' && query.to === CTEST1_TOKEN_ADDRESS) {
+                // queryConfidentialBalance
+                return { result: handle };
+            }
+            throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);
+        });
+    }
+    it('should build a full balance sweep recovery transaction', async function () {
+        mockExplorerForRecovery();
+        const result = await coin.recover({
+            userKey: encryptedUserKey,
+            backupKey: encryptedBackupKey,
+            walletPassphrase: WALLET_PASSPHRASE,
+            walletContractAddress: WALLET_CONTRACT,
+            recoveryDestination: RECOVERY_DEST,
+        });
+        should_1.default.exist(result);
+        result.should.have.property('id');
+        result.should.have.property('tx');
+        result.tx.should.be.a.String();
+        result.tx.length.should.be.greaterThan(0);
+    });
+    it('should use user-provided encryptedHandle and skip auto-query', async function () {
+        const userHandle = '0x' + 'ff'.repeat(32);
+        explorerStub.callsFake(async (query) => {
+            if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {
+                return { result: ABI_TRUE };
+            }
+            if (query.action === 'txlist') {
+                return { result: [] };
+            }
+            if (query.action === 'balance') {
+                return { result: '100000000000000000' };
+            }
+            if (query.action === 'eth_call' && query.data?.startsWith('a0b7967b')) {
+                return { result: '0x0000000000000000000000000000000000000000000000000000000000000005' };
+            }
+            if (query.action === 'eth_call' && query.to === CTEST1_TOKEN_ADDRESS) {
+                throw new Error('Should not query confidentialBalanceOf when handle is provided');
+            }
+            throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);
+        });
+        const result = await coin.recover({
+            userKey: encryptedUserKey,
+            backupKey: encryptedBackupKey,
+            walletPassphrase: WALLET_PASSPHRASE,
+            walletContractAddress: WALLET_CONTRACT,
+            recoveryDestination: RECOVERY_DEST,
+            encryptedHandle: userHandle,
+        });
+        should_1.default.exist(result);
+        result.should.have.property('tx');
+    });
+    it('should still build a recovery tx even with a zero-value handle (encrypted handles are always non-zero)', async function () {
+        mockExplorerForRecovery(ZERO_HANDLE);
+        const result = await coin.recover({
+            userKey: encryptedUserKey,
+            backupKey: encryptedBackupKey,
+            walletPassphrase: WALLET_PASSPHRASE,
+            walletContractAddress: WALLET_CONTRACT,
+            recoveryDestination: RECOVERY_DEST,
+        });
+        should_1.default.exist(result);
+        result.should.have.property('tx');
+    });
+    it('should return unsigned sweep format when isUnsignedSweep is true', async function () {
+        mockExplorerForRecovery();
+        const result = await coin.recover({
+            userKey: testData.PUBLIC_KEY,
+            backupKey: testData.PUBLIC_KEY,
+            walletContractAddress: WALLET_CONTRACT,
+            recoveryDestination: RECOVERY_DEST,
+            isUnsignedSweep: true,
+        });
+        should_1.default.exist(result);
+        result.should.have.property('tx');
+        result.should.have.property('userKey');
+        result.should.have.property('backupKey');
+    });
+    it('should return KRS recovery format with backupKey and coin', async function () {
+        explorerStub.callsFake(async (query) => {
+            if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {
+                return { result: ABI_TRUE };
+            }
+            if (query.action === 'txlist') {
+                return { result: [] };
+            }
+            if (query.action === 'balance') {
+                return { result: '100000000000000000' };
+            }
+            if (query.action === 'eth_call' && query.data?.startsWith('a0b7967b')) {
+                return { result: '0x0000000000000000000000000000000000000000000000000000000000000005' };
+            }
+            if (query.action === 'eth_call' && query.to === CTEST1_TOKEN_ADDRESS) {
+                return { result: HANDLE };
+            }
+            throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);
+        });
+        const result = (await coin.recover({
+            userKey: encryptedUserKey,
+            backupKey: testData.PUBLIC_KEY,
+            walletPassphrase: WALLET_PASSPHRASE,
+            walletContractAddress: WALLET_CONTRACT,
+            recoveryDestination: RECOVERY_DEST,
+            krsProvider: 'keyternal',
+        }));
+        should_1.default.exist(result);
+        result.should.have.property('tx');
+        result.should.have.property('backupKey', testData.PUBLIC_KEY);
+        result.should.have.property('coin', 'hteth:ctest1');
+    });
+    it('should throw when backup key has insufficient gas', async function () {
+        explorerStub.callsFake(async (query) => {
+            if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {
+                return { result: ABI_TRUE };
+            }
+            if (query.action === 'txlist') {
+                return { result: [] };
+            }
+            if (query.action === 'balance') {
+                // Very low balance, not enough for 12M gas
+                return { result: '100' };
+            }
+            throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);
+        });
+        await coin
+            .recover({
+            userKey: encryptedUserKey,
+            backupKey: encryptedBackupKey,
+            walletPassphrase: WALLET_PASSPHRASE,
+            walletContractAddress: WALLET_CONTRACT,
+            recoveryDestination: RECOVERY_DEST,
+        })
+            .should.be.rejectedWith(/has balance.*Gwei/);
+    });
+    it('should throw when userKey is missing', async function () {
+        await coin
+            .recover({
+            userKey: undefined,
+            backupKey: encryptedBackupKey,
+            walletPassphrase: WALLET_PASSPHRASE,
+            walletContractAddress: WALLET_CONTRACT,
+            recoveryDestination: RECOVERY_DEST,
+        })
+            .should.be.rejectedWith(/missing userKey/);
+    });
+    it('should throw when walletContractAddress is invalid', async function () {
+        await coin
+            .recover({
+            userKey: encryptedUserKey,
+            backupKey: encryptedBackupKey,
+            walletPassphrase: WALLET_PASSPHRASE,
+            walletContractAddress: 'not-an-address',
+            recoveryDestination: RECOVERY_DEST,
+        })
+            .should.be.rejectedWith(/invalid walletContractAddress/);
+    });
+    it('should produce tx with inner calldata matching confidentialTransfer selector 0x5bebed7e', async function () {
+        mockExplorerForRecovery();
+        const result = (await coin.recover({
+            userKey: encryptedUserKey,
+            backupKey: encryptedBackupKey,
+            walletPassphrase: WALLET_PASSPHRASE,
+            walletContractAddress: WALLET_CONTRACT,
+            recoveryDestination: RECOVERY_DEST,
+        }));
+        should_1.default.exist(result.tx);
+        // The serialized tx contains the sendMultiSig calldata which wraps confidentialTransfer.
+        // The confidentialTransfer selector (5bebed7e) must appear somewhere in the serialized tx.
+        const selectorNoPrefix = abstract_eth_1.confidentialTransferNoProofMethodId.slice(2);
+        result.tx.should.containEql(selectorNoPrefix);
+    });
+    it('should throw RecoveryKeyMismatchError when a recovery key is not a wallet signer', async function () {
+        explorerStub.callsFake(async (query) => {
+            if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {
+                return { result: ABI_FALSE };
+            }
+            throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);
+        });
+        await coin
+            .recover({
+            userKey: encryptedUserKey,
+            backupKey: encryptedBackupKey,
+            walletPassphrase: WALLET_PASSPHRASE,
+            walletContractAddress: WALLET_CONTRACT,
+            recoveryDestination: RECOVERY_DEST,
+        })
+            .should.be.rejectedWith(sdk_core_1.RecoveryKeyMismatchError);
+    });
+});
+// ---------------------------------------------------------------------------
+// queryConfidentialBalance() tests
+// ---------------------------------------------------------------------------
+describe('Erc7984Token – queryConfidentialBalance()', function () {
+    let bitgo;
+    let coin;
+    let explorerStub;
+    const WALLET_ADDRESS = '0x8f977e912ef500548a0c3be6ddde9899f1199b81';
+    const HANDLE = '0x' + 'ab'.repeat(32);
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+    });
+    beforeEach(function () {
+        explorerStub = sinon_1.default.stub(coin, 'recoveryBlockchainExplorerQuery');
+    });
+    afterEach(function () {
+        sinon_1.default.restore();
+    });
+    it('should return a valid bytes32 handle from eth_call', async function () {
+        explorerStub.resolves({ result: HANDLE });
+        const result = await coin.queryConfidentialBalance(WALLET_ADDRESS);
+        result.should.equal(HANDLE);
+    });
+    it('should verify the eth_call is made to the correct token contract', async function () {
+        explorerStub.resolves({ result: HANDLE });
+        await coin.queryConfidentialBalance(WALLET_ADDRESS);
+        explorerStub.calledOnce.should.be.true();
+        const callArgs = explorerStub.firstCall.args[0];
+        callArgs.should.have.property('action', 'eth_call');
+        callArgs.should.have.property('to', CTEST1_TOKEN_ADDRESS);
+        callArgs.should.have.property('module', 'proxy');
+    });
+    it('should throw when explorer returns no result', async function () {
+        explorerStub.resolves({ result: null });
+        await coin.queryConfidentialBalance(WALLET_ADDRESS).should.be.rejectedWith(/Could not obtain confidential balance/);
+    });
+    it('should throw when response format is unexpected (not 66 chars)', async function () {
+        explorerStub.resolves({ result: '0xabcd' });
+        await coin
+            .queryConfidentialBalance(WALLET_ADDRESS)
+            .should.be.rejectedWith(/Unexpected confidentialBalanceOf response format/);
+    });
+});
+// ---------------------------------------------------------------------------
+// verifyTransaction – WrapERC7984 (shield)
+// ---------------------------------------------------------------------------
+const WRAP_BASE_ADDRESS = '0x1111111111111111111111111111111111111111';
+const WRAP_AMOUNT = '1000000';
+const WRAP_RATE = '1';
+async function buildDirectWrapTxHex(tokenAddress, recipient, amount) {
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.WrapERC7984);
+    txBuilder.contract(tokenAddress);
+    txBuilder.wrapRecipient(recipient);
+    txBuilder.wrapAmount(amount);
+    txBuilder.wrapRate(WRAP_RATE);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+async function buildMultisigWrapTxHex(tokenAddress, recipient, amount) {
+    const wrapCalldata = (0, abstract_eth_1.buildWrapCalldata)(recipient, amount, WRAP_RATE);
+    const sendData = (0, abstract_eth_1.sendMultiSigData)(tokenAddress, '0', wrapCalldata, Math.floor(Date.now() / 1000) + 3600, 14, DUMMY_MULTISIG_SIGNATURE);
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+    txBuilder.contract(MULTISIG_WALLET_CONTRACT);
+    txBuilder.data(sendData);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+describe('verifyTransaction – WrapERC7984', function () {
+    let bitgo;
+    let coin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+    });
+    it('should verify a valid direct wrap tx (TSS shape)', async function () {
+        const txHex = await buildDirectWrapTxHex(CTEST1_TOKEN_ADDRESS, WRAP_BASE_ADDRESS, WRAP_AMOUNT);
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: WRAP_BASE_ADDRESS },
+        });
+        const result = await coin.verifyTransaction({
+            txParams: {
+                type: 'wrap',
+                recipients: [{ address: WRAP_BASE_ADDRESS, amount: WRAP_AMOUNT }],
+            },
+            txPrebuild: { txHex },
+            wallet,
+        });
+        result.should.equal(true);
+    });
+    it('should verify a valid multisig wrap tx (sendMultiSig → wrap)', async function () {
+        const txHex = await buildMultisigWrapTxHex(CTEST1_TOKEN_ADDRESS, WRAP_BASE_ADDRESS, WRAP_AMOUNT);
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: WRAP_BASE_ADDRESS },
+        });
+        const result = await coin.verifyTransaction({
+            txParams: {
+                type: 'wrap',
+                recipients: [{ address: WRAP_BASE_ADDRESS, amount: WRAP_AMOUNT }],
+            },
+            txPrebuild: { txHex },
+            wallet,
+        });
+        result.should.equal(true);
+    });
+    it('should reject wrap when recipient does not match wallet base address', async function () {
+        const txHex = await buildDirectWrapTxHex(CTEST1_TOKEN_ADDRESS, WRAP_BASE_ADDRESS, WRAP_AMOUNT);
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { type: 'wrap', recipients: [{ address: WRAP_BASE_ADDRESS, amount: WRAP_AMOUNT }] },
+            txPrebuild: { txHex },
+            wallet,
+        })
+            .should.be.rejectedWith(/wrap recipient must equal wallet base address/);
+    });
+    it('should reject wrap when amount mismatches recipients', async function () {
+        const txHex = await buildDirectWrapTxHex(CTEST1_TOKEN_ADDRESS, WRAP_BASE_ADDRESS, WRAP_AMOUNT);
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: WRAP_BASE_ADDRESS },
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { type: 'wrap', recipients: [{ address: WRAP_BASE_ADDRESS, amount: '999' }] },
+            txPrebuild: { txHex },
+            wallet,
+        })
+            .should.be.rejectedWith(/amount mismatch/);
+    });
+});
+// ---------------------------------------------------------------------------
+// verifyTransaction – UnwrapERC7984 (unshield phase-1)
+// ---------------------------------------------------------------------------
+const UNWRAP_BASE_ADDRESS = '0x1111111111111111111111111111111111111111';
+const UNWRAP_ENCRYPTED_AMOUNT = '0x' + 'ab'.repeat(32);
+const UNWRAP_INPUT_PROOF = '0x' + 'cd'.repeat(64);
+async function buildDirectUnwrapTxHex(tokenAddress, from, to, encryptedAmount, inputProof) {
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.UnwrapERC7984);
+    txBuilder.contract(tokenAddress);
+    txBuilder.unwrapFrom(from);
+    txBuilder.unwrapTo(to);
+    txBuilder.unwrapEncryptedAmount(encryptedAmount);
+    txBuilder.unwrapInputProof(inputProof);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+async function buildMultisigUnwrapTxHex(tokenAddress, from, to, encryptedAmount, inputProof) {
+    const unwrapCalldata = (0, abstract_eth_1.buildUnwrapCalldata)(from, to, encryptedAmount, inputProof);
+    const sendData = (0, abstract_eth_1.sendMultiSigData)(tokenAddress, '0', unwrapCalldata, Math.floor(Date.now() / 1000) + 3600, 14, DUMMY_MULTISIG_SIGNATURE);
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+    txBuilder.contract(MULTISIG_WALLET_CONTRACT);
+    txBuilder.data(sendData);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+describe('verifyTransaction – UnwrapERC7984', function () {
+    let bitgo;
+    let coin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+    });
+    it('should verify a valid direct unwrap tx (TSS shape)', async function () {
+        const txHex = await buildDirectUnwrapTxHex(CTEST1_TOKEN_ADDRESS, UNWRAP_BASE_ADDRESS, UNWRAP_BASE_ADDRESS, UNWRAP_ENCRYPTED_AMOUNT, UNWRAP_INPUT_PROOF);
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: UNWRAP_BASE_ADDRESS },
+        });
+        const result = await coin.verifyTransaction({
+            txParams: { type: 'unwrap' },
+            txPrebuild: { txHex },
+            wallet,
+        });
+        result.should.equal(true);
+    });
+    it('should verify a valid multisig unwrap tx (sendMultiSig → unwrap)', async function () {
+        const txHex = await buildMultisigUnwrapTxHex(CTEST1_TOKEN_ADDRESS, UNWRAP_BASE_ADDRESS, UNWRAP_BASE_ADDRESS, UNWRAP_ENCRYPTED_AMOUNT, UNWRAP_INPUT_PROOF);
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: UNWRAP_BASE_ADDRESS },
+        });
+        const result = await coin.verifyTransaction({
+            txParams: { type: 'unwrap' },
+            txPrebuild: { txHex },
+            wallet,
+        });
+        result.should.equal(true);
+    });
+    it('should reject unwrap when from does not match wallet base address', async function () {
+        const txHex = await buildDirectUnwrapTxHex(CTEST1_TOKEN_ADDRESS, UNWRAP_BASE_ADDRESS, UNWRAP_BASE_ADDRESS, UNWRAP_ENCRYPTED_AMOUNT, UNWRAP_INPUT_PROOF);
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { type: 'unwrap' },
+            txPrebuild: { txHex },
+            wallet,
+        })
+            .should.be.rejectedWith(/unwrap from must equal wallet base address/);
+    });
+    it('should reject unwrap when to differs from from (non-self-directed)', async function () {
+        const other = '0x2222222222222222222222222222222222222222';
+        const txHex = await buildDirectUnwrapTxHex(CTEST1_TOKEN_ADDRESS, UNWRAP_BASE_ADDRESS, other, UNWRAP_ENCRYPTED_AMOUNT, UNWRAP_INPUT_PROOF);
+        const wallet = new sdk_core_1.Wallet(bitgo, coin, {
+            coinSpecific: { baseAddress: UNWRAP_BASE_ADDRESS },
+        });
+        await coin
+            .verifyTransaction({
+            txParams: { type: 'unwrap' },
+            txPrebuild: { txHex },
+            wallet,
+        })
+            .should.be.rejectedWith(/unwrap to must equal wallet base address/);
+    });
+});
+// ---------------------------------------------------------------------------
+// verifyTransaction – FinalizeUnwrapERC7984 (unshield phase-2)
+// ---------------------------------------------------------------------------
+const FINALIZE_REQUEST_ID = '0x' + '11'.repeat(32);
+const FINALIZE_CLEARTEXT_AMOUNT = '1000000';
+const FINALIZE_DECRYPTION_PROOF = '0x' + 'ee'.repeat(64);
+async function buildDirectFinalizeUnwrapTxHex(tokenAddress, requestId, cleartextAmount, decryptionProof) {
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.FinalizeUnwrapERC7984);
+    txBuilder.contract(tokenAddress);
+    txBuilder.finalizeUnwrapRequestId(requestId);
+    txBuilder.finalizeUnwrapCleartextAmount(cleartextAmount);
+    txBuilder.finalizeUnwrapDecryptionProof(decryptionProof);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+async function buildMultisigFinalizeUnwrapTxHex(tokenAddress, requestId, cleartextAmount, decryptionProof) {
+    const finalizeCalldata = (0, abstract_eth_1.buildFinalizeUnwrapCalldata)(requestId, cleartextAmount, decryptionProof);
+    const sendData = (0, abstract_eth_1.sendMultiSigData)(tokenAddress, '0', finalizeCalldata, Math.floor(Date.now() / 1000) + 3600, 14, DUMMY_MULTISIG_SIGNATURE);
+    const txBuilder = (0, getBuilder_1.getBuilder)('hteth');
+    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });
+    txBuilder.counter(1);
+    txBuilder.type(sdk_core_1.TransactionType.ContractCall);
+    txBuilder.contract(MULTISIG_WALLET_CONTRACT);
+    txBuilder.data(sendData);
+    const tx = await txBuilder.build();
+    return tx.toBroadcastFormat();
+}
+describe('verifyTransaction – FinalizeUnwrapERC7984', function () {
+    let bitgo;
+    let coin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+    });
+    it('should verify a valid direct finalizeUnwrap tx (TSS shape)', async function () {
+        const txHex = await buildDirectFinalizeUnwrapTxHex(CTEST1_TOKEN_ADDRESS, FINALIZE_REQUEST_ID, FINALIZE_CLEARTEXT_AMOUNT, FINALIZE_DECRYPTION_PROOF);
+        const result = await coin.verifyTransaction({
+            txParams: {
+                type: 'finalizeUnwrap',
+                recipients: [{ address: UNWRAP_BASE_ADDRESS, amount: FINALIZE_CLEARTEXT_AMOUNT }],
+            },
+            txPrebuild: { txHex },
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should verify a valid multisig finalizeUnwrap tx (sendMultiSig → finalizeUnwrap)', async function () {
+        const txHex = await buildMultisigFinalizeUnwrapTxHex(CTEST1_TOKEN_ADDRESS, FINALIZE_REQUEST_ID, FINALIZE_CLEARTEXT_AMOUNT, FINALIZE_DECRYPTION_PROOF);
+        const result = await coin.verifyTransaction({
+            txParams: {
+                type: 'finalizeUnwrap',
+                recipients: [{ address: UNWRAP_BASE_ADDRESS, amount: FINALIZE_CLEARTEXT_AMOUNT }],
+            },
+            txPrebuild: { txHex },
+            wallet: {},
+        });
+        result.should.equal(true);
+    });
+    it('should reject finalizeUnwrap when amount mismatches recipients', async function () {
+        const txHex = await buildDirectFinalizeUnwrapTxHex(CTEST1_TOKEN_ADDRESS, FINALIZE_REQUEST_ID, FINALIZE_CLEARTEXT_AMOUNT, FINALIZE_DECRYPTION_PROOF);
+        await coin
+            .verifyTransaction({
+            txParams: {
+                type: 'finalizeUnwrap',
+                recipients: [{ address: UNWRAP_BASE_ADDRESS, amount: '999' }],
+            },
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/amount mismatch/);
+    });
+    it('should reject finalizeUnwrap when wrapper address mismatches token', async function () {
+        const wrongWrapper = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
+        const txHex = await buildDirectFinalizeUnwrapTxHex(wrongWrapper, FINALIZE_REQUEST_ID, FINALIZE_CLEARTEXT_AMOUNT, FINALIZE_DECRYPTION_PROOF);
+        await coin
+            .verifyTransaction({
+            txParams: { type: 'finalizeUnwrap' },
+            txPrebuild: { txHex },
+            wallet: {},
+        })
+            .should.be.rejectedWith(/wrapper address mismatch/);
+    });
+});
+// ---------------------------------------------------------------------------
+// setGasLimit() override tests
+// ---------------------------------------------------------------------------
+describe('Erc7984Token – setGasLimit()', function () {
+    let bitgo;
+    let coin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.initializeTestVars();
+        (0, register_1.register)(bitgo);
+        coin = bitgo.coin('hteth:ctest1');
+    });
+    it('should return 800000 as default gas limit', function () {
+        const gasLimit = coin.setGasLimit();
+        gasLimit.should.equal(800000);
+    });
+    it('should accept user-provided gas limit', function () {
+        const gasLimit = coin.setGasLimit(1000000);
+        gasLimit.should.equal(1000000);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"erc7984Token.js","sourceRoot":"","sources":["../../../test/unit/erc7984Token.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unit tests for Erc7984Token.\n *\n * Covers:\n *   - getTokenEnablementConfig\n *   - verifyTransaction (TSS and multisig paths)\n *   - verifyTransaction (confidential transfer / SendERC7984 path)\n *   - decodeTokenAddressesFromDelegationCalldata (round-trip and forwarder-wrapped)\n *   - recover() (ERC-7984 confidential token recovery)\n *   - queryConfidentialBalance()\n */\nimport should from 'should';\nimport sinon from 'sinon';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { RecoveryKeyMismatchError, TransactionType, Wallet } from '@bitgo-beta/sdk-core';\nimport {\n  buildMulticallDelegationCalldata,\n  buildFlushERC7984ForwarderTokenCalldata,\n  buildWrapCalldata,\n  buildUnwrapCalldata,\n  buildFinalizeUnwrapCalldata,\n  sendMultiSigData,\n  wrapInCallFromParent,\n  decodeTokenAddressesFromDelegationCalldata,\n  TransferBuilderERC7984,\n  confidentialTransferNoProofMethodId,\n} from '@bitgo-beta/abstract-eth';\nimport { Erc7984Token } from '../../src/erc7984Token';\nimport { TransactionBuilder } from '../../src/lib';\nimport { getBuilder } from './getBuilder';\nimport { register } from '../../src/register';\nimport * as testData from '../resources/eth';\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\n// Hoodi ACL contract address (Networks.test.hoodi.zamaAclContractAddress)\nconst ZAMA_ACL_ADDRESS = '0x6d3faf6f86e1ff9f3b0831dda920aba1cbd5bd68';\nconst DELEGATE_ADDRESS = '0x1111111111111111111111111111111111111111';\n\n// hteth:ctest1 token contract address (from statics/erc7984Tokens.ts)\nconst CTEST1_TOKEN_ADDRESS = '0x7b1d59bbcd291daa59cb6c8c5bc04de1afc4aba1';\n// hteth:cusdt token contract address (from statics/erc7984Tokens.ts)\nconst CUSDT_TOKEN_ADDRESS = '0x2debbe0487ef921df4457f9e36ed05be2df1ac75';\n\nconst WRONG_TOKEN_ADDRESS = '0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef';\nconst WRONG_ACL_ADDRESS = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';\nconst FORWARDER_ADDRESS = '0x1234567890123456789012345678901234567890';\n\nconst EXPIRY = Math.floor(Date.now() / 1000) + 365 * 86400;\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Builds a root-wallet delegation tx hex (to = ACL, data = multicall).\n */\nasync function buildDelegationTxHex(aclAddress: string, tokenAddresses: string[], value = '0'): Promise<string> {\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.ContractCall);\n  txBuilder.contract(aclAddress);\n  const calldata = buildMulticallDelegationCalldata(DELEGATE_ADDRESS, tokenAddresses, EXPIRY);\n  txBuilder.data(calldata);\n  if (value !== '0') {\n    txBuilder.value(value);\n  }\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\n/**\n * Builds a forwarder delegation tx hex (to = forwarder, data = callFromParent(ACL, 0, multicall)).\n * This mirrors what DecryptionDelegationBuilder.build() returns when forwarderAddress is set.\n */\nasync function buildForwarderDelegationTxHex(\n  forwarderAddress: string,\n  aclAddress: string,\n  tokenAddresses: string[]\n): Promise<string> {\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.ContractCall);\n  txBuilder.contract(forwarderAddress);\n  const innerCalldata = buildMulticallDelegationCalldata(DELEGATE_ADDRESS, tokenAddresses, EXPIRY);\n  const outerCalldata = wrapInCallFromParent(aclAddress, innerCalldata);\n  txBuilder.data(outerCalldata);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\n// ---------------------------------------------------------------------------\n// Tests\n// ---------------------------------------------------------------------------\n\ndescribe('Erc7984Token', function () {\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n  });\n\n  // -------------------------------------------------------------------------\n  describe('getTokenEnablementConfig', function () {\n    it('should return requiresTokenEnablement: true', function () {\n      const config = coin.getTokenEnablementConfig();\n      config.requiresTokenEnablement.should.equal(true);\n    });\n\n    it('should return supportsMultipleTokenEnablements: true', function () {\n      const config = coin.getTokenEnablementConfig();\n      config.supportsMultipleTokenEnablements.should.equal(true);\n    });\n  });\n\n  // -------------------------------------------------------------------------\n  describe('verifyTransaction – non-enable-token', function () {\n    it('should route to confidential transfer path when type is not enabletoken', async function () {\n      // Non-enabletoken transactions route to verifyConfidentialTransfer.\n      // Empty recipients triggers our ERC7984-specific validation error,\n      // confirming the override only intercepts the enabletoken type.\n      await coin\n        .verifyTransaction({\n          txParams: { recipients: [] },\n          txPrebuild: {} as any,\n          wallet: {} as any,\n        })\n        .should.be.rejectedWith(/recipients must contain at least one entry/);\n    });\n  });\n\n  // -------------------------------------------------------------------------\n  describe('verifyTransaction – TSS path', function () {\n    it('should verify a valid single-token delegation tx', async function () {\n      const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS]);\n      const result = await coin.verifyTransaction({\n        txParams: {\n          type: 'enabletoken',\n          enableTokens: [{ name: 'hteth:ctest1' }],\n        },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n        walletType: 'tss',\n      });\n      result.should.equal(true);\n    });\n\n    it('should verify a valid multi-token delegation tx', async function () {\n      const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS, CUSDT_TOKEN_ADDRESS]);\n      const result = await coin.verifyTransaction({\n        txParams: {\n          type: 'enabletoken',\n          enableTokens: [{ name: 'hteth:ctest1' }, { name: 'hteth:cusdt' }],\n        },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n        walletType: 'tss',\n      });\n      result.should.equal(true);\n    });\n\n    it('should throw when ACL address does not match', async function () {\n      const txHex = await buildDelegationTxHex(WRONG_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS]);\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'hteth:ctest1' }],\n          },\n          txPrebuild: { txHex } as any,\n          wallet: {} as any,\n          walletType: 'tss',\n        })\n        .should.be.rejectedWith(/does not match ACL contract/);\n    });\n\n    it('should throw when calldata contains wrong token address', async function () {\n      const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [WRONG_TOKEN_ADDRESS]);\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'hteth:ctest1' }],\n          },\n          txPrebuild: { txHex } as any,\n          wallet: {} as any,\n          walletType: 'tss',\n        })\n        .should.be.rejectedWith(/not found in delegation calldata/);\n    });\n\n    it('should verify a valid forwarder delegation tx (callFromParent shape)', async function () {\n      const txHex = await buildForwarderDelegationTxHex(FORWARDER_ADDRESS, ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS]);\n      const result = await coin.verifyTransaction({\n        txParams: {\n          type: 'enabletoken',\n          enableTokens: [{ name: 'hteth:ctest1' }],\n        },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n        walletType: 'tss',\n      });\n      result.should.equal(true);\n    });\n\n    it('should verify a forwarder delegation tx with multiple tokens', async function () {\n      const txHex = await buildForwarderDelegationTxHex(FORWARDER_ADDRESS, ZAMA_ACL_ADDRESS, [\n        CTEST1_TOKEN_ADDRESS,\n        CUSDT_TOKEN_ADDRESS,\n      ]);\n      const result = await coin.verifyTransaction({\n        txParams: {\n          type: 'enabletoken',\n          enableTokens: [{ name: 'hteth:ctest1' }, { name: 'hteth:cusdt' }],\n        },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n        walletType: 'tss',\n      });\n      result.should.equal(true);\n    });\n\n    it('should throw when forwarder calldata contains wrong token address', async function () {\n      const txHex = await buildForwarderDelegationTxHex(FORWARDER_ADDRESS, ZAMA_ACL_ADDRESS, [WRONG_TOKEN_ADDRESS]);\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'hteth:ctest1' }],\n          },\n          txPrebuild: { txHex } as any,\n          wallet: {} as any,\n          walletType: 'tss',\n        })\n        .should.be.rejectedWith(/not found in delegation calldata/);\n    });\n\n    it('should throw when calldata has unrecognised method ID', async function () {\n      // Build a tx with arbitrary calldata that is neither multicall nor callFromParent\n      const txBuilder = getBuilder('hteth') as TransactionBuilder;\n      txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n      txBuilder.counter(1);\n      txBuilder.type(TransactionType.ContractCall);\n      txBuilder.contract(ZAMA_ACL_ADDRESS);\n      txBuilder.data('0xdeadbeef');\n      const tx = await txBuilder.build();\n      const txHex = tx.toBroadcastFormat();\n\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'hteth:ctest1' }],\n          },\n          txPrebuild: { txHex } as any,\n          wallet: {} as any,\n          walletType: 'tss',\n        })\n        .should.be.rejectedWith(/unrecognised calldata method ID/);\n    });\n\n    it('should throw when transaction value is not 0', async function () {\n      const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS], '1');\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'hteth:ctest1' }],\n          },\n          txPrebuild: { txHex } as any,\n          wallet: {} as any,\n          walletType: 'tss',\n        })\n        .should.be.rejectedWith(/expected transaction value 0/);\n    });\n\n    it('should throw when enableTokens is empty', async function () {\n      const txHex = await buildDelegationTxHex(ZAMA_ACL_ADDRESS, [CTEST1_TOKEN_ADDRESS]);\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [],\n          },\n          txPrebuild: { txHex } as any,\n          wallet: {} as any,\n          walletType: 'tss',\n        })\n        .should.be.rejectedWith(/enableTokens must be non-empty/);\n    });\n\n    it('should throw when txHex is missing', async function () {\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n            enableTokens: [{ name: 'hteth:ctest1' }],\n          },\n          txPrebuild: {} as any,\n          wallet: {} as any,\n          walletType: 'tss',\n        })\n        .should.be.rejectedWith(/missing txHex/);\n    });\n  });\n\n  // -------------------------------------------------------------------------\n  describe('verifyTransaction – multisig path', function () {\n    it('should verify valid buildParams recipients', async function () {\n      const result = await coin.verifyTransaction({\n        txParams: {\n          type: 'enabletoken',\n          recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' }] as any,\n        },\n        txPrebuild: {\n          buildParams: {\n            type: 'enabletoken',\n            recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' }],\n          },\n        } as any,\n        wallet: {} as any,\n        walletType: 'onchain',\n      });\n      result.should.equal(true);\n    });\n\n    it('should verify multiple token recipients', async function () {\n      const result = await coin.verifyTransaction({\n        txParams: {\n          type: 'enabletoken',\n          recipients: [\n            { tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' },\n            { tokenName: 'hteth:cusdt', address: '0xabc', amount: '0' },\n          ] as any,\n        },\n        txPrebuild: {\n          buildParams: {\n            type: 'enabletoken',\n            recipients: [\n              { tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' },\n              { tokenName: 'hteth:cusdt', address: '0xabc', amount: '0' },\n            ],\n          },\n        } as any,\n        wallet: {} as any,\n        walletType: 'onchain',\n      });\n      result.should.equal(true);\n    });\n\n    it('should throw when buildParams recipients have wrong tokenName', async function () {\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n            recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' }] as any,\n          },\n          txPrebuild: {\n            buildParams: {\n              type: 'enabletoken',\n              recipients: [{ tokenName: 'hteth:wrongtoken', address: '0xabc', amount: '0' }],\n            },\n          } as any,\n          wallet: {} as any,\n          walletType: 'onchain',\n        })\n        .should.be.rejectedWith(/not found in buildParams recipients/);\n    });\n\n    it('should throw when amount is not 0', async function () {\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n            recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '0' }] as any,\n          },\n          txPrebuild: {\n            buildParams: {\n              type: 'enabletoken',\n              recipients: [{ tokenName: 'hteth:ctest1', address: '0xabc', amount: '100' }],\n            },\n          } as any,\n          wallet: {} as any,\n          walletType: 'onchain',\n        })\n        .should.be.rejectedWith(/expected amount 0/);\n    });\n\n    it('should throw when recipients is missing', async function () {\n      await coin\n        .verifyTransaction({\n          txParams: {\n            type: 'enabletoken',\n          },\n          txPrebuild: {\n            buildParams: {},\n          } as any,\n          wallet: {} as any,\n          walletType: 'onchain',\n        })\n        .should.be.rejectedWith(/missing buildParams.recipients/);\n    });\n  });\n});\n\n// ---------------------------------------------------------------------------\n// verifyTransaction – confidential transfer (SendERC7984) tests\n// ---------------------------------------------------------------------------\n\n/**\n * Build a raw signed sendMultiSig tx hex that wraps a confidentialTransfer call.\n * The wallet contract (sendMultiSig wrapper) is `walletContractAddress`.\n */\nasync function buildConfidentialTransferTxHex(opts: {\n  walletContractAddress: string;\n  tokenContractAddress: string;\n  recipientAddress: string;\n  encryptedHandle: string;\n  inputProof: string;\n}): Promise<string> {\n  const key = testData.KEYPAIR_PRV.getKeys().prv as string;\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '12100000' });\n  txBuilder.counter(1);\n  txBuilder.contract(opts.walletContractAddress);\n  txBuilder.type(TransactionType.SendERC7984);\n\n  const transferBuilder = txBuilder.transfer() as TransferBuilderERC7984;\n  transferBuilder\n    .from('0x19645032c7f1533395d44a629462e751084d3e4d')\n    .to(opts.recipientAddress)\n    .tokenContractAddress(opts.tokenContractAddress)\n    .encryptedHandle(opts.encryptedHandle)\n    .inputProof(opts.inputProof)\n    .contractSequenceId(1)\n    .expirationTime(Math.floor(Date.now() / 1000) + 3600)\n    .key(key);\n\n  txBuilder.sign({ key: testData.PRIVATE_KEY });\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\ndescribe('verifyTransaction – confidential transfer (SendERC7984)', function () {\n  // Wallet contract that wraps the sendMultiSig call\n  const WALLET_CONTRACT = '0x8f977e912ef500548a0c3be6ddde9899f1199b81';\n  // Recipient of the confidential transfer\n  const RECIPIENT = '0x19645032c7f1533395d44a629462e751084d3e4c';\n  // Encrypted handle: synthetic 32 bytes\n  const HANDLE = '0x' + 'ab'.repeat(32);\n  // Input proof: synthetic 50 bytes\n  const PROOF = '0x' + 'cd'.repeat(50);\n  // A different recipient to trigger mismatch\n  const WRONG_RECIPIENT = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';\n  // A different token contract to trigger mismatch\n  const WRONG_TOKEN = '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';\n\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n  });\n\n  // Representative plaintext amount in base units (e.g., 1 cTEST1 = 1_000_000 units at 6 decimals)\n  const AMOUNT = '1000000';\n\n  it('should verify a valid confidential transfer transaction with matching amounts', async function () {\n    const txHex = await buildConfidentialTransferTxHex({\n      walletContractAddress: WALLET_CONTRACT,\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n      txPrebuild: { txHex, buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] } } as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should throw when no recipient info is provided in either txParams or buildParams', async function () {\n    const txHex = await buildConfidentialTransferTxHex({\n      walletContractAddress: WALLET_CONTRACT,\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: {},\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/missing expected recipient/);\n  });\n\n  it('should verify successfully using buildParams.recipients when txParams has no recipients', async function () {\n    const txHex = await buildConfidentialTransferTxHex({\n      walletContractAddress: WALLET_CONTRACT,\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: {},\n      txPrebuild: {\n        txHex,\n        buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n      } as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should throw when token contract address does not match this coin', async function () {\n    const txHex = await buildConfidentialTransferTxHex({\n      walletContractAddress: WALLET_CONTRACT,\n      tokenContractAddress: WRONG_TOKEN,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/token contract address mismatch/);\n  });\n\n  it('should throw when recipient address does not match txParams', async function () {\n    const txHex = await buildConfidentialTransferTxHex({\n      walletContractAddress: WALLET_CONTRACT,\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: WRONG_RECIPIENT, amount: AMOUNT }] },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/recipient address mismatch/);\n  });\n\n  it('should throw when calldata is not a confidential transfer', async function () {\n    const txBuilder = getBuilder('hteth') as TransactionBuilder;\n    txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n    txBuilder.counter(1);\n    txBuilder.type(TransactionType.ContractCall);\n    txBuilder.contract(WALLET_CONTRACT);\n    txBuilder.data('0xdeadbeef00000000000000000000000000000000000000000000000000000000');\n    const tx = await txBuilder.build();\n    const txHex = tx.toBroadcastFormat();\n\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/failed to decode confidential transfer calldata/);\n  });\n\n  it('should throw when txParams amount does not match buildParams amount (with txHex)', async function () {\n    const txHex = await buildConfidentialTransferTxHex({\n      walletContractAddress: WALLET_CONTRACT,\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: '9999999' }] },\n        txPrebuild: {\n          txHex,\n          buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n        } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/amount mismatch/);\n  });\n\n  it('should throw when txParams amount is 0 (with txHex)', async function () {\n    const txHex = await buildConfidentialTransferTxHex({\n      walletContractAddress: WALLET_CONTRACT,\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: '0' }] },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/amount must be a positive integer string/);\n  });\n\n  // ── First-signer (no txHex) tests ──────────────────────────────────────────\n\n  it('should verify valid first-signer params when no txHex is present', async function () {\n    const result = await coin.verifyTransaction({\n      txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n      txPrebuild: {} as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should verify first-signer params when txParams and buildParams amounts match', async function () {\n    const result = await coin.verifyTransaction({\n      txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n      txPrebuild: { buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] } } as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should throw when recipients is empty and no txHex is present', async function () {\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [] },\n        txPrebuild: {} as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/recipients must contain at least one entry/);\n  });\n\n  it('should throw when recipient address is invalid and no txHex is present', async function () {\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: 'not-an-address', amount: AMOUNT }] },\n        txPrebuild: {} as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/recipient address is missing or invalid/);\n  });\n\n  it('should throw when amount is 0 and no txHex is present', async function () {\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: '0' }] },\n        txPrebuild: {} as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/amount must be a positive integer string/);\n  });\n\n  it('should throw when amount is empty and no txHex is present', async function () {\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: '' }] },\n        txPrebuild: {} as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/amount must be a positive integer string/);\n  });\n\n  it('should throw when txParams and buildParams amounts mismatch and no txHex is present', async function () {\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: '9999999' }] },\n        txPrebuild: { buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] } } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/amount mismatch/);\n  });\n\n  it('should throw when txParams and buildParams recipient addresses mismatch and no txHex is present', async function () {\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n        txPrebuild: {\n          buildParams: { recipients: [{ address: WRONG_RECIPIENT, amount: AMOUNT }] },\n        } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/recipient address mismatch/);\n  });\n\n  it('should verify when txHex absent and buildParams has matching recipient address', async function () {\n    const result = await coin.verifyTransaction({\n      txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n      txPrebuild: {\n        buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n      } as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should verify decoded recipient against buildParams when txParams.recipients is absent', async function () {\n    const txHex = await buildConfidentialTransferTxHex({\n      walletContractAddress: WALLET_CONTRACT,\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n\n    // No recipients in txParams — falls back to buildParams for recipient verification\n    const result = await coin.verifyTransaction({\n      txParams: {},\n      txPrebuild: {\n        txHex,\n        buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n      } as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should throw when decoded recipient does not match buildParams recipient (txParams absent)', async function () {\n    const txHex = await buildConfidentialTransferTxHex({\n      walletContractAddress: WALLET_CONTRACT,\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: {},\n        txPrebuild: {\n          txHex,\n          buildParams: { recipients: [{ address: WRONG_RECIPIENT, amount: AMOUNT }] },\n        } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/recipient address mismatch/);\n  });\n});\n\n// ---------------------------------------------------------------------------\n// verifyTransaction – direct confidentialTransfer (hot/TSS EOA wallet) tests\n// ---------------------------------------------------------------------------\n\n/**\n * Builds a raw tx hex where the EOA calls confidentialTransfer directly on the token\n * contract (no sendMultiSig wrapper). This is the hot/TSS wallet path.\n */\nasync function buildDirectConfidentialTransferTxHex(opts: {\n  tokenContractAddress: string;\n  recipientAddress: string;\n  encryptedHandle: string;\n  inputProof: string;\n}): Promise<string> {\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.ContractCall);\n  // tx.to = token contract (EOA calls it directly)\n  txBuilder.contract(opts.tokenContractAddress);\n  // Inner calldata: confidentialTransfer(address, bytes32, bytes) — no sendMultiSig wrapper\n  const calldata = new TransferBuilderERC7984()\n    .to(opts.recipientAddress)\n    .tokenContractAddress(opts.tokenContractAddress)\n    .encryptedHandle(opts.encryptedHandle)\n    .inputProof(opts.inputProof)\n    .build();\n  txBuilder.data(calldata);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\ndescribe('verifyTransaction – direct confidentialTransfer (hot/TSS EOA wallet)', function () {\n  const RECIPIENT = '0x19645032c7f1533395d44a629462e751084d3e4c';\n  const HANDLE = '0x' + 'ab'.repeat(32);\n  const PROOF = '0x' + 'cd'.repeat(50);\n  const WRONG_RECIPIENT = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';\n  const WRONG_TOKEN = '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';\n  const AMOUNT = '1000000';\n\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n  });\n\n  it('should verify a valid direct confidentialTransfer tx', async function () {\n    const txHex = await buildDirectConfidentialTransferTxHex({\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n    const result = await coin.verifyTransaction({\n      txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n      txPrebuild: { txHex, buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] } } as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should verify using buildParams.recipients when txParams has no recipients', async function () {\n    const txHex = await buildDirectConfidentialTransferTxHex({\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n    const result = await coin.verifyTransaction({\n      txParams: {},\n      txPrebuild: {\n        txHex,\n        buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n      } as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should throw when token contract address (tx.to) does not match this coin', async function () {\n    const txHex = await buildDirectConfidentialTransferTxHex({\n      tokenContractAddress: WRONG_TOKEN,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/token contract address mismatch/);\n  });\n\n  it('should throw when recipient address does not match txParams', async function () {\n    const txHex = await buildDirectConfidentialTransferTxHex({\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: WRONG_RECIPIENT, amount: AMOUNT }] },\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/recipient address mismatch/);\n  });\n\n  it('should throw when no recipient info is provided in either txParams or buildParams', async function () {\n    const txHex = await buildDirectConfidentialTransferTxHex({\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n    await coin\n      .verifyTransaction({\n        txParams: {},\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/missing expected recipient/);\n  });\n\n  it('should throw when txParams amount does not match buildParams amount', async function () {\n    const txHex = await buildDirectConfidentialTransferTxHex({\n      tokenContractAddress: CTEST1_TOKEN_ADDRESS,\n      recipientAddress: RECIPIENT,\n      encryptedHandle: HANDLE,\n      inputProof: PROOF,\n    });\n    await coin\n      .verifyTransaction({\n        txParams: { recipients: [{ address: RECIPIENT, amount: '9999999' }] },\n        txPrebuild: {\n          txHex,\n          buildParams: { recipients: [{ address: RECIPIENT, amount: AMOUNT }] },\n        } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/amount mismatch/);\n  });\n});\n\n// ---------------------------------------------------------------------------\n// decodeTokenAddressesFromDelegationCalldata tests\n// ---------------------------------------------------------------------------\n\ndescribe('decodeTokenAddressesFromDelegationCalldata', function () {\n  it('should decode a single-token multicall calldata', function () {\n    const calldata = buildMulticallDelegationCalldata(DELEGATE_ADDRESS, [CTEST1_TOKEN_ADDRESS], EXPIRY);\n    const addresses = decodeTokenAddressesFromDelegationCalldata(calldata);\n    addresses.should.deepEqual([CTEST1_TOKEN_ADDRESS.toLowerCase()]);\n  });\n\n  it('should decode a multi-token multicall calldata', function () {\n    const calldata = buildMulticallDelegationCalldata(\n      DELEGATE_ADDRESS,\n      [CTEST1_TOKEN_ADDRESS, CUSDT_TOKEN_ADDRESS],\n      EXPIRY\n    );\n    const addresses = decodeTokenAddressesFromDelegationCalldata(calldata);\n    addresses.should.deepEqual([CTEST1_TOKEN_ADDRESS.toLowerCase(), CUSDT_TOKEN_ADDRESS.toLowerCase()]);\n  });\n\n  it('should return addresses in lowercase', function () {\n    const mixedCase = '0x7B1D59bbCD291daA59cB6C8C5bc04De1AFC4aBA1';\n    const calldata = buildMulticallDelegationCalldata(DELEGATE_ADDRESS, [mixedCase], EXPIRY);\n    const addresses = decodeTokenAddressesFromDelegationCalldata(calldata);\n    addresses[0].should.equal(mixedCase.toLowerCase());\n  });\n\n  it('should handle callFromParent-wrapped multicall calldata', function () {\n    const inner = buildMulticallDelegationCalldata(\n      DELEGATE_ADDRESS,\n      [CTEST1_TOKEN_ADDRESS, CUSDT_TOKEN_ADDRESS],\n      EXPIRY\n    );\n    const wrapped = wrapInCallFromParent(ZAMA_ACL_ADDRESS, inner);\n    const addresses = decodeTokenAddressesFromDelegationCalldata(wrapped);\n    addresses.should.deepEqual([CTEST1_TOKEN_ADDRESS.toLowerCase(), CUSDT_TOKEN_ADDRESS.toLowerCase()]);\n  });\n\n  it('should work with calldata missing 0x prefix', function () {\n    const calldata = buildMulticallDelegationCalldata(DELEGATE_ADDRESS, [CTEST1_TOKEN_ADDRESS], EXPIRY);\n    const noPrefix = calldata.slice(2); // strip 0x\n    const addresses = decodeTokenAddressesFromDelegationCalldata(noPrefix);\n    addresses.should.deepEqual([CTEST1_TOKEN_ADDRESS.toLowerCase()]);\n  });\n\n  it('should throw for unrecognised calldata', function () {\n    should.throws(\n      () => decodeTokenAddressesFromDelegationCalldata('0xdeadbeef00000000'),\n      /Not a valid delegation calldata/\n    );\n  });\n});\n\n// ---------------------------------------------------------------------------\n// verifyTransaction – confidential consolidation (FlushERC7984ForwarderToken)\n// ---------------------------------------------------------------------------\n\nconst MULTISIG_WALLET_CONTRACT = '0x3b58684525564b38a381e46a731703ed03f32122';\nconst CONSOLIDATION_FORWARDER = '0xf4bcb366bb5e34ebbee51fae5de98cc876c0146f';\nconst CONSOLIDATION_BASE_ADDRESS = '0x3b58684525564b38a381e46a731703ed03f32122';\nconst CONSOLIDATION_HANDLE = '0x65df136b609ab395c1a99ae46f7939c7f8b20dff4bff0000000088bb0050';\nconst DUMMY_MULTISIG_SIGNATURE = '0x' + '00'.repeat(65);\n\nasync function buildMultisigConsolidationTxHex(): Promise<string> {\n  const flushCalldata = buildFlushERC7984ForwarderTokenCalldata(\n    CTEST1_TOKEN_ADDRESS,\n    CONSOLIDATION_BASE_ADDRESS,\n    CONSOLIDATION_HANDLE\n  );\n  const sendData = sendMultiSigData(\n    CONSOLIDATION_FORWARDER,\n    '0',\n    flushCalldata,\n    Math.floor(Date.now() / 1000) + 3600,\n    14,\n    DUMMY_MULTISIG_SIGNATURE\n  );\n\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '12100000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.ContractCall);\n  txBuilder.contract(MULTISIG_WALLET_CONTRACT);\n  txBuilder.data(sendData);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\nasync function buildDirectConsolidationTxHex(): Promise<string> {\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.FlushERC7984ForwarderToken);\n  txBuilder.contract(CONSOLIDATION_FORWARDER);\n  txBuilder.forwarderAddress(CONSOLIDATION_FORWARDER);\n  txBuilder.tokenContractAddress(CTEST1_TOKEN_ADDRESS);\n  txBuilder.parentAddress(CONSOLIDATION_BASE_ADDRESS);\n  txBuilder.encryptedHandle(CONSOLIDATION_HANDLE);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\ndescribe('verifyTransaction – confidential consolidation (FlushERC7984ForwarderToken)', function () {\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n  });\n\n  it('should verify a valid multisig consolidation tx (sendMultiSig → callFromParent → confidentialTransferNoProof)', async function () {\n    const txHex = await buildMultisigConsolidationTxHex();\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: { type: 'consolidate' } as any,\n      txPrebuild: {\n        consolidateId: '6a44ebc0326e1be45c1d797542c8c634',\n        txHex,\n        recipients: [{ address: CONSOLIDATION_FORWARDER, amount: '0' }],\n      } as any,\n      wallet,\n    });\n    result.should.equal(true);\n  });\n\n  it('should verify a valid direct callFromParent consolidation tx (TSS shape)', async function () {\n    const txHex = await buildDirectConsolidationTxHex();\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: { type: 'consolidate' } as any,\n      txPrebuild: {\n        consolidateId: '6a44ebc0326e1be45c1d797542c8c634',\n        txHex,\n      } as any,\n      wallet,\n      verification: { consolidationToBaseAddress: true },\n    });\n    result.should.equal(true);\n  });\n\n  it('should reject multisig consolidation when parent address does not match wallet base address', async function () {\n    const txHex = await buildMultisigConsolidationTxHex();\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { type: 'consolidate' } as any,\n        txPrebuild: { consolidateId: 'abc123', txHex } as any,\n        wallet,\n      })\n      .should.be.rejectedWith(/parent address mismatch/);\n  });\n\n  it('should verify multisig consolidation using forwarder address from txPrebuild.txInfo.recipients', async function () {\n    const txHex = await buildMultisigConsolidationTxHex();\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },\n    });\n\n    // No top-level recipients; forwarder comes from txInfo.recipients\n    const result = await coin.verifyTransaction({\n      txParams: { type: 'consolidate' } as any,\n      txPrebuild: {\n        consolidateId: '6a44ebc0326e1be45c1d797542c8c634',\n        txHex,\n        txInfo: { recipients: [{ address: CONSOLIDATION_FORWARDER, amount: '0' }] },\n      } as any,\n      wallet,\n    });\n    result.should.equal(true);\n  });\n\n  it('should reject multisig consolidation when txInfo.recipients forwarder address does not match tx forwarder', async function () {\n    const txHex = await buildMultisigConsolidationTxHex();\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { type: 'consolidate' } as any,\n        txPrebuild: {\n          consolidateId: 'abc123',\n          txHex,\n          txInfo: { recipients: [{ address: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', amount: '0' }] },\n        } as any,\n        wallet,\n      })\n      .should.be.rejectedWith(/forwarder address mismatch/);\n  });\n\n  // TSS MPCv2 signing path — resolveEffectiveTxParams sets type from intent.intentType ('consolidateToken'),\n  // and txPrebuild has only txHex (no consolidateId, no recipients). This was the broken path before\n  // isConsolidationTransaction was updated to recognise 'consolidateToken'.\n  it('should verify a valid direct callFromParent consolidation tx when type is consolidateToken (TSS MPCv2 signing path)', async function () {\n    const txHex = await buildDirectConsolidationTxHex();\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: CONSOLIDATION_BASE_ADDRESS },\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: {\n        type: 'consolidateToken',\n        recipients: [{ address: CONSOLIDATION_FORWARDER, amount: '0' }],\n      } as any,\n      txPrebuild: { txHex } as any,\n      wallet,\n    });\n    result.should.equal(true);\n  });\n\n  it('should reject callFromParent consolidation with type consolidateToken when parent address does not match wallet base address', async function () {\n    const txHex = await buildDirectConsolidationTxHex();\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: {\n          type: 'consolidateToken',\n          recipients: [{ address: CONSOLIDATION_FORWARDER, amount: '0' }],\n        } as any,\n        txPrebuild: { txHex } as any,\n        wallet,\n      })\n      .should.be.rejectedWith(/parent address mismatch/);\n  });\n});\n\n// ---------------------------------------------------------------------------\n// recover() – ERC-7984 confidential token recovery\n// ---------------------------------------------------------------------------\n\ndescribe('Erc7984Token – recover()', function () {\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n  let explorerStub: sinon.SinonStub;\n\n  const WALLET_CONTRACT = '0x8f977e912ef500548a0c3be6ddde9899f1199b81';\n  const RECOVERY_DEST = '0x19645032c7f1533395d44a629462e751084d3e4c';\n  const HANDLE = '0x' + 'ab'.repeat(32);\n  const ZERO_HANDLE = '0x' + '00'.repeat(32);\n\n  const USER_KEY = testData.PRIVATE_KEY;\n  const BACKUP_KEY = testData.PRIVATE_KEY;\n  const WALLET_PASSPHRASE = 'test wallet passphrase';\n\n  /**\n   * Function selector for `isSigner(address)` on the WalletSimple contract.\n   *\n   * EVM calldata starts with the first 4 bytes of the keccak256 hash of the\n   * function signature, i.e. `keccak256(\"isSigner(address)\")[0..4]` = `7df73e27`.\n   * The explorer stub matches on this prefix to distinguish the signer probe\n   * from other `eth_call` queries (e.g. `getNextSequenceId` = `a0b7967b`).\n   */\n  const IS_SIGNER_SELECTOR = '7df73e27';\n\n  /**\n   * Solidity ABI-encoded boolean `true`.\n   *\n   * A `bool` in ABI encoding occupies a full 32-byte word: 31 zero bytes then\n   * `0x01` for true (all 32 zero bytes for false). `queryIsWalletSigner` decodes\n   * the explorer response with `ethAbi.rawDecode(['bool'], ...)`, so the stub\n   * must return this exact 32-byte shape — a shorter value like `0x01` would\n   * fail to decode.\n   *\n   * Written as an expression instead of a bare hex literal because the repo's\n   * test-fixture secret scrubber flags 64-hex literals.\n   */\n  const ABI_TRUE = '0x' + '00'.repeat(31) + '01';\n\n  /**\n   * Solidity ABI-encoded boolean `false` — a 32-byte word of all zeros.\n   * See `ABI_TRUE` above for the encoding rationale.\n   */\n  const ABI_FALSE = '0x' + '00'.repeat(32);\n\n  // Encrypted keys for test (encrypt with the test passphrase)\n  let encryptedUserKey: string;\n  let encryptedBackupKey: string;\n\n  before(async function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n\n    encryptedUserKey = await bitgo.encrypt({ input: USER_KEY, password: WALLET_PASSPHRASE });\n    encryptedBackupKey = await bitgo.encrypt({ input: BACKUP_KEY, password: WALLET_PASSPHRASE });\n  });\n\n  beforeEach(function () {\n    explorerStub = sinon.stub(coin, 'recoveryBlockchainExplorerQuery' as any);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  function mockExplorerForRecovery(handle: string = HANDLE) {\n    explorerStub.callsFake(async (query: Record<string, string>) => {\n      if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {\n        return { result: ABI_TRUE };\n      }\n      if (query.action === 'txlist') {\n        // getAddressNonce: return empty tx list (nonce = 0)\n        return { result: [] };\n      }\n      if (query.action === 'balance') {\n        // queryAddressBalance: return enough ETH for gas\n        return { result: '100000000000000000' }; // 0.1 ETH\n      }\n      if (query.action === 'eth_call' && query.data?.startsWith('a0b7967b')) {\n        // querySequenceId: getNextSequenceId\n        return { result: '0x0000000000000000000000000000000000000000000000000000000000000005' };\n      }\n      if (query.action === 'eth_call' && query.to === CTEST1_TOKEN_ADDRESS) {\n        // queryConfidentialBalance\n        return { result: handle };\n      }\n      throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);\n    });\n  }\n\n  it('should build a full balance sweep recovery transaction', async function () {\n    mockExplorerForRecovery();\n\n    const result = await coin.recover({\n      userKey: encryptedUserKey,\n      backupKey: encryptedBackupKey,\n      walletPassphrase: WALLET_PASSPHRASE,\n      walletContractAddress: WALLET_CONTRACT,\n      recoveryDestination: RECOVERY_DEST,\n    });\n\n    should.exist(result);\n    result.should.have.property('id');\n    result.should.have.property('tx');\n    (result as any).tx.should.be.a.String();\n    (result as any).tx.length.should.be.greaterThan(0);\n  });\n\n  it('should use user-provided encryptedHandle and skip auto-query', async function () {\n    const userHandle = '0x' + 'ff'.repeat(32);\n\n    explorerStub.callsFake(async (query: Record<string, string>) => {\n      if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {\n        return { result: ABI_TRUE };\n      }\n      if (query.action === 'txlist') {\n        return { result: [] };\n      }\n      if (query.action === 'balance') {\n        return { result: '100000000000000000' };\n      }\n      if (query.action === 'eth_call' && query.data?.startsWith('a0b7967b')) {\n        return { result: '0x0000000000000000000000000000000000000000000000000000000000000005' };\n      }\n      if (query.action === 'eth_call' && query.to === CTEST1_TOKEN_ADDRESS) {\n        throw new Error('Should not query confidentialBalanceOf when handle is provided');\n      }\n      throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);\n    });\n\n    const result = await coin.recover({\n      userKey: encryptedUserKey,\n      backupKey: encryptedBackupKey,\n      walletPassphrase: WALLET_PASSPHRASE,\n      walletContractAddress: WALLET_CONTRACT,\n      recoveryDestination: RECOVERY_DEST,\n      encryptedHandle: userHandle,\n    });\n\n    should.exist(result);\n    result.should.have.property('tx');\n  });\n\n  it('should still build a recovery tx even with a zero-value handle (encrypted handles are always non-zero)', async function () {\n    mockExplorerForRecovery(ZERO_HANDLE);\n\n    const result = await coin.recover({\n      userKey: encryptedUserKey,\n      backupKey: encryptedBackupKey,\n      walletPassphrase: WALLET_PASSPHRASE,\n      walletContractAddress: WALLET_CONTRACT,\n      recoveryDestination: RECOVERY_DEST,\n    });\n\n    should.exist(result);\n    result.should.have.property('tx');\n  });\n\n  it('should return unsigned sweep format when isUnsignedSweep is true', async function () {\n    mockExplorerForRecovery();\n\n    const result = await coin.recover({\n      userKey: testData.PUBLIC_KEY,\n      backupKey: testData.PUBLIC_KEY,\n      walletContractAddress: WALLET_CONTRACT,\n      recoveryDestination: RECOVERY_DEST,\n      isUnsignedSweep: true,\n    });\n\n    should.exist(result);\n    result.should.have.property('tx');\n    result.should.have.property('userKey');\n    result.should.have.property('backupKey');\n  });\n\n  it('should return KRS recovery format with backupKey and coin', async function () {\n    explorerStub.callsFake(async (query: Record<string, string>) => {\n      if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {\n        return { result: ABI_TRUE };\n      }\n      if (query.action === 'txlist') {\n        return { result: [] };\n      }\n      if (query.action === 'balance') {\n        return { result: '100000000000000000' };\n      }\n      if (query.action === 'eth_call' && query.data?.startsWith('a0b7967b')) {\n        return { result: '0x0000000000000000000000000000000000000000000000000000000000000005' };\n      }\n      if (query.action === 'eth_call' && query.to === CTEST1_TOKEN_ADDRESS) {\n        return { result: HANDLE };\n      }\n      throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);\n    });\n\n    const result = (await coin.recover({\n      userKey: encryptedUserKey,\n      backupKey: testData.PUBLIC_KEY,\n      walletPassphrase: WALLET_PASSPHRASE,\n      walletContractAddress: WALLET_CONTRACT,\n      recoveryDestination: RECOVERY_DEST,\n      krsProvider: 'keyternal',\n    })) as any;\n\n    should.exist(result);\n    result.should.have.property('tx');\n    result.should.have.property('backupKey', testData.PUBLIC_KEY);\n    result.should.have.property('coin', 'hteth:ctest1');\n  });\n\n  it('should throw when backup key has insufficient gas', async function () {\n    explorerStub.callsFake(async (query: Record<string, string>) => {\n      if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {\n        return { result: ABI_TRUE };\n      }\n      if (query.action === 'txlist') {\n        return { result: [] };\n      }\n      if (query.action === 'balance') {\n        // Very low balance, not enough for 12M gas\n        return { result: '100' };\n      }\n      throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);\n    });\n\n    await coin\n      .recover({\n        userKey: encryptedUserKey,\n        backupKey: encryptedBackupKey,\n        walletPassphrase: WALLET_PASSPHRASE,\n        walletContractAddress: WALLET_CONTRACT,\n        recoveryDestination: RECOVERY_DEST,\n      })\n      .should.be.rejectedWith(/has balance.*Gwei/);\n  });\n\n  it('should throw when userKey is missing', async function () {\n    await coin\n      .recover({\n        userKey: undefined as any,\n        backupKey: encryptedBackupKey,\n        walletPassphrase: WALLET_PASSPHRASE,\n        walletContractAddress: WALLET_CONTRACT,\n        recoveryDestination: RECOVERY_DEST,\n      })\n      .should.be.rejectedWith(/missing userKey/);\n  });\n\n  it('should throw when walletContractAddress is invalid', async function () {\n    await coin\n      .recover({\n        userKey: encryptedUserKey,\n        backupKey: encryptedBackupKey,\n        walletPassphrase: WALLET_PASSPHRASE,\n        walletContractAddress: 'not-an-address',\n        recoveryDestination: RECOVERY_DEST,\n      })\n      .should.be.rejectedWith(/invalid walletContractAddress/);\n  });\n\n  it('should produce tx with inner calldata matching confidentialTransfer selector 0x5bebed7e', async function () {\n    mockExplorerForRecovery();\n\n    const result = (await coin.recover({\n      userKey: encryptedUserKey,\n      backupKey: encryptedBackupKey,\n      walletPassphrase: WALLET_PASSPHRASE,\n      walletContractAddress: WALLET_CONTRACT,\n      recoveryDestination: RECOVERY_DEST,\n    })) as any;\n\n    should.exist(result.tx);\n    // The serialized tx contains the sendMultiSig calldata which wraps confidentialTransfer.\n    // The confidentialTransfer selector (5bebed7e) must appear somewhere in the serialized tx.\n    const selectorNoPrefix = confidentialTransferNoProofMethodId.slice(2);\n    result.tx.should.containEql(selectorNoPrefix);\n  });\n\n  it('should throw RecoveryKeyMismatchError when a recovery key is not a wallet signer', async function () {\n    explorerStub.callsFake(async (query: Record<string, string>) => {\n      if (query.action === 'eth_call' && query.data?.startsWith(IS_SIGNER_SELECTOR)) {\n        return { result: ABI_FALSE };\n      }\n      throw new Error(`Unexpected explorer query: ${JSON.stringify(query)}`);\n    });\n\n    await coin\n      .recover({\n        userKey: encryptedUserKey,\n        backupKey: encryptedBackupKey,\n        walletPassphrase: WALLET_PASSPHRASE,\n        walletContractAddress: WALLET_CONTRACT,\n        recoveryDestination: RECOVERY_DEST,\n      })\n      .should.be.rejectedWith(RecoveryKeyMismatchError);\n  });\n});\n\n// ---------------------------------------------------------------------------\n// queryConfidentialBalance() tests\n// ---------------------------------------------------------------------------\n\ndescribe('Erc7984Token – queryConfidentialBalance()', function () {\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n  let explorerStub: sinon.SinonStub;\n\n  const WALLET_ADDRESS = '0x8f977e912ef500548a0c3be6ddde9899f1199b81';\n  const HANDLE = '0x' + 'ab'.repeat(32);\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n  });\n\n  beforeEach(function () {\n    explorerStub = sinon.stub(coin, 'recoveryBlockchainExplorerQuery' as any);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  it('should return a valid bytes32 handle from eth_call', async function () {\n    explorerStub.resolves({ result: HANDLE });\n\n    const result = await coin.queryConfidentialBalance(WALLET_ADDRESS);\n    result.should.equal(HANDLE);\n  });\n\n  it('should verify the eth_call is made to the correct token contract', async function () {\n    explorerStub.resolves({ result: HANDLE });\n\n    await coin.queryConfidentialBalance(WALLET_ADDRESS);\n\n    explorerStub.calledOnce.should.be.true();\n    const callArgs = explorerStub.firstCall.args[0];\n    callArgs.should.have.property('action', 'eth_call');\n    callArgs.should.have.property('to', CTEST1_TOKEN_ADDRESS);\n    callArgs.should.have.property('module', 'proxy');\n  });\n\n  it('should throw when explorer returns no result', async function () {\n    explorerStub.resolves({ result: null });\n\n    await coin.queryConfidentialBalance(WALLET_ADDRESS).should.be.rejectedWith(/Could not obtain confidential balance/);\n  });\n\n  it('should throw when response format is unexpected (not 66 chars)', async function () {\n    explorerStub.resolves({ result: '0xabcd' });\n\n    await coin\n      .queryConfidentialBalance(WALLET_ADDRESS)\n      .should.be.rejectedWith(/Unexpected confidentialBalanceOf response format/);\n  });\n});\n\n// ---------------------------------------------------------------------------\n// verifyTransaction – WrapERC7984 (shield)\n// ---------------------------------------------------------------------------\n\nconst WRAP_BASE_ADDRESS = '0x1111111111111111111111111111111111111111';\nconst WRAP_AMOUNT = '1000000';\nconst WRAP_RATE = '1';\n\nasync function buildDirectWrapTxHex(tokenAddress: string, recipient: string, amount: string): Promise<string> {\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.WrapERC7984);\n  txBuilder.contract(tokenAddress);\n  txBuilder.wrapRecipient(recipient);\n  txBuilder.wrapAmount(amount);\n  txBuilder.wrapRate(WRAP_RATE);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\nasync function buildMultisigWrapTxHex(tokenAddress: string, recipient: string, amount: string): Promise<string> {\n  const wrapCalldata = buildWrapCalldata(recipient, amount, WRAP_RATE);\n  const sendData = sendMultiSigData(\n    tokenAddress,\n    '0',\n    wrapCalldata,\n    Math.floor(Date.now() / 1000) + 3600,\n    14,\n    DUMMY_MULTISIG_SIGNATURE\n  );\n\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.ContractCall);\n  txBuilder.contract(MULTISIG_WALLET_CONTRACT);\n  txBuilder.data(sendData);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\ndescribe('verifyTransaction – WrapERC7984', function () {\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n  });\n\n  it('should verify a valid direct wrap tx (TSS shape)', async function () {\n    const txHex = await buildDirectWrapTxHex(CTEST1_TOKEN_ADDRESS, WRAP_BASE_ADDRESS, WRAP_AMOUNT);\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: WRAP_BASE_ADDRESS },\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: {\n        type: 'wrap',\n        recipients: [{ address: WRAP_BASE_ADDRESS, amount: WRAP_AMOUNT }],\n      } as any,\n      txPrebuild: { txHex } as any,\n      wallet,\n    });\n    result.should.equal(true);\n  });\n\n  it('should verify a valid multisig wrap tx (sendMultiSig → wrap)', async function () {\n    const txHex = await buildMultisigWrapTxHex(CTEST1_TOKEN_ADDRESS, WRAP_BASE_ADDRESS, WRAP_AMOUNT);\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: WRAP_BASE_ADDRESS },\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: {\n        type: 'wrap',\n        recipients: [{ address: WRAP_BASE_ADDRESS, amount: WRAP_AMOUNT }],\n      } as any,\n      txPrebuild: { txHex } as any,\n      wallet,\n    });\n    result.should.equal(true);\n  });\n\n  it('should reject wrap when recipient does not match wallet base address', async function () {\n    const txHex = await buildDirectWrapTxHex(CTEST1_TOKEN_ADDRESS, WRAP_BASE_ADDRESS, WRAP_AMOUNT);\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { type: 'wrap', recipients: [{ address: WRAP_BASE_ADDRESS, amount: WRAP_AMOUNT }] } as any,\n        txPrebuild: { txHex } as any,\n        wallet,\n      })\n      .should.be.rejectedWith(/wrap recipient must equal wallet base address/);\n  });\n\n  it('should reject wrap when amount mismatches recipients', async function () {\n    const txHex = await buildDirectWrapTxHex(CTEST1_TOKEN_ADDRESS, WRAP_BASE_ADDRESS, WRAP_AMOUNT);\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: WRAP_BASE_ADDRESS },\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { type: 'wrap', recipients: [{ address: WRAP_BASE_ADDRESS, amount: '999' }] } as any,\n        txPrebuild: { txHex } as any,\n        wallet,\n      })\n      .should.be.rejectedWith(/amount mismatch/);\n  });\n});\n\n// ---------------------------------------------------------------------------\n// verifyTransaction – UnwrapERC7984 (unshield phase-1)\n// ---------------------------------------------------------------------------\n\nconst UNWRAP_BASE_ADDRESS = '0x1111111111111111111111111111111111111111';\nconst UNWRAP_ENCRYPTED_AMOUNT = '0x' + 'ab'.repeat(32);\nconst UNWRAP_INPUT_PROOF = '0x' + 'cd'.repeat(64);\n\nasync function buildDirectUnwrapTxHex(\n  tokenAddress: string,\n  from: string,\n  to: string,\n  encryptedAmount: string,\n  inputProof: string\n): Promise<string> {\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.UnwrapERC7984);\n  txBuilder.contract(tokenAddress);\n  txBuilder.unwrapFrom(from);\n  txBuilder.unwrapTo(to);\n  txBuilder.unwrapEncryptedAmount(encryptedAmount);\n  txBuilder.unwrapInputProof(inputProof);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\nasync function buildMultisigUnwrapTxHex(\n  tokenAddress: string,\n  from: string,\n  to: string,\n  encryptedAmount: string,\n  inputProof: string\n): Promise<string> {\n  const unwrapCalldata = buildUnwrapCalldata(from, to, encryptedAmount, inputProof);\n  const sendData = sendMultiSigData(\n    tokenAddress,\n    '0',\n    unwrapCalldata,\n    Math.floor(Date.now() / 1000) + 3600,\n    14,\n    DUMMY_MULTISIG_SIGNATURE\n  );\n\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.ContractCall);\n  txBuilder.contract(MULTISIG_WALLET_CONTRACT);\n  txBuilder.data(sendData);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\ndescribe('verifyTransaction – UnwrapERC7984', function () {\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n  });\n\n  it('should verify a valid direct unwrap tx (TSS shape)', async function () {\n    const txHex = await buildDirectUnwrapTxHex(\n      CTEST1_TOKEN_ADDRESS,\n      UNWRAP_BASE_ADDRESS,\n      UNWRAP_BASE_ADDRESS,\n      UNWRAP_ENCRYPTED_AMOUNT,\n      UNWRAP_INPUT_PROOF\n    );\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: UNWRAP_BASE_ADDRESS },\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: { type: 'unwrap' } as any,\n      txPrebuild: { txHex } as any,\n      wallet,\n    });\n    result.should.equal(true);\n  });\n\n  it('should verify a valid multisig unwrap tx (sendMultiSig → unwrap)', async function () {\n    const txHex = await buildMultisigUnwrapTxHex(\n      CTEST1_TOKEN_ADDRESS,\n      UNWRAP_BASE_ADDRESS,\n      UNWRAP_BASE_ADDRESS,\n      UNWRAP_ENCRYPTED_AMOUNT,\n      UNWRAP_INPUT_PROOF\n    );\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: UNWRAP_BASE_ADDRESS },\n    });\n\n    const result = await coin.verifyTransaction({\n      txParams: { type: 'unwrap' } as any,\n      txPrebuild: { txHex } as any,\n      wallet,\n    });\n    result.should.equal(true);\n  });\n\n  it('should reject unwrap when from does not match wallet base address', async function () {\n    const txHex = await buildDirectUnwrapTxHex(\n      CTEST1_TOKEN_ADDRESS,\n      UNWRAP_BASE_ADDRESS,\n      UNWRAP_BASE_ADDRESS,\n      UNWRAP_ENCRYPTED_AMOUNT,\n      UNWRAP_INPUT_PROOF\n    );\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { type: 'unwrap' } as any,\n        txPrebuild: { txHex } as any,\n        wallet,\n      })\n      .should.be.rejectedWith(/unwrap from must equal wallet base address/);\n  });\n\n  it('should reject unwrap when to differs from from (non-self-directed)', async function () {\n    const other = '0x2222222222222222222222222222222222222222';\n    const txHex = await buildDirectUnwrapTxHex(\n      CTEST1_TOKEN_ADDRESS,\n      UNWRAP_BASE_ADDRESS,\n      other,\n      UNWRAP_ENCRYPTED_AMOUNT,\n      UNWRAP_INPUT_PROOF\n    );\n    const wallet = new Wallet(bitgo, coin, {\n      coinSpecific: { baseAddress: UNWRAP_BASE_ADDRESS },\n    });\n\n    await coin\n      .verifyTransaction({\n        txParams: { type: 'unwrap' } as any,\n        txPrebuild: { txHex } as any,\n        wallet,\n      })\n      .should.be.rejectedWith(/unwrap to must equal wallet base address/);\n  });\n});\n\n// ---------------------------------------------------------------------------\n// verifyTransaction – FinalizeUnwrapERC7984 (unshield phase-2)\n// ---------------------------------------------------------------------------\n\nconst FINALIZE_REQUEST_ID = '0x' + '11'.repeat(32);\nconst FINALIZE_CLEARTEXT_AMOUNT = '1000000';\nconst FINALIZE_DECRYPTION_PROOF = '0x' + 'ee'.repeat(64);\n\nasync function buildDirectFinalizeUnwrapTxHex(\n  tokenAddress: string,\n  requestId: string,\n  cleartextAmount: string,\n  decryptionProof: string\n): Promise<string> {\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.FinalizeUnwrapERC7984);\n  txBuilder.contract(tokenAddress);\n  txBuilder.finalizeUnwrapRequestId(requestId);\n  txBuilder.finalizeUnwrapCleartextAmount(cleartextAmount);\n  txBuilder.finalizeUnwrapDecryptionProof(decryptionProof);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\nasync function buildMultisigFinalizeUnwrapTxHex(\n  tokenAddress: string,\n  requestId: string,\n  cleartextAmount: string,\n  decryptionProof: string\n): Promise<string> {\n  const finalizeCalldata = buildFinalizeUnwrapCalldata(requestId, cleartextAmount, decryptionProof);\n  const sendData = sendMultiSigData(\n    tokenAddress,\n    '0',\n    finalizeCalldata,\n    Math.floor(Date.now() / 1000) + 3600,\n    14,\n    DUMMY_MULTISIG_SIGNATURE\n  );\n\n  const txBuilder = getBuilder('hteth') as TransactionBuilder;\n  txBuilder.fee({ fee: '1000000000', gasLimit: '200000' });\n  txBuilder.counter(1);\n  txBuilder.type(TransactionType.ContractCall);\n  txBuilder.contract(MULTISIG_WALLET_CONTRACT);\n  txBuilder.data(sendData);\n  const tx = await txBuilder.build();\n  return tx.toBroadcastFormat();\n}\n\ndescribe('verifyTransaction – FinalizeUnwrapERC7984', function () {\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n  });\n\n  it('should verify a valid direct finalizeUnwrap tx (TSS shape)', async function () {\n    const txHex = await buildDirectFinalizeUnwrapTxHex(\n      CTEST1_TOKEN_ADDRESS,\n      FINALIZE_REQUEST_ID,\n      FINALIZE_CLEARTEXT_AMOUNT,\n      FINALIZE_DECRYPTION_PROOF\n    );\n\n    const result = await coin.verifyTransaction({\n      txParams: {\n        type: 'finalizeUnwrap',\n        recipients: [{ address: UNWRAP_BASE_ADDRESS, amount: FINALIZE_CLEARTEXT_AMOUNT }],\n      } as any,\n      txPrebuild: { txHex } as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should verify a valid multisig finalizeUnwrap tx (sendMultiSig → finalizeUnwrap)', async function () {\n    const txHex = await buildMultisigFinalizeUnwrapTxHex(\n      CTEST1_TOKEN_ADDRESS,\n      FINALIZE_REQUEST_ID,\n      FINALIZE_CLEARTEXT_AMOUNT,\n      FINALIZE_DECRYPTION_PROOF\n    );\n\n    const result = await coin.verifyTransaction({\n      txParams: {\n        type: 'finalizeUnwrap',\n        recipients: [{ address: UNWRAP_BASE_ADDRESS, amount: FINALIZE_CLEARTEXT_AMOUNT }],\n      } as any,\n      txPrebuild: { txHex } as any,\n      wallet: {} as any,\n    });\n    result.should.equal(true);\n  });\n\n  it('should reject finalizeUnwrap when amount mismatches recipients', async function () {\n    const txHex = await buildDirectFinalizeUnwrapTxHex(\n      CTEST1_TOKEN_ADDRESS,\n      FINALIZE_REQUEST_ID,\n      FINALIZE_CLEARTEXT_AMOUNT,\n      FINALIZE_DECRYPTION_PROOF\n    );\n\n    await coin\n      .verifyTransaction({\n        txParams: {\n          type: 'finalizeUnwrap',\n          recipients: [{ address: UNWRAP_BASE_ADDRESS, amount: '999' }],\n        } as any,\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/amount mismatch/);\n  });\n\n  it('should reject finalizeUnwrap when wrapper address mismatches token', async function () {\n    const wrongWrapper = '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';\n    const txHex = await buildDirectFinalizeUnwrapTxHex(\n      wrongWrapper,\n      FINALIZE_REQUEST_ID,\n      FINALIZE_CLEARTEXT_AMOUNT,\n      FINALIZE_DECRYPTION_PROOF\n    );\n\n    await coin\n      .verifyTransaction({\n        txParams: { type: 'finalizeUnwrap' } as any,\n        txPrebuild: { txHex } as any,\n        wallet: {} as any,\n      })\n      .should.be.rejectedWith(/wrapper address mismatch/);\n  });\n});\n\n// ---------------------------------------------------------------------------\n// setGasLimit() override tests\n// ---------------------------------------------------------------------------\n\ndescribe('Erc7984Token – setGasLimit()', function () {\n  let bitgo: TestBitGoAPI;\n  let coin: Erc7984Token;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.initializeTestVars();\n    register(bitgo);\n    coin = bitgo.coin('hteth:ctest1') as Erc7984Token;\n  });\n\n  it('should return 800000 as default gas limit', function () {\n    const gasLimit = coin.setGasLimit();\n    gasLimit.should.equal(800000);\n  });\n\n  it('should accept user-provided gas limit', function () {\n    const gasLimit = coin.setGasLimit(1000000);\n    gasLimit.should.equal(1000000);\n  });\n});\n"]}