@bitgo-beta/sdk-coin-dot 2.2.8-beta.209 → 2.2.8-beta.2091

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

@@ -0,0 +1,1302 @@
+"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 });
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const crypto_1 = require("crypto");
+const should = require("should");
+const assert = require("assert");
+const src_1 = require("../../src");
+const testData = __importStar(require("../fixtures"));
+const resources_1 = require("../resources");
+const sinon = __importStar(require("sinon"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const statics_1 = require("@bitgo-beta/statics");
+const wasm_dot_1 = require("@bitgo/wasm-dot");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const Extrinsic_1 = require("@polkadot/types/extrinsic/v4/Extrinsic");
+const utils_1 = __importDefault(require("../../src/lib/utils"));
+const lib_1 = require("../../src/lib");
+describe('DOT:', function () {
+    let bitgo;
+    let basecoin;
+    let prodCoin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('dot', src_1.Dot.createInstance);
+        bitgo.safeRegister('tdot', src_1.Tdot.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('tdot');
+        prodCoin = bitgo.coin('dot');
+    });
+    describe('Sign Message', () => {
+        it('should be performed', async () => {
+            const keyPair = new src_1.KeyPair();
+            const messageToSign = Buffer.from((0, crypto_1.randomBytes)(32)).toString('hex');
+            const signature = await basecoin.signMessage(keyPair.getKeys(), messageToSign);
+            keyPair.verifySignature(messageToSign, Uint8Array.from(signature)).should.equals(true);
+        });
+        it('should fail with missing private key', async () => {
+            const keyPair = new src_1.KeyPair({
+                pub: '7788327c695dca4b3e649a0db45bc3e703a2c67428fce360e61800cc4248f4f7',
+            }).getKeys();
+            const messageToSign = Buffer.from((0, crypto_1.randomBytes)(32)).toString('hex');
+            await basecoin.signMessage(keyPair, messageToSign).should.be.rejectedWith('Invalid key pair options');
+        });
+    });
+    describe('Sign transaction', () => {
+        const transaction = {
+            id: '0x19de156328eea66bd1ec45843569c168e0bb2f2898221029b403df3f23a5489d',
+            sender: '5EGoFA95omzemRssELLDjVenNZ68aXyUeqtKQScXSEBvVJkr',
+            referenceBlock: '0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d',
+            blockNumber: 3933,
+            genesisHash: '0x67f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9',
+            nonce: 200,
+            specVersion: 1018013,
+            transactionVersion: 16,
+            eraPeriod: 64,
+            chainName: 'Westend Asset Hub',
+            tip: 0,
+            to: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq',
+            amount: '10000000000',
+        };
+        // TODO: BG-43197
+        xit('should sign transaction', async function () {
+            const signed = await basecoin.signTransaction({
+                txPrebuild: {
+                    txHex: testData.rawTx.transfer.unsigned,
+                    transaction,
+                },
+                pubs: [testData.accounts.account1.publicKey],
+                prv: testData.accounts.account1.secretKey,
+            });
+            signed.txHex.should.equal(testData.rawTx.transfer.signed);
+        });
+        // TODO: BG-43197
+        xit('should fail to sign transaction with an invalid key', async function () {
+            try {
+                await basecoin.signTransaction({
+                    txPrebuild: {
+                        txHex: testData.rawTx.transfer.unsigned,
+                        transaction,
+                    },
+                    pubs: [testData.accounts.account2.publicKey],
+                    prv: testData.accounts.account1.secretKey,
+                });
+            }
+            catch (e) {
+                should.equal(e.message, 'Private key cannot sign the transaction');
+            }
+        });
+        it('should fail to build transaction with missing params', async function () {
+            try {
+                await basecoin.signTransaction({
+                    txPrebuild: {
+                        txHex: testData.rawTx.transfer.unsigned,
+                        key: testData.accounts.account1.publicKey,
+                    },
+                    prv: testData.accounts.account1.secretKey,
+                });
+            }
+            catch (e) {
+                should.notEqual(e, null);
+            }
+        });
+    });
+    describe('Generate wallet key pair: ', () => {
+        it('should generate key pair', () => {
+            const kp = basecoin.generateKeyPair();
+            basecoin.isValidPub(kp.pub).should.equal(true);
+            basecoin.isValidPrv(kp.prv).should.equal(true);
+        });
+        it('should generate key pair from seed', () => {
+            const seed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');
+            const kp = basecoin.generateKeyPair(seed);
+            basecoin.isValidPub(kp.pub).should.equal(true);
+            basecoin.isValidPrv(kp.prv).should.equal(true);
+        });
+    });
+    describe('Balance Conversion', () => {
+        it('should return 10000000000 as tdot base factor', () => {
+            // mainnet uses 10 decimal places
+            const baseFactor = prodCoin.getBaseFactor();
+            baseFactor.should.equal(10000000000);
+        });
+        it('should return 1000000000000 as dot base factor', () => {
+            // westend (test polkadot) uses 12 decimal places
+            const baseFactor = basecoin.getBaseFactor();
+            baseFactor.should.equal(1000000000000);
+        });
+        it('should return 4 Dot when base unit is 40000000000 for dot', () => {
+            const bigUnit = prodCoin.baseUnitsToBigUnits('40000000000');
+            bigUnit.should.equal('4');
+        });
+        it('should return 0.04 Dot when base unit is 400000000 for dot', () => {
+            const bigUnit = prodCoin.baseUnitsToBigUnits('400000000');
+            bigUnit.should.equal('0.04');
+        });
+        it('should return 4 test Dot when base unit is 4000000000000 for tdot', () => {
+            const bigUnit = basecoin.baseUnitsToBigUnits('4000000000000');
+            bigUnit.should.equal('4');
+        });
+        it('should return 0.04 test Dot when base unit is 400000000 for tdot', () => {
+            const bigUnit = basecoin.baseUnitsToBigUnits('40000000000');
+            bigUnit.should.equal('0.04');
+        });
+    });
+    describe('Explain Transactions:', () => {
+        it('should explain an unsigned transfer transaction', async function () {
+            const explainedTransaction = await prodCoin.explainTransaction(testData.unsignedTransaction);
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'fee',
+                    'type',
+                    'sequenceId',
+                    'id',
+                    'blockNumber',
+                ],
+                sequenceId: 0,
+                fee: '10',
+                id: '0x0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8',
+                type: '0',
+                outputs: [
+                    {
+                        address: '5DkddSfPsWojjfuH9iJEcUV7ZseQ9EJ6RjtNmCR1w3CEb8S9',
+                        valueString: '90034235235350',
+                        coinName: 'tdot',
+                        wallet: '62a1205751675b2f0fe72328',
+                    },
+                ],
+                blockNumber: 8619307,
+                outputAmount: 90034235235350,
+                changeOutputs: [],
+                changeAmount: '0',
+            });
+        });
+    });
+    describe('Explain Transactions (WASM):', () => {
+        const coin = statics_1.coins.get('tdot');
+        const material = utils_1.default.getMaterial(coin);
+        const SENDER = testData.accounts.account1.address;
+        const RECIPIENT = testData.accounts.account2.address;
+        function wasmContext(nonce = 0) {
+            return {
+                sender: SENDER,
+                nonce,
+                material: material,
+                validity: { firstValid: testData.westendBlock.blockNumber, maxDuration: 2400 },
+                referenceBlock: testData.westendBlock.hash,
+            };
+        }
+        it('should explain a transfer via explainDotTransaction', function () {
+            const tx = (0, wasm_dot_1.buildTransaction)({ type: 'payment', to: RECIPIENT, amount: 1000000000000n }, wasmContext());
+            const explained = (0, lib_1.explainDotTransaction)({
+                txHex: tx.toBroadcastFormat(),
+                material,
+                senderAddress: SENDER,
+            });
+            assert.strictEqual(explained.type, sdk_core_1.TransactionType.Send);
+            assert.strictEqual(explained.outputs.length, 1);
+            assert.strictEqual(explained.outputs[0].address, RECIPIENT);
+            assert.strictEqual(explained.outputs[0].amount, '1000000000000');
+            assert.strictEqual(explained.outputAmount, '1000000000000');
+            assert.strictEqual(explained.sender, SENDER);
+            assert.strictEqual(explained.methodName, 'balances.transferKeepAlive');
+        });
+        it('should explain a staking bond via explainDotTransaction', function () {
+            const tx = (0, wasm_dot_1.buildTransaction)({ type: 'stake', amount: 5000000000000n, payee: { type: 'stash' } }, wasmContext(1));
+            const explained = (0, lib_1.explainDotTransaction)({
+                txHex: tx.toBroadcastFormat(),
+                material,
+                senderAddress: SENDER,
+            });
+            assert.strictEqual(explained.type, sdk_core_1.TransactionType.StakingActivate);
+            assert.strictEqual(explained.outputs.length, 1);
+            // STAKING_DESTINATION: SS58(0x00..00) sentinel, bond doesn't transfer to an external address
+            assert.strictEqual(explained.outputs[0].address, '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM');
+            assert.strictEqual(explained.outputs[0].amount, '5000000000000');
+        });
+        it('should explain a transfer via explainDotTransaction with sender', function () {
+            const tx = (0, wasm_dot_1.buildTransaction)({ type: 'payment', to: RECIPIENT, amount: 1000000000000n }, wasmContext());
+            const explained = (0, lib_1.explainDotTransaction)({
+                txHex: tx.toBroadcastFormat(),
+                material,
+                senderAddress: SENDER,
+            });
+            assert.strictEqual(explained.type, sdk_core_1.TransactionType.Send);
+            assert.strictEqual(explained.outputs.length, 1);
+            assert.strictEqual(explained.outputs[0].address, RECIPIENT);
+            assert.strictEqual(explained.outputs[0].amount, '1000000000000');
+            assert.strictEqual(explained.sender, SENDER);
+            assert.strictEqual(explained.nonce, 0);
+        });
+    });
+    describe('Recover Transactions:', () => {
+        const sandBox = sinon.createSandbox();
+        const destAddr = testData.accounts.account1.address;
+        const nonce = 123;
+        beforeEach(function () {
+            const accountInfoCB = sandBox.stub(src_1.Dot.prototype, 'getAccountInfo');
+            accountInfoCB.withArgs(testData.wrwUser.walletAddress0).resolves({
+                nonce: nonce,
+                // Must exceed stubbed getFee so recover() does not throw (matches getFee withArgs amount).
+                freeBalance: 1510000000000,
+            });
+            const headerInfoCB = sandBox.stub(src_1.Dot.prototype, 'getHeaderInfo');
+            headerInfoCB.resolves({
+                headerNumber: testData.westendBlock.blockNumber,
+                headerHash: testData.westendBlock.hash,
+            });
+            accountInfoCB.withArgs('5Dtg2zKjVEL8p9keSM4dQ7nD26sVtMfCsyxkhvZZ9fqBbhw6').resolves({
+                nonce: 0,
+                freeBalance: 1510000000000,
+            });
+            const getFeeCB = sandBox.stub(src_1.Dot.prototype, 'getFee');
+            // Default avoids RPC when tests use a recoveryDestination other than destAddr (e.g. unsigned sweep fixture).
+            getFeeCB.resolves(15783812856);
+            getFeeCB.withArgs(destAddr, testData.wrwUser.walletAddress0, 1510000000000).resolves(15783812856);
+            const getMaterialCB = sandBox.stub(src_1.Dot.prototype, 'getMaterial');
+            getMaterialCB.resolves(utils_1.default.getMaterial(statics_1.coins.get('tdot')));
+        });
+        afterEach(function () {
+            sandBox.restore();
+        });
+        it('should generate unsigned sweep correctly', async function () {
+            const commonKeychain = '3cd14f5d60744287cd3a50510e2964746b6feaad4b2300088eaae60d1a35f0abc518534d43b2614370d9a263aadb57edb5d0b78f816a519cd5896e7352920b67';
+            const recoveryDestination = '5GPAveMvmDsjxVT6Q2xiu5kYPbFAmdebHaiNZK14FBaSaAKh';
+            const unsigned = await basecoin.recover({ bitgoKey: commonKeychain, recoveryDestination });
+            unsigned.txRequests.should.not.be.undefined();
+            unsigned.txRequests.length.should.equal(1);
+            unsigned.txRequests[0].transactions.length.should.equal(1);
+            unsigned.txRequests[0].walletCoin.should.equal('tdot');
+            unsigned.txRequests[0].transactions[0].unsignedTx.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.serializedTx.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.scanIndex.should.equal(0);
+            unsigned.txRequests[0].transactions[0].unsignedTx.coin.should.equal('tdot');
+            unsigned.txRequests[0].transactions[0].unsignedTx.signableHex.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.derivationPath.should.equal('m/0');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs.length.should.equal(1);
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].address.should.equal('5Dtg2zKjVEL8p9keSM4dQ7nD26sVtMfCsyxkhvZZ9fqBbhw6');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].valueString.should.equal('1510000000000');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].value.should.equal(1510000000000);
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs.length.should.equal(1);
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].address.should.equal('5GPAveMvmDsjxVT6Q2xiu5kYPbFAmdebHaiNZK14FBaSaAKh');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].valueString.should.equal('1510000000000');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].coinName.should.equal('tdot');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.type.should.equal('');
+            unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.fee.should.equal(0);
+            unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.feeString.should.equal('0');
+            unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.firstValid.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.maxDuration.should.equal(2400);
+            unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.commonKeychain.should.equal('3cd14f5d60744287cd3a50510e2964746b6feaad4b2300088eaae60d1a35f0abc518534d43b2614370d9a263aadb57edb5d0b78f816a519cd5896e7352920b67');
+        });
+        // TODO(COIN-919): Fix failing test
+        xit('should take OVC output and generate a signed sweep transaction', async function () {
+            const params = testData.ovcResponse;
+            const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);
+            recoveryTxn.transactions[0].serializedTx.should.equal('0x2d02840050d1e116cdb32e61ba3ece275b620f503f0c5ae4e7690d9f9aa7e0b50303976c00057c131cde2be39f4ff23eeba11139c46dd8c6d69ff517abede37381d8d24f0bb30fd8805b2e51a9e2a75338d7fb7edb290be9638debedbfc001d10b8132be0b2b4a0400040400bf0678d312b2b2c7effd2b1f214ee13928d339391d5f5f7056608aa0d32b9edf01');
+            recoveryTxn.transactions[0].scanIndex.should.equal(0);
+            recoveryTxn.lastScanIndex.should.equal(0);
+        });
+        // TODO(COIN-919): Fix failing test
+        xit('should take consolidation OVC output and generate multiple signed sweep transactions', async function () {
+            const params = testData.ovcResponse2;
+            const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);
+            recoveryTxn.transactions[0].serializedTx.should.equal('0x2d028400f053d177371f4919b71017421aa34841ac87c926a14e8a7e75f092693665cb4a009871feb8389e12191b460ebea1f9e1716ada8a31d94ac08f5c15cb5f7be24683cdfc300ae3e6802c6f4b044dd92ea03d15b92399ab45803e43beb5cbff582a031b37000004040050d1e116cdb32e61ba3ece275b620f503f0c5ae4e7690d9f9aa7e0b50303976c01');
+            recoveryTxn.transactions[0].scanIndex.should.equal(1);
+            recoveryTxn.transactions[1].serializedTx.should.equal('0x2d028400cf7ed9f536373c8f874e780a4269ec1bd6799ed7d4a854c670b0c72805fac87600d153cbb683706ddf320f7b225af14ce4b59b868c07440aefa4c4e1297e49bcd5f6ee84f696b0c2e456e2a7f8779a78a2c832dfb47d5b283eba8408b003c7dd031b37000004040050d1e116cdb32e61ba3ece275b620f503f0c5ae4e7690d9f9aa7e0b50303976c01');
+            recoveryTxn.transactions[1].scanIndex.should.equal(2);
+            recoveryTxn.transactions[2].serializedTx.should.equal('0x2d0284009482ad7e43b40b7df3383244daafed32b3b9fd7541016b5c907f2d9052f85f8600e255698d110977faf33efb3336ba98ad7eaa2a1a926487fc696a277442d4414b2a441ba92d598f2b1f96f13b28785f5e572984035a608d63c48bd35ba955090e1b37000004040050d1e116cdb32e61ba3ece275b620f503f0c5ae4e7690d9f9aa7e0b50303976c01');
+            recoveryTxn.transactions[2].scanIndex.should.equal(3);
+            recoveryTxn.lastScanIndex.should.equal(20);
+        });
+        // TODO(COIN-919): Fix failing test
+        xit('should recover a txn for non-bitgo recoveries', async function () {
+            const res = await basecoin.recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            });
+            res.should.not.be.empty();
+            res.should.hasOwnProperty('serializedTx');
+            res.should.hasOwnProperty('scanIndex');
+            sandBox.assert.calledOnce(basecoin.getAccountInfo);
+            sandBox.assert.calledOnce(basecoin.getHeaderInfo);
+            // deserialize the txn and verify the fields are what we expect
+            const txBuilder = basecoin.getBuilder().from(res.serializedTx);
+            // some information isn't deserialized by the from method, so we will
+            // supply it again in order to re-build the txn
+            txBuilder
+                .validity({
+                firstValid: testData.westendBlock.blockNumber,
+                maxDuration: basecoin.SWEEP_TXN_DURATION,
+            })
+                .referenceBlock(testData.westendBlock.hash);
+            const tx = await txBuilder.build();
+            const txJson = tx.toJson();
+            should.deepEqual(txJson.sender, testData.wrwUser.walletAddress0);
+            should.deepEqual(txJson.blockNumber, testData.westendBlock.blockNumber);
+            should.deepEqual(txJson.referenceBlock, testData.westendBlock.hash);
+            should.deepEqual(txJson.genesisHash, resources_1.genesisHash);
+            should.deepEqual(txJson.specVersion, resources_1.specVersion);
+            should.deepEqual(txJson.nonce, nonce);
+            should.deepEqual(txJson.tip, 0);
+            should.deepEqual(txJson.transactionVersion, resources_1.txVersion);
+            should.deepEqual(txJson.chainName, resources_1.chainName);
+            should.deepEqual(txJson.eraPeriod, basecoin.SWEEP_TXN_DURATION);
+        });
+        it('should recover a txn for unsigned-sweep recoveries', async function () {
+            const res = await basecoin.recover({
+                bitgoKey: testData.wrwUser.bitgoKey,
+                recoveryDestination: destAddr,
+            });
+            res.should.not.be.empty();
+            res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');
+            res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('scanIndex');
+            sandBox.assert.calledOnce(basecoin.getAccountInfo);
+            sandBox.assert.calledOnce(basecoin.getHeaderInfo);
+            // deserialize the txn and verify the fields are what we expect
+            const txBuilder = basecoin.getBuilder().from(res.txRequests[0].transactions[0].unsignedTx.serializedTx);
+            // some information isn't deserialized by the from method, so we will
+            // supply it again in order to re-build the txn
+            txBuilder
+                .validity({
+                firstValid: testData.westendBlock.blockNumber,
+                maxDuration: basecoin.SWEEP_TXN_DURATION,
+            })
+                .referenceBlock(testData.westendBlock.hash)
+                .sender({ address: testData.wrwUser.walletAddress0 });
+            const tx = await txBuilder.build();
+            const txJson = tx.toJson();
+            should.deepEqual(txJson.sender, testData.wrwUser.walletAddress0);
+            should.deepEqual(txJson.blockNumber, testData.westendBlock.blockNumber);
+            should.deepEqual(txJson.referenceBlock, testData.westendBlock.hash);
+            should.deepEqual(txJson.genesisHash, resources_1.genesisHash);
+            should.deepEqual(txJson.specVersion, resources_1.specVersion);
+            should.deepEqual(txJson.nonce, nonce);
+            should.deepEqual(txJson.tip, 0);
+            should.deepEqual(txJson.transactionVersion, resources_1.txVersion);
+            should.deepEqual(txJson.chainName, resources_1.chainName);
+            should.deepEqual(txJson.eraPeriod, basecoin.SWEEP_TXN_DURATION);
+            const extras = lib_1.SingletonRegistry.getInstance(utils_1.default.getMaterial(statics_1.coins.get('tdot')))
+                .createType('ExtrinsicPayload', res.txRequests[0].transactions[0].unsignedTx.serializedTx, {
+                version: Extrinsic_1.EXTRINSIC_VERSION,
+            })
+                .toJSON();
+            should.equal(Number(extras.tip ?? 0), 0);
+            should.equal(Number(extras.mode ?? 0), 0);
+            should.equal(extras.assetId === null || extras.assetId === undefined, true, `expected ChargeAsset assetId None, got ${JSON.stringify(extras.assetId)}`);
+        });
+    });
+    describe('Recover Transactions (MPCv2):', () => {
+        const sandBox = sinon.createSandbox();
+        const destAddr = testData.accounts.account1.address;
+        const nonce = 123;
+        const walletPassphrase = testData.wrwUser.walletPassphrase;
+        let mpcV2UserKey;
+        let mpcV2BackupKey;
+        let mpcV2CommonKeyChain;
+        let mpcV2WalletAddress;
+        let mismatchedBitgoKey;
+        let mismatchedWalletAddress;
+        before(async function () {
+            const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+            const [otherUserDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+            mpcV2UserKey = await (0, sdk_api_1.encrypt)(walletPassphrase, userDkg.getReducedKeyShare().toString('base64'));
+            mpcV2BackupKey = await (0, sdk_api_1.encrypt)(walletPassphrase, backupDkg.getReducedKeyShare().toString('base64'));
+            mpcV2CommonKeyChain = userDkg.getCommonKeychain();
+            const mpc = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+            mpcV2WalletAddress = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/0').slice(0, 64));
+            mismatchedBitgoKey = otherUserDkg.getCommonKeychain();
+            mismatchedWalletAddress = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mismatchedBitgoKey, 'm/0').slice(0, 64));
+        });
+        beforeEach(function () {
+            const accountInfoCB = sandBox.stub(src_1.Dot.prototype, 'getAccountInfo');
+            accountInfoCB.withArgs(mpcV2WalletAddress).resolves({
+                nonce: nonce,
+                freeBalance: 1510000000000,
+            });
+            accountInfoCB.withArgs(mismatchedWalletAddress).resolves({
+                nonce: nonce,
+                freeBalance: 1510000000000,
+            });
+            const headerInfoCB = sandBox.stub(src_1.Dot.prototype, 'getHeaderInfo');
+            headerInfoCB.resolves({
+                headerNumber: testData.westendBlock.blockNumber,
+                headerHash: testData.westendBlock.hash,
+            });
+            const getFeeCB = sandBox.stub(src_1.Dot.prototype, 'getFee');
+            getFeeCB.resolves(15783812856);
+            const getMaterialCB = sandBox.stub(src_1.Dot.prototype, 'getMaterial');
+            getMaterialCB.resolves(utils_1.default.getMaterial(statics_1.coins.get('tdot')));
+        });
+        afterEach(function () {
+            sandBox.restore();
+        });
+        it('should route to MPCv2 path for native DOT recovery when keycard is MPCv2', async function () {
+            const getTSSSignatureSpy = sandBox.spy(sdk_core_1.EDDSAMethods, 'getTSSSignature');
+            const res = (await basecoin.recover({
+                userKey: mpcV2UserKey,
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                recoveryDestination: destAddr,
+            }));
+            res.should.not.be.empty();
+            res.should.hasOwnProperty('serializedTx');
+            res.should.hasOwnProperty('scanIndex');
+            should.equal(res.scanIndex, 0);
+            sandBox.assert.calledOnce(basecoin.getAccountInfo);
+            sandBox.assert.notCalled(getTSSSignatureSpy);
+        });
+        it('should throw when MPCv2 commonKeyChain does not match bitgoKey', async function () {
+            await basecoin
+                .recover({
+                userKey: mpcV2UserKey,
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mismatchedBitgoKey,
+                walletPassphrase,
+                recoveryDestination: destAddr,
+            })
+                .should.be.rejectedWith('EdDSA MPCv2 recovery: commonKeyChain from keycard does not match bitgoKey');
+        });
+        it('should throw missing userKey when backupKey and walletPassphrase are present but userKey is not', async function () {
+            await basecoin
+                .recover({
+                userKey: undefined,
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                recoveryDestination: destAddr,
+            })
+                .should.be.rejectedWith('missing userKey');
+        });
+        it('should throw missing backupKey when userKey and walletPassphrase are present but backupKey is not', async function () {
+            await basecoin
+                .recover({
+                userKey: mpcV2UserKey,
+                backupKey: undefined,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                recoveryDestination: destAddr,
+            })
+                .should.be.rejectedWith('missing backupKey');
+        });
+        it('should throw missing wallet passphrase when userKey and backupKey are present but walletPassphrase is not', async function () {
+            await basecoin
+                .recover({
+                userKey: mpcV2UserKey,
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase: undefined,
+                recoveryDestination: destAddr,
+            })
+                .should.be.rejectedWith('missing wallet passphrase');
+        });
+        it('should still use the MPCv1 path (getTSSSignature) for MPCv1 JSON keycards', async function () {
+            const getTSSSignatureSpy = sandBox.spy(sdk_core_1.EDDSAMethods, 'getTSSSignature');
+            src_1.Dot.prototype.getAccountInfo
+                .withArgs(testData.wrwUser.walletAddress0)
+                .resolves({
+                nonce,
+                freeBalance: 1510000000000,
+            });
+            const result = (await basecoin.recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            }));
+            result.should.not.be.empty();
+            result.should.hasOwnProperty('serializedTx');
+            sandBox.assert.calledOnce(getTSSSignatureSpy);
+        });
+        it('should call getEddsaSigningMaterial exactly once per recover() call', async function () {
+            const getEddsaMaterialSpy = sandBox.spy(basecoin, 'getEddsaSigningMaterial');
+            const res = (await basecoin.recover({
+                userKey: mpcV2UserKey,
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                recoveryDestination: destAddr,
+            }));
+            res.should.not.be.empty();
+            sandBox.assert.calledOnce(getEddsaMaterialSpy);
+        });
+        it('should ignore a non-signing-material second arg (WRW openSSL WASM buffer)', async function () {
+            const getEddsaMaterialSpy = sandBox.spy(basecoin, 'getEddsaSigningMaterial');
+            const res = (await basecoin.recover({
+                userKey: mpcV2UserKey,
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                recoveryDestination: destAddr,
+            }, new ArrayBuffer(8)));
+            res.should.not.be.empty();
+            res.should.hasOwnProperty('serializedTx');
+            sandBox.assert.calledOnce(getEddsaMaterialSpy);
+        });
+    });
+    describe('Build Consolidation Recoveries:', () => {
+        const sandBox = sinon.createSandbox();
+        const baseAddr = testData.consolidationWrwUser.walletAddress0;
+        const nonce = 123;
+        beforeEach(function () {
+            const accountInfoCB = sandBox.stub(src_1.Dot.prototype, 'getAccountInfo');
+            accountInfoCB.withArgs(testData.consolidationWrwUser.walletAddress1).resolves({
+                nonce: nonce,
+                freeBalance: 10000000000,
+            });
+            accountInfoCB.withArgs(testData.consolidationWrwUser.walletAddress2).resolves({
+                nonce: nonce,
+                freeBalance: 1510000000000,
+            });
+            accountInfoCB.withArgs(testData.consolidationWrwUser.walletAddress3).resolves({
+                nonce: nonce,
+                freeBalance: 1510000000000,
+            });
+            const headerInfoCB = sandBox.stub(src_1.Dot.prototype, 'getHeaderInfo');
+            headerInfoCB.resolves({
+                headerNumber: testData.westendBlock.blockNumber,
+                headerHash: testData.westendBlock.hash,
+            });
+            const getFeeCB = sandBox.stub(src_1.Dot.prototype, 'getFee');
+            getFeeCB.withArgs(baseAddr, testData.consolidationWrwUser.walletAddress1, 10000000000).resolves(15783812856);
+            getFeeCB.withArgs(baseAddr, testData.consolidationWrwUser.walletAddress2, 1510000000000).resolves(15783812856);
+            getFeeCB.withArgs(baseAddr, testData.consolidationWrwUser.walletAddress3, 1510000000000).resolves(15783812856);
+            const getMaterialCB = sandBox.stub(src_1.Dot.prototype, 'getMaterial');
+            getMaterialCB.resolves(utils_1.default.getMaterial(statics_1.coins.get('tdot')));
+        });
+        afterEach(function () {
+            sandBox.restore();
+        });
+        // TODO(COIN-919): Fix failing test
+        xit('should build signed consolidation recoveries', async function () {
+            const res = await basecoin.recoverConsolidations({
+                userKey: testData.consolidationWrwUser.userKey,
+                backupKey: testData.consolidationWrwUser.backupKey,
+                bitgoKey: testData.consolidationWrwUser.bitgoKey,
+                walletPassphrase: testData.consolidationWrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            res.should.not.be.empty();
+            res.transactions.length.should.equal(2);
+            sandBox.assert.calledThrice(basecoin.getAccountInfo);
+            sandBox.assert.calledTwice(basecoin.getHeaderInfo);
+            const txn1 = res.transactions[0];
+            txn1.should.hasOwnProperty('serializedTx');
+            txn1.should.hasOwnProperty('scanIndex');
+            txn1.scanIndex.should.equal(2);
+            // deserialize the txn and verify the fields are what we expect
+            const txBuilder1 = basecoin.getBuilder().from(txn1.serializedTx);
+            // some information isn't deserialized by the from method, so we will
+            // supply it again in order to re-build the txn
+            txBuilder1
+                .validity({
+                firstValid: testData.westendBlock.blockNumber,
+                maxDuration: basecoin.MAX_VALIDITY_DURATION,
+            })
+                .referenceBlock(testData.westendBlock.hash);
+            const tx1 = await txBuilder1.build();
+            const txJson1 = tx1.toJson();
+            should.deepEqual(txJson1.sender, testData.consolidationWrwUser.walletAddress2);
+            should.deepEqual(txJson1.blockNumber, testData.westendBlock.blockNumber);
+            should.deepEqual(txJson1.referenceBlock, testData.westendBlock.hash);
+            should.deepEqual(txJson1.genesisHash, resources_1.genesisHash);
+            should.deepEqual(txJson1.specVersion, resources_1.specVersion);
+            should.deepEqual(txJson1.nonce, nonce);
+            should.deepEqual(txJson1.tip, 0);
+            should.deepEqual(txJson1.transactionVersion, resources_1.txVersion);
+            should.deepEqual(txJson1.chainName, resources_1.chainName);
+            // eraPeriod will always round to the next upper power of 2 for any input value, in this case 2400.
+            // 4096 is the "highest" value you can set, but the txn still may fail after 2400 blocks.
+            const eraPeriod = 4096;
+            should.deepEqual(txJson1.eraPeriod, eraPeriod);
+            should.deepEqual(txJson1.to, baseAddr);
+            res.lastScanIndex.should.equal(3);
+            const txn2 = res.transactions[1];
+            txn2.should.hasOwnProperty('serializedTx');
+            txn2.should.hasOwnProperty('scanIndex');
+            txn2.scanIndex.should.equal(3);
+            // deserialize the txn and verify the fields are what we expect
+            const txBuilder2 = basecoin.getBuilder().from(txn2.serializedTx);
+            // some information isn't deserialized by the from method, so we will
+            // supply it again in order to re-build the txn
+            txBuilder2
+                .validity({
+                firstValid: testData.westendBlock.blockNumber,
+                maxDuration: basecoin.MAX_VALIDITY_DURATION,
+            })
+                .referenceBlock(testData.westendBlock.hash);
+            const tx2 = await txBuilder2.build();
+            const txJson2 = tx2.toJson();
+            should.deepEqual(txJson2.sender, testData.consolidationWrwUser.walletAddress3);
+            should.deepEqual(txJson2.blockNumber, testData.westendBlock.blockNumber);
+            should.deepEqual(txJson2.referenceBlock, testData.westendBlock.hash);
+            should.deepEqual(txJson2.genesisHash, resources_1.genesisHash);
+            should.deepEqual(txJson2.specVersion, resources_1.specVersion);
+            should.deepEqual(txJson2.nonce, nonce);
+            should.deepEqual(txJson2.tip, 0);
+            should.deepEqual(txJson2.transactionVersion, resources_1.txVersion);
+            should.deepEqual(txJson2.chainName, resources_1.chainName);
+            should.deepEqual(txJson2.eraPeriod, eraPeriod);
+            should.deepEqual(txJson2.to, baseAddr);
+        });
+        it('should build unsigned consolidation recoveries', async function () {
+            const res = await basecoin.recoverConsolidations({
+                bitgoKey: testData.consolidationWrwUser.bitgoKey,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            res.should.not.be.empty();
+            res.txRequests.length.should.equal(2);
+            sandBox.assert.calledThrice(basecoin.getAccountInfo);
+            sandBox.assert.calledTwice(basecoin.getHeaderInfo);
+            const txn1 = res.txRequests[0].transactions[0].unsignedTx;
+            txn1.should.hasOwnProperty('serializedTx');
+            txn1.should.hasOwnProperty('signableHex');
+            txn1.should.hasOwnProperty('scanIndex');
+            txn1.scanIndex.should.equal(2);
+            txn1.should.hasOwnProperty('coin');
+            txn1.coin.should.equal('tdot');
+            txn1.should.hasOwnProperty('derivationPath');
+            txn1.derivationPath.should.equal('m/2');
+            txn1.should.hasOwnProperty('coinSpecific');
+            const coinSpecific1 = txn1.coinSpecific;
+            coinSpecific1.should.hasOwnProperty('commonKeychain');
+            coinSpecific1.should.hasOwnProperty('firstValid');
+            coinSpecific1.firstValid.should.equal(testData.westendBlock.blockNumber);
+            coinSpecific1.should.hasOwnProperty('maxDuration');
+            coinSpecific1.maxDuration.should.equal(basecoin.MAX_VALIDITY_DURATION);
+            // deserialize the txn and verify the fields are what we expect
+            const txBuilder1 = basecoin.getBuilder().from(txn1.serializedTx);
+            // some information isn't deserialized by the from method, so we will
+            // supply it again in order to re-build the txn
+            txBuilder1
+                .validity({
+                firstValid: testData.westendBlock.blockNumber,
+                maxDuration: basecoin.MAX_VALIDITY_DURATION,
+            })
+                .referenceBlock(testData.westendBlock.hash)
+                .sender({ address: testData.consolidationWrwUser.walletAddress2 });
+            const tx1 = await txBuilder1.build();
+            const txJson1 = tx1.toJson();
+            should.deepEqual(txJson1.sender, testData.consolidationWrwUser.walletAddress2);
+            should.deepEqual(txJson1.blockNumber, testData.westendBlock.blockNumber);
+            should.deepEqual(txJson1.referenceBlock, testData.westendBlock.hash);
+            should.deepEqual(txJson1.genesisHash, resources_1.genesisHash);
+            should.deepEqual(txJson1.specVersion, resources_1.specVersion);
+            should.deepEqual(txJson1.nonce, nonce);
+            should.deepEqual(txJson1.tip, 0);
+            should.deepEqual(txJson1.transactionVersion, resources_1.txVersion);
+            should.deepEqual(txJson1.chainName, resources_1.chainName);
+            // eraPeriod will always round to the next upper power of 2 for any input value, in this case 2400.
+            // 4096 is the "highest" value you can set, but the txn still may fail after 2400 blocks.
+            const eraPeriod = 4096;
+            should.deepEqual(txJson1.eraPeriod, eraPeriod);
+            should.deepEqual(txJson1.to, baseAddr);
+            const txn2 = res.txRequests[1].transactions[0].unsignedTx;
+            txn2.should.hasOwnProperty('serializedTx');
+            txn2.should.hasOwnProperty('signableHex');
+            txn2.should.hasOwnProperty('scanIndex');
+            txn2.scanIndex.should.equal(3);
+            txn2.should.hasOwnProperty('coin');
+            txn2.coin.should.equal('tdot');
+            txn2.should.hasOwnProperty('derivationPath');
+            txn2.derivationPath.should.equal('m/3');
+            txn2.should.hasOwnProperty('coinSpecific');
+            const coinSpecific2 = txn2.coinSpecific;
+            coinSpecific2.should.hasOwnProperty('commonKeychain');
+            coinSpecific2.should.hasOwnProperty('firstValid');
+            coinSpecific2.firstValid.should.equal(testData.westendBlock.blockNumber);
+            coinSpecific2.should.hasOwnProperty('maxDuration');
+            coinSpecific2.maxDuration.should.equal(basecoin.MAX_VALIDITY_DURATION);
+            coinSpecific2.should.hasOwnProperty('commonKeychain');
+            coinSpecific2.should.hasOwnProperty('lastScanIndex');
+            coinSpecific2.lastScanIndex.should.equal(3);
+            // deserialize the txn and verify the fields are what we expect
+            const txBuilder2 = basecoin.getBuilder().from(txn2.serializedTx);
+            // some information isn't deserialized by the from method, so we will
+            // supply it again in order to re-build the txn
+            txBuilder2
+                .validity({
+                firstValid: testData.westendBlock.blockNumber,
+                maxDuration: basecoin.MAX_VALIDITY_DURATION,
+            })
+                .referenceBlock(testData.westendBlock.hash)
+                .sender({ address: testData.consolidationWrwUser.walletAddress3 });
+            const tx2 = await txBuilder2.build();
+            const txJson2 = tx2.toJson();
+            should.deepEqual(txJson2.sender, testData.consolidationWrwUser.walletAddress3);
+            should.deepEqual(txJson2.blockNumber, testData.westendBlock.blockNumber);
+            should.deepEqual(txJson2.referenceBlock, testData.westendBlock.hash);
+            should.deepEqual(txJson2.genesisHash, resources_1.genesisHash);
+            should.deepEqual(txJson2.specVersion, resources_1.specVersion);
+            should.deepEqual(txJson2.nonce, nonce);
+            should.deepEqual(txJson2.tip, 0);
+            should.deepEqual(txJson2.transactionVersion, resources_1.txVersion);
+            should.deepEqual(txJson2.chainName, resources_1.chainName);
+            should.deepEqual(txJson2.eraPeriod, eraPeriod);
+            should.deepEqual(txJson2.to, baseAddr);
+        });
+        it('should skip building consolidate transaction if balance is equal to zero', async function () {
+            await basecoin
+                .recoverConsolidations({
+                userKey: testData.consolidationWrwUser.userKey,
+                backupKey: testData.consolidationWrwUser.backupKey,
+                bitgoKey: testData.consolidationWrwUser.bitgoKey,
+                walletPassphrase: testData.consolidationWrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 2,
+            })
+                .should.rejectedWith('Did not find an address with funds to recover');
+        });
+        it('should throw if startingScanIndex is not ge to 1', async () => {
+            await basecoin
+                .recoverConsolidations({
+                userKey: testData.consolidationWrwUser.userKey,
+                backupKey: testData.consolidationWrwUser.backupKey,
+                bitgoKey: testData.consolidationWrwUser.bitgoKey,
+                startingScanIndex: -1,
+            })
+                .should.be.rejectedWith('Invalid starting or ending index to scan for addresses. startingScanIndex: -1, endingScanIndex: 19.');
+        });
+        it('should throw if scan factor is too high', async () => {
+            await basecoin
+                .recoverConsolidations({
+                userKey: testData.consolidationWrwUser.userKey,
+                backupKey: testData.consolidationWrwUser.backupKey,
+                bitgoKey: testData.consolidationWrwUser.bitgoKey,
+                startingScanIndex: 1,
+                endingScanIndex: 300,
+            })
+                .should.be.rejectedWith('Invalid starting or ending index to scan for addresses. startingScanIndex: 1, endingScanIndex: 300.');
+        });
+    });
+    describe('Build Consolidation Recoveries (MPCv2):', () => {
+        const sandBox = sinon.createSandbox();
+        const nonce = 123;
+        const walletPassphrase = testData.wrwUser.walletPassphrase;
+        let mpcV2UserKey;
+        let mpcV2BackupKey;
+        let mpcV2CommonKeyChain;
+        let baseAddr;
+        let mpcV2Address1;
+        let mpcV2Address2;
+        let mpcV2Address3;
+        before(async function () {
+            const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+            mpcV2UserKey = await (0, sdk_api_1.encrypt)(walletPassphrase, userDkg.getReducedKeyShare().toString('base64'));
+            mpcV2BackupKey = await (0, sdk_api_1.encrypt)(walletPassphrase, backupDkg.getReducedKeyShare().toString('base64'));
+            mpcV2CommonKeyChain = userDkg.getCommonKeychain();
+            const mpc = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+            baseAddr = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/0').slice(0, 64));
+            mpcV2Address1 = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/1').slice(0, 64));
+            mpcV2Address2 = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/2').slice(0, 64));
+            mpcV2Address3 = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/3').slice(0, 64));
+        });
+        beforeEach(function () {
+            const accountInfoCB = sandBox.stub(src_1.Dot.prototype, 'getAccountInfo');
+            accountInfoCB.withArgs(mpcV2Address1).resolves({ nonce, freeBalance: 0 });
+            accountInfoCB.withArgs(mpcV2Address2).resolves({ nonce, freeBalance: 1510000000000 });
+            accountInfoCB.withArgs(mpcV2Address3).resolves({ nonce, freeBalance: 1510000000000 });
+            const headerInfoCB = sandBox.stub(src_1.Dot.prototype, 'getHeaderInfo');
+            headerInfoCB.resolves({
+                headerNumber: testData.westendBlock.blockNumber,
+                headerHash: testData.westendBlock.hash,
+            });
+            const getFeeCB = sandBox.stub(src_1.Dot.prototype, 'getFee');
+            getFeeCB.resolves(15783812856);
+            const getMaterialCB = sandBox.stub(src_1.Dot.prototype, 'getMaterial');
+            getMaterialCB.resolves(utils_1.default.getMaterial(statics_1.coins.get('tdot')));
+        });
+        afterEach(function () {
+            sandBox.restore();
+        });
+        it('should build MPCv2 signed consolidation recoveries across 2+ funded indexes, sweeping to the MPCv2 base address', async function () {
+            const getEddsaMaterialSpy = sandBox.spy(basecoin, 'getEddsaSigningMaterial');
+            const res = (await basecoin.recoverConsolidations({
+                userKey: mpcV2UserKey,
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            }));
+            res.should.not.be.empty();
+            res.transactions.length.should.equal(2);
+            should.equal(res.lastScanIndex, 3);
+            const txBuilder1 = basecoin.getBuilder().from(res.transactions[0].serializedTx);
+            txBuilder1
+                .validity({ firstValid: testData.westendBlock.blockNumber, maxDuration: basecoin.MAX_VALIDITY_DURATION })
+                .referenceBlock(testData.westendBlock.hash);
+            const tx1 = await txBuilder1.build();
+            should.deepEqual(tx1.toJson().to, baseAddr);
+            // recoverConsolidations must detect signing material exactly once at the top of the scan
+            // loop, not per-iteration inside recover() — precomputedMaterial bypasses per-call detection.
+            sandBox.assert.calledOnce(getEddsaMaterialSpy);
+        });
+        it('should call getEddsaSigningMaterial exactly once across all recover() iterations', async function () {
+            const getEddsaMaterialSpy = sandBox.spy(basecoin, 'getEddsaSigningMaterial');
+            await basecoin.recoverConsolidations({
+                userKey: mpcV2UserKey,
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            sandBox.assert.calledOnce(getEddsaMaterialSpy);
+        });
+        it('should leave MPCv1 base address derivation and signing unchanged (regression)', async function () {
+            const baseAddrV1 = testData.consolidationWrwUser.walletAddress0;
+            basecoin.getAccountInfo.withArgs(testData.consolidationWrwUser.walletAddress1).resolves({
+                nonce,
+                freeBalance: 10000000000,
+            });
+            basecoin.getAccountInfo.withArgs(testData.consolidationWrwUser.walletAddress2).resolves({
+                nonce,
+                freeBalance: 1510000000000,
+            });
+            const getTSSSignatureSpy = sandBox.spy(sdk_core_1.EDDSAMethods, 'getTSSSignature');
+            const res = (await basecoin.recoverConsolidations({
+                userKey: testData.consolidationWrwUser.userKey,
+                backupKey: testData.consolidationWrwUser.backupKey,
+                bitgoKey: testData.consolidationWrwUser.bitgoKey,
+                walletPassphrase: testData.consolidationWrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 3,
+            }));
+            res.should.not.be.empty();
+            sandBox.assert.calledOnce(getTSSSignatureSpy);
+            const txBuilder1 = basecoin.getBuilder().from(res.transactions[0].serializedTx);
+            txBuilder1
+                .validity({ firstValid: testData.westendBlock.blockNumber, maxDuration: basecoin.MAX_VALIDITY_DURATION })
+                .referenceBlock(testData.westendBlock.hash);
+            const tx1 = await txBuilder1.build();
+            should.deepEqual(tx1.toJson().to, baseAddrV1);
+        });
+        it('should leave the unsigned (no passphrase) cold path unchanged when keycard is MPCv2', async function () {
+            const res = (await basecoin.recoverConsolidations({
+                bitgoKey: mpcV2CommonKeyChain,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            }));
+            res.should.not.be.empty();
+            res.txRequests.length.should.equal(2);
+        });
+    });
+    describe('Recover Transaction Failures:', () => {
+        const sandBox = sinon.createSandbox();
+        const destAddr = testData.accounts.account1.address;
+        const nonce = 123;
+        beforeEach(function () {
+            const accountInfoCB = sandBox.stub(src_1.Dot.prototype, 'getAccountInfo');
+            accountInfoCB.resolves({
+                nonce: nonce,
+                freeBalance: 0,
+            });
+            const getFeeCB = sandBox.stub(src_1.Dot.prototype, 'getFee');
+            getFeeCB.resolves(15783812856);
+        });
+        afterEach(function () {
+            sandBox.restore();
+        });
+        it('should fail to recover due to not finding an address with funds', async function () {
+            await basecoin
+                .recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            })
+                .should.rejectedWith('Did not find address with funds to recover');
+        });
+    });
+    describe('Verify Transaction', function () {
+        const address1 = '5Ge59qRnZa8bxyhVFE6BDoY3kuhSrNVETRxXYLty1Hh6XTaf';
+        const address2 = '5DiMLZugmcKEH3igPZP367FqummZkWeW5Z6zDCHLfxRjnPXe';
+        it('should reject a txPrebuild with more than one recipient', async function () {
+            const wallet = new sdk_core_1.Wallet(bitgo, basecoin, {});
+            const txParams = {
+                recipients: [
+                    { amount: '1000000000000', address: address1 },
+                    { amount: '2500000000000', address: address2 },
+                ],
+                wallet: wallet,
+                walletPassphrase: 'fakeWalletPassphrase',
+            };
+            const txPrebuild = {
+                txHex: '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',
+            };
+            await basecoin
+                .verifyTransaction({ txPrebuild, txParams })
+                .should.be.rejectedWith(`tdot doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`);
+        });
+        it('should reject a txPrebuild with more than invalid amount', async function () {
+            const wallet = new sdk_core_1.Wallet(bitgo, basecoin, {});
+            const txParams = {
+                recipients: [{ amount: '20000000000', address: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD' }],
+                wallet: wallet,
+                walletPassphrase: 'fakeWalletPassphrase',
+            };
+            const txPrebuild = {
+                txHex: '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',
+            };
+            await basecoin
+                .verifyTransaction({ txPrebuild, txParams })
+                .should.be.rejectedWith(`Recipient amount 20000000000 does not match transaction amount 2000000000000`);
+        });
+        it('should reject a txPrebuild with more than invalid recipient', async function () {
+            const wallet = new sdk_core_1.Wallet(bitgo, basecoin, {});
+            const txParams = {
+                recipients: [{ amount: '2000000000000', address: '5CZh773vKGwKFCUjGc31AwXCbf7TPkavduk2XoujJMjbBD' }],
+                wallet: wallet,
+                walletPassphrase: 'fakeWalletPassphrase',
+            };
+            const txPrebuild = {
+                txHex: '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',
+            };
+            await basecoin
+                .verifyTransaction({ txPrebuild, txParams })
+                .should.be.rejectedWith(`Recipient address 5CZh773vKGwKFCUjGc31AwXCbf7TPkavduk2XoujJMjbBD does not match transaction destination address 5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD`);
+        });
+        it('should accept a txPrebuild with more than valid recipient and amount', async function () {
+            const wallet = new sdk_core_1.Wallet(bitgo, basecoin, {});
+            const txParams = {
+                recipients: [{ amount: '2000000000000', address: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD' }],
+                wallet: wallet,
+                walletPassphrase: 'fakeWalletPassphrase',
+            };
+            const txPrebuild = {
+                txHex: '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',
+            };
+            const result = await basecoin.verifyTransaction({ txPrebuild, txParams });
+            assert.strictEqual(result, true);
+        });
+        it('should verify a valid consolidation transaction', async function () {
+            const mockedWallet = {
+                coinSpecific: () => ({
+                    baseAddress: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD',
+                }),
+            };
+            const txPrebuild = {
+                txHex: '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',
+            };
+            const result = await basecoin.verifyTransaction({
+                txPrebuild,
+                txParams: {},
+                wallet: mockedWallet,
+                verification: {
+                    consolidationToBaseAddress: true,
+                },
+            });
+            assert.strictEqual(result, true);
+        });
+        it('should reject a consolidation transaction with invalid destination address', async function () {
+            const mockedWallet = {
+                coinSpecific: () => ({
+                    baseAddress: '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74',
+                }),
+            };
+            const txPrebuild = {
+                txHex: '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',
+            };
+            await basecoin
+                .verifyTransaction({
+                txPrebuild,
+                txParams: {},
+                wallet: mockedWallet,
+                verification: {
+                    consolidationToBaseAddress: true,
+                },
+            })
+                .should.be.rejectedWith('Transaction destination address 5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD does not match wallet base address 5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74');
+        });
+        it('should verify a transferAll (sweep) transaction with empty txParams', async function () {
+            const mockedWallet = {
+                coinSpecific: () => ({
+                    baseAddress: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq',
+                }),
+            };
+            // TransferAll tx (sweep) - uses method 0a04 (balances.transferAll)
+            const txPrebuild = {
+                txHex: '0x900a04009f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f025401d50121030000009d880f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d00',
+            };
+            const result = await basecoin.verifyTransaction({
+                txPrebuild,
+                txParams: {},
+                wallet: mockedWallet,
+                verification: {
+                    consolidationToBaseAddress: true,
+                },
+            });
+            assert.strictEqual(result, true);
+        });
+        it('should verify a transferAll (sweep) transaction with recipients in txParams', async function () {
+            const mockedWallet = {
+                coinSpecific: () => ({
+                    baseAddress: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq',
+                }),
+            };
+            // TransferAll tx (sweep) - _amount is undefined for these transactions
+            const txPrebuild = {
+                txHex: '0x900a04009f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f025401d50121030000009d880f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d00',
+            };
+            const txParams = {
+                recipients: [{ address: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq', amount: '1000000000000' }],
+            };
+            const result = await basecoin.verifyTransaction({
+                txPrebuild,
+                txParams,
+                wallet: mockedWallet,
+                verification: {
+                    consolidationToBaseAddress: true,
+                },
+            });
+            assert.strictEqual(result, true);
+        });
+        const wasmTransferKeepAliveHex = '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300';
+        const wasmTransferAllHex = '0x900a04009f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f025401d50121030000009d880f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d00';
+        it('should accept a valid WASM-built payment (tdot)', async function () {
+            const txParams = {
+                recipients: [{ amount: '2000000000000', address: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD' }],
+            };
+            const result = await basecoin.verifyTransaction({ txPrebuild: { txHex: wasmTransferKeepAliveHex }, txParams });
+            assert.strictEqual(result, true);
+        });
+        it('should reject WASM-built payment with wrong amount (tdot)', async function () {
+            const txParams = {
+                recipients: [{ amount: '9999', address: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD' }],
+            };
+            await basecoin
+                .verifyTransaction({ txPrebuild: { txHex: wasmTransferKeepAliveHex }, txParams })
+                .should.be.rejectedWith(/does not match transaction amount/);
+        });
+        it('should reject WASM-built payment with wrong recipient (tdot)', async function () {
+            const txParams = {
+                recipients: [{ amount: '2000000000000', address: '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74' }],
+            };
+            await basecoin
+                .verifyTransaction({ txPrebuild: { txHex: wasmTransferKeepAliveHex }, txParams })
+                .should.be.rejectedWith(/does not match transaction destination address/);
+        });
+        it('should verify WASM-built transferAll consolidation (tdot)', async function () {
+            const mockedWallet = {
+                coinSpecific: () => ({ baseAddress: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq' }),
+            };
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex: wasmTransferAllHex },
+                txParams: {},
+                wallet: mockedWallet,
+                verification: { consolidationToBaseAddress: true },
+            });
+            assert.strictEqual(result, true);
+        });
+        it('should verify WASM-built transferAll with recipients skips amount check (tdot)', async function () {
+            const mockedWallet = {
+                coinSpecific: () => ({ baseAddress: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq' }),
+            };
+            const txParams = {
+                recipients: [{ address: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq', amount: '999999' }],
+            };
+            const result = await basecoin.verifyTransaction({
+                txPrebuild: { txHex: wasmTransferAllHex },
+                txParams,
+                wallet: mockedWallet,
+                verification: { consolidationToBaseAddress: true },
+            });
+            assert.strictEqual(result, true);
+        });
+        it('should decode wasm-built signing payload with legacy TransactionBuilderFactory', async function () {
+            const { TransactionBuilderFactory } = await Promise.resolve().then(() => __importStar(require('../../src/lib')));
+            const factory = new TransactionBuilderFactory(statics_1.coins.get('tdot'));
+            const txBuilder = factory.from(wasmTransferKeepAliveHex);
+            txBuilder.sender({ address: '5EGoFA95omzemRssELLDjVenNZ68aXyUeqtKQScXSEBvVJkr' });
+            txBuilder.validity({ firstValid: 1000 });
+            txBuilder.referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d');
+            const tx = await txBuilder.build();
+            const json = tx.toJson();
+            assert.strictEqual(json.to, '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD');
+            assert.strictEqual(json.amount, '2000000000000');
+        });
+    });
+    describe('isWalletAddress', () => {
+        it('should verify valid wallet address with correct keychain and index', async function () {
+            const address = '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74';
+            const commonKeychain = '6d2d5150f6e435dfd9b4f225f2cc29d95ec3b61b34e8bec98693b1a7ffe44cd764f99ee5058838d785c73360ad4f24d78e0255ab2c368c09060b29a9b27f040e';
+            const index = '3';
+            const keychains = [{ id: '1', type: 'tss', commonKeychain }];
+            const result = await basecoin.isWalletAddress({ keychains, address, index });
+            result.should.equal(true);
+        });
+        it('should return false for address with incorrect keychain', async function () {
+            const address = '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74';
+            const wrongKeychain = '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';
+            const index = '3';
+            const keychains = [{ id: '1', type: 'tss', commonKeychain: wrongKeychain }];
+            const result = await basecoin.isWalletAddress({ keychains, address, index });
+            result.should.equal(false);
+        });
+        it('should return false for address with incorrect index', async function () {
+            const address = '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74';
+            const commonKeychain = '6d2d5150f6e435dfd9b4f225f2cc29d95ec3b61b34e8bec98693b1a7ffe44cd764f99ee5058838d785c73360ad4f24d78e0255ab2c368c09060b29a9b27f040e';
+            const wrongIndex = '999';
+            const keychains = [{ id: '1', type: 'tss', commonKeychain }];
+            const result = await basecoin.isWalletAddress({ keychains, address, index: wrongIndex });
+            result.should.equal(false);
+        });
+        it('should throw error for invalid address', async function () {
+            const invalidAddress = 'invalidaddress';
+            const commonKeychain = '6d2d5150f6e435dfd9b4f225f2cc29d95ec3b61b34e8bec98693b1a7ffe44cd764f99ee5058838d785c73360ad4f24d78e0255ab2c368c09060b29a9b27f040e';
+            const index = '3';
+            const keychains = [{ id: '1', type: 'tss', commonKeychain }];
+            await assert.rejects(async () => await basecoin.isWalletAddress({ keychains, address: invalidAddress, index }), {
+                message: `invalid address: ${invalidAddress}`,
+            });
+        });
+    });
+    describe('getAddressFromPublicKey', () => {
+        it('should convert public key to SS58 address for testnet', function () {
+            const publicKey = '53845d7b6a6e4a666fa2a0f500b88849b02926da5590993731d2b428b7643690';
+            const expectedAddress = '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74';
+            const address = basecoin.getAddressFromPublicKey(publicKey);
+            address.should.equal(expectedAddress);
+        });
+        it('should convert public key to SS58 address for mainnet', function () {
+            const publicKey = '53845d7b6a6e4a666fa2a0f500b88849b02926da5590993731d2b428b7643690';
+            // Mainnet uses different SS58 prefix (0) vs testnet (42)
+            const address = prodCoin.getAddressFromPublicKey(publicKey);
+            address.should.be.type('string');
+            address.length.should.be.greaterThan(0);
+            // Should be different from testnet address
+            address.should.not.equal('5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74');
+        });
+    });
+    describe('createBroadcastableSweepTransaction (MPCv2):', () => {
+        const sandBox = sinon.createSandbox();
+        let userKeyShare;
+        let backupKeyShare;
+        let commonKeychain;
+        let mpcv2SweepTxRequest;
+        let mpcv2SignatureHex;
+        before(async function () {
+            const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+            commonKeychain = userDkg.getCommonKeychain();
+            userKeyShare = userDkg.getKeyShare();
+            backupKeyShare = backupDkg.getKeyShare();
+            const accountInfoCB = sandBox.stub(src_1.Dot.prototype, 'getAccountInfo');
+            accountInfoCB.resolves({ nonce: 123, freeBalance: 1510000000000 });
+            const headerInfoCB = sandBox.stub(src_1.Dot.prototype, 'getHeaderInfo');
+            headerInfoCB.resolves({
+                headerNumber: testData.westendBlock.blockNumber,
+                headerHash: testData.westendBlock.hash,
+            });
+            const getFeeCB = sandBox.stub(src_1.Dot.prototype, 'getFee');
+            getFeeCB.resolves(15783812856);
+            const getMaterialCB = sandBox.stub(src_1.Dot.prototype, 'getMaterial');
+            getMaterialCB.resolves(utils_1.default.getMaterial(statics_1.coins.get('tdot')));
+            // no walletPassphrase -> unsigned sweep path returns MPCSweepTxs
+            const sweep = (await basecoin.recover({
+                bitgoKey: commonKeychain,
+                recoveryDestination: testData.accounts.account1.address,
+            }));
+            sandBox.restore();
+            mpcv2SweepTxRequest = sweep.txRequests[0];
+            const unsignedTx = mpcv2SweepTxRequest.transactions[0].unsignedTx;
+            const signature = await (0, sdk_core_1.signRecoveryEddsaMPCv2)(Buffer.from(unsignedTx.signableHex, 'hex'), unsignedTx.derivationPath, userKeyShare, backupKeyShare, commonKeychain);
+            mpcv2SignatureHex = signature.toString('hex');
+        });
+        function buildParams(ovc) {
+            return {
+                signatureShares: [
+                    {
+                        txRequest: mpcv2SweepTxRequest,
+                        tssVersion: '0.0.1',
+                        ovc: [ovc],
+                    },
+                ],
+            };
+        }
+        it('should take MPCv2 OVC output and generate a signed sweep transaction', async function () {
+            const params = buildParams({ eddsaMpcv2Signature: mpcv2SignatureHex });
+            const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);
+            recoveryTxn.transactions[0].serializedTx.should.not.equal(mpcv2SweepTxRequest.transactions[0].unsignedTx.serializedTx);
+            recoveryTxn.transactions[0].serializedTx.should.not.be.empty();
+            (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(0);
+            (recoveryTxn.lastScanIndex ?? 0).should.equal(0);
+        });
+        it('should reject a tampered MPCv2 signature', async function () {
+            const unsignedTx = mpcv2SweepTxRequest.transactions[0].unsignedTx;
+            const tamperedMessage = Buffer.concat([Buffer.from(unsignedTx.signableHex, 'hex'), Buffer.from('00', 'hex')]);
+            const tamperedSignature = await (0, sdk_core_1.signRecoveryEddsaMPCv2)(tamperedMessage, unsignedTx.derivationPath, userKeyShare, backupKeyShare, commonKeychain);
+            await basecoin
+                .createBroadcastableSweepTransaction(buildParams({ eddsaMpcv2Signature: tamperedSignature.toString('hex') }))
+                .should.be.rejectedWith('Invalid signature');
+        });
+        it('should throw when MPCv2 OVC is missing signature(s)', async function () {
+            await basecoin
+                .createBroadcastableSweepTransaction(buildParams({}))
+                .should.be.rejectedWith('Missing signature(s)');
+        });
+        it('should route MPCv1-shaped ovc to the MPCv1 verify branch and reject an invalid signature', async function () {
+            const mpc = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+            const derivedPubKey = mpc.deriveUnhardened(commonKeychain, 'm/0').slice(0, 64);
+            await basecoin
+                .createBroadcastableSweepTransaction(buildParams({
+                eddsaSignature: { R: '00'.repeat(32), sigma: '00'.repeat(32), y: derivedPubKey },
+            }))
+                .should.be.rejectedWith('Invalid signature');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dot.js","sourceRoot":"","sources":["../../../../test/unit/dot.ts"],"names":[],"mappings":"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","sourcesContent":["import { BitGoAPI, encrypt } from '@bitgo-beta/sdk-api';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { randomBytes } from 'crypto';\nimport should = require('should');\nimport assert = require('assert');\nimport { Dot, Tdot, KeyPair } from '../../src';\nimport * as testData from '../fixtures';\nimport { chainName, txVersion, genesisHash, specVersion } from '../resources';\nimport * as sinon from 'sinon';\nimport {\n  EDDSAMethods,\n  MPCSweepRecoveryOptions,\n  MPCSweepTxs,\n  MPCTx,\n  MPCTxs,\n  signRecoveryEddsaMPCv2,\n  TransactionType,\n  Wallet,\n} from '@bitgo-beta/sdk-core';\nimport { coins } from '@bitgo-beta/statics';\nimport { buildTransaction, type BuildContext, type Material } from '@bitgo/wasm-dot';\nimport { MPSUtil } from '@bitgo-beta/sdk-lib-mpc';\nimport { EXTRINSIC_VERSION } from '@polkadot/types/extrinsic/v4/Extrinsic';\nimport utils from '../../src/lib/utils';\nimport { explainDotTransaction, SingletonRegistry } from '../../src/lib';\n\ndescribe('DOT:', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin;\n  let prodCoin;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('dot', Dot.createInstance);\n    bitgo.safeRegister('tdot', Tdot.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('tdot');\n    prodCoin = bitgo.coin('dot');\n  });\n\n  describe('Sign Message', () => {\n    it('should be performed', async () => {\n      const keyPair = new KeyPair();\n      const messageToSign = Buffer.from(randomBytes(32)).toString('hex');\n      const signature = await basecoin.signMessage(keyPair.getKeys(), messageToSign);\n      keyPair.verifySignature(messageToSign, Uint8Array.from(signature)).should.equals(true);\n    });\n\n    it('should fail with missing private key', async () => {\n      const keyPair = new KeyPair({\n        pub: '7788327c695dca4b3e649a0db45bc3e703a2c67428fce360e61800cc4248f4f7',\n      }).getKeys();\n      const messageToSign = Buffer.from(randomBytes(32)).toString('hex');\n      await basecoin.signMessage(keyPair, messageToSign).should.be.rejectedWith('Invalid key pair options');\n    });\n  });\n\n  describe('Sign transaction', () => {\n    const transaction = {\n      id: '0x19de156328eea66bd1ec45843569c168e0bb2f2898221029b403df3f23a5489d',\n      sender: '5EGoFA95omzemRssELLDjVenNZ68aXyUeqtKQScXSEBvVJkr',\n      referenceBlock: '0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d',\n      blockNumber: 3933,\n      genesisHash: '0x67f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9',\n      nonce: 200,\n      specVersion: 1018013,\n      transactionVersion: 16,\n      eraPeriod: 64,\n      chainName: 'Westend Asset Hub',\n      tip: 0,\n      to: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq',\n      amount: '10000000000',\n    };\n\n    // TODO: BG-43197\n    xit('should sign transaction', async function () {\n      const signed = await basecoin.signTransaction({\n        txPrebuild: {\n          txHex: testData.rawTx.transfer.unsigned,\n          transaction,\n        },\n        pubs: [testData.accounts.account1.publicKey],\n        prv: testData.accounts.account1.secretKey,\n      });\n      signed.txHex.should.equal(testData.rawTx.transfer.signed);\n    });\n\n    // TODO: BG-43197\n    xit('should fail to sign transaction with an invalid key', async function () {\n      try {\n        await basecoin.signTransaction({\n          txPrebuild: {\n            txHex: testData.rawTx.transfer.unsigned,\n            transaction,\n          },\n          pubs: [testData.accounts.account2.publicKey],\n          prv: testData.accounts.account1.secretKey,\n        });\n      } catch (e) {\n        should.equal(e.message, 'Private key cannot sign the transaction');\n      }\n    });\n\n    it('should fail to build transaction with missing params', async function () {\n      try {\n        await basecoin.signTransaction({\n          txPrebuild: {\n            txHex: testData.rawTx.transfer.unsigned,\n            key: testData.accounts.account1.publicKey,\n          },\n          prv: testData.accounts.account1.secretKey,\n        });\n      } catch (e) {\n        should.notEqual(e, null);\n      }\n    });\n  });\n\n  describe('Generate wallet key pair: ', () => {\n    it('should generate key pair', () => {\n      const kp = basecoin.generateKeyPair();\n      basecoin.isValidPub(kp.pub).should.equal(true);\n      basecoin.isValidPrv(kp.prv).should.equal(true);\n    });\n\n    it('should generate key pair from seed', () => {\n      const seed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');\n      const kp = basecoin.generateKeyPair(seed);\n      basecoin.isValidPub(kp.pub).should.equal(true);\n      basecoin.isValidPrv(kp.prv).should.equal(true);\n    });\n  });\n\n  describe('Balance Conversion', () => {\n    it('should return 10000000000 as tdot base factor', () => {\n      // mainnet uses 10 decimal places\n      const baseFactor = prodCoin.getBaseFactor();\n      baseFactor.should.equal(10000000000);\n    });\n\n    it('should return 1000000000000 as dot base factor', () => {\n      // westend (test polkadot) uses 12 decimal places\n      const baseFactor = basecoin.getBaseFactor();\n      baseFactor.should.equal(1000000000000);\n    });\n\n    it('should return 4 Dot when base unit is 40000000000 for dot', () => {\n      const bigUnit = prodCoin.baseUnitsToBigUnits('40000000000');\n      bigUnit.should.equal('4');\n    });\n\n    it('should return 0.04 Dot when base unit is 400000000 for dot', () => {\n      const bigUnit = prodCoin.baseUnitsToBigUnits('400000000');\n      bigUnit.should.equal('0.04');\n    });\n\n    it('should return 4 test Dot when base unit is 4000000000000 for tdot', () => {\n      const bigUnit = basecoin.baseUnitsToBigUnits('4000000000000');\n      bigUnit.should.equal('4');\n    });\n\n    it('should return 0.04 test Dot when base unit is 400000000 for tdot', () => {\n      const bigUnit = basecoin.baseUnitsToBigUnits('40000000000');\n      bigUnit.should.equal('0.04');\n    });\n  });\n\n  describe('Explain Transactions:', () => {\n    it('should explain an unsigned transfer transaction', async function () {\n      const explainedTransaction = await prodCoin.explainTransaction(testData.unsignedTransaction);\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'fee',\n          'type',\n          'sequenceId',\n          'id',\n          'blockNumber',\n        ],\n        sequenceId: 0,\n        fee: '10',\n        id: '0x0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8',\n        type: '0',\n        outputs: [\n          {\n            address: '5DkddSfPsWojjfuH9iJEcUV7ZseQ9EJ6RjtNmCR1w3CEb8S9',\n            valueString: '90034235235350',\n            coinName: 'tdot',\n            wallet: '62a1205751675b2f0fe72328',\n          },\n        ],\n        blockNumber: 8619307,\n        outputAmount: 90034235235350,\n        changeOutputs: [],\n        changeAmount: '0',\n      });\n    });\n  });\n\n  describe('Explain Transactions (WASM):', () => {\n    const coin = coins.get('tdot');\n    const material = utils.getMaterial(coin);\n    const SENDER = testData.accounts.account1.address;\n    const RECIPIENT = testData.accounts.account2.address;\n\n    function wasmContext(nonce = 0): BuildContext {\n      return {\n        sender: SENDER,\n        nonce,\n        material: material as Material,\n        validity: { firstValid: testData.westendBlock.blockNumber, maxDuration: 2400 },\n        referenceBlock: testData.westendBlock.hash,\n      };\n    }\n\n    it('should explain a transfer via explainDotTransaction', function () {\n      const tx = buildTransaction({ type: 'payment', to: RECIPIENT, amount: 1000000000000n }, wasmContext());\n      const explained = explainDotTransaction({\n        txHex: tx.toBroadcastFormat(),\n        material,\n        senderAddress: SENDER,\n      });\n\n      assert.strictEqual(explained.type, TransactionType.Send);\n      assert.strictEqual(explained.outputs.length, 1);\n      assert.strictEqual(explained.outputs[0].address, RECIPIENT);\n      assert.strictEqual(explained.outputs[0].amount, '1000000000000');\n      assert.strictEqual(explained.outputAmount, '1000000000000');\n      assert.strictEqual(explained.sender, SENDER);\n      assert.strictEqual(explained.methodName, 'balances.transferKeepAlive');\n    });\n\n    it('should explain a staking bond via explainDotTransaction', function () {\n      const tx = buildTransaction({ type: 'stake', amount: 5000000000000n, payee: { type: 'stash' } }, wasmContext(1));\n      const explained = explainDotTransaction({\n        txHex: tx.toBroadcastFormat(),\n        material,\n        senderAddress: SENDER,\n      });\n\n      assert.strictEqual(explained.type, TransactionType.StakingActivate);\n      assert.strictEqual(explained.outputs.length, 1);\n      // STAKING_DESTINATION: SS58(0x00..00) sentinel, bond doesn't transfer to an external address\n      assert.strictEqual(explained.outputs[0].address, '5C4hrfjw9DjXZTzV3MwzrrAr9P1MJhSrvWGWqi1eSuyUpnhM');\n      assert.strictEqual(explained.outputs[0].amount, '5000000000000');\n    });\n\n    it('should explain a transfer via explainDotTransaction with sender', function () {\n      const tx = buildTransaction({ type: 'payment', to: RECIPIENT, amount: 1000000000000n }, wasmContext());\n      const explained = explainDotTransaction({\n        txHex: tx.toBroadcastFormat(),\n        material,\n        senderAddress: SENDER,\n      });\n\n      assert.strictEqual(explained.type, TransactionType.Send);\n      assert.strictEqual(explained.outputs.length, 1);\n      assert.strictEqual(explained.outputs[0].address, RECIPIENT);\n      assert.strictEqual(explained.outputs[0].amount, '1000000000000');\n      assert.strictEqual(explained.sender, SENDER);\n      assert.strictEqual(explained.nonce, 0);\n    });\n  });\n\n  describe('Recover Transactions:', () => {\n    const sandBox = sinon.createSandbox();\n    const destAddr = testData.accounts.account1.address;\n    const nonce = 123;\n\n    beforeEach(function () {\n      const accountInfoCB = sandBox.stub(Dot.prototype, 'getAccountInfo' as keyof Dot);\n      accountInfoCB.withArgs(testData.wrwUser.walletAddress0).resolves({\n        nonce: nonce,\n        // Must exceed stubbed getFee so recover() does not throw (matches getFee withArgs amount).\n        freeBalance: 1510000000000,\n      });\n      const headerInfoCB = sandBox.stub(Dot.prototype, 'getHeaderInfo' as keyof Dot);\n      headerInfoCB.resolves({\n        headerNumber: testData.westendBlock.blockNumber,\n        headerHash: testData.westendBlock.hash,\n      });\n      accountInfoCB.withArgs('5Dtg2zKjVEL8p9keSM4dQ7nD26sVtMfCsyxkhvZZ9fqBbhw6').resolves({\n        nonce: 0,\n        freeBalance: 1510000000000,\n      });\n      const getFeeCB = sandBox.stub(Dot.prototype, 'getFee' as keyof Dot);\n      // Default avoids RPC when tests use a recoveryDestination other than destAddr (e.g. unsigned sweep fixture).\n      getFeeCB.resolves(15783812856);\n      getFeeCB.withArgs(destAddr, testData.wrwUser.walletAddress0, 1510000000000).resolves(15783812856);\n      const getMaterialCB = sandBox.stub(Dot.prototype, 'getMaterial' as keyof Dot);\n      getMaterialCB.resolves(utils.getMaterial(coins.get('tdot')));\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should generate unsigned sweep correctly', async function () {\n      const commonKeychain =\n        '3cd14f5d60744287cd3a50510e2964746b6feaad4b2300088eaae60d1a35f0abc518534d43b2614370d9a263aadb57edb5d0b78f816a519cd5896e7352920b67';\n      const recoveryDestination = '5GPAveMvmDsjxVT6Q2xiu5kYPbFAmdebHaiNZK14FBaSaAKh';\n\n      const unsigned = await basecoin.recover({ bitgoKey: commonKeychain, recoveryDestination });\n      unsigned.txRequests.should.not.be.undefined();\n      unsigned.txRequests.length.should.equal(1);\n      unsigned.txRequests[0].transactions.length.should.equal(1);\n      unsigned.txRequests[0].walletCoin.should.equal('tdot');\n      unsigned.txRequests[0].transactions[0].unsignedTx.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.serializedTx.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.scanIndex.should.equal(0);\n      unsigned.txRequests[0].transactions[0].unsignedTx.coin.should.equal('tdot');\n      unsigned.txRequests[0].transactions[0].unsignedTx.signableHex.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.derivationPath.should.equal('m/0');\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs.length.should.equal(1);\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].address.should.equal(\n        '5Dtg2zKjVEL8p9keSM4dQ7nD26sVtMfCsyxkhvZZ9fqBbhw6'\n      );\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].valueString.should.equal('1510000000000');\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].value.should.equal(1510000000000);\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs.length.should.equal(1);\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].address.should.equal(\n        '5GPAveMvmDsjxVT6Q2xiu5kYPbFAmdebHaiNZK14FBaSaAKh'\n      );\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].valueString.should.equal('1510000000000');\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].coinName.should.equal('tdot');\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.type.should.equal('');\n      unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.fee.should.equal(0);\n      unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.feeString.should.equal('0');\n      unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.firstValid.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.maxDuration.should.equal(2400);\n      unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.commonKeychain.should.equal(\n        '3cd14f5d60744287cd3a50510e2964746b6feaad4b2300088eaae60d1a35f0abc518534d43b2614370d9a263aadb57edb5d0b78f816a519cd5896e7352920b67'\n      );\n    });\n\n    // TODO(COIN-919): Fix failing test\n    xit('should take OVC output and generate a signed sweep transaction', async function () {\n      const params = testData.ovcResponse;\n\n      const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);\n      recoveryTxn.transactions[0].serializedTx.should.equal(\n        '0x2d02840050d1e116cdb32e61ba3ece275b620f503f0c5ae4e7690d9f9aa7e0b50303976c00057c131cde2be39f4ff23eeba11139c46dd8c6d69ff517abede37381d8d24f0bb30fd8805b2e51a9e2a75338d7fb7edb290be9638debedbfc001d10b8132be0b2b4a0400040400bf0678d312b2b2c7effd2b1f214ee13928d339391d5f5f7056608aa0d32b9edf01'\n      );\n      recoveryTxn.transactions[0].scanIndex.should.equal(0);\n      recoveryTxn.lastScanIndex.should.equal(0);\n    });\n\n    // TODO(COIN-919): Fix failing test\n    xit('should take consolidation OVC output and generate multiple signed sweep transactions', async function () {\n      const params = testData.ovcResponse2;\n\n      const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);\n      recoveryTxn.transactions[0].serializedTx.should.equal(\n        '0x2d028400f053d177371f4919b71017421aa34841ac87c926a14e8a7e75f092693665cb4a009871feb8389e12191b460ebea1f9e1716ada8a31d94ac08f5c15cb5f7be24683cdfc300ae3e6802c6f4b044dd92ea03d15b92399ab45803e43beb5cbff582a031b37000004040050d1e116cdb32e61ba3ece275b620f503f0c5ae4e7690d9f9aa7e0b50303976c01'\n      );\n      recoveryTxn.transactions[0].scanIndex.should.equal(1);\n      recoveryTxn.transactions[1].serializedTx.should.equal(\n        '0x2d028400cf7ed9f536373c8f874e780a4269ec1bd6799ed7d4a854c670b0c72805fac87600d153cbb683706ddf320f7b225af14ce4b59b868c07440aefa4c4e1297e49bcd5f6ee84f696b0c2e456e2a7f8779a78a2c832dfb47d5b283eba8408b003c7dd031b37000004040050d1e116cdb32e61ba3ece275b620f503f0c5ae4e7690d9f9aa7e0b50303976c01'\n      );\n      recoveryTxn.transactions[1].scanIndex.should.equal(2);\n      recoveryTxn.transactions[2].serializedTx.should.equal(\n        '0x2d0284009482ad7e43b40b7df3383244daafed32b3b9fd7541016b5c907f2d9052f85f8600e255698d110977faf33efb3336ba98ad7eaa2a1a926487fc696a277442d4414b2a441ba92d598f2b1f96f13b28785f5e572984035a608d63c48bd35ba955090e1b37000004040050d1e116cdb32e61ba3ece275b620f503f0c5ae4e7690d9f9aa7e0b50303976c01'\n      );\n      recoveryTxn.transactions[2].scanIndex.should.equal(3);\n      recoveryTxn.lastScanIndex.should.equal(20);\n    });\n\n    // TODO(COIN-919): Fix failing test\n    xit('should recover a txn for non-bitgo recoveries', async function () {\n      const res = await basecoin.recover({\n        userKey: testData.wrwUser.userKey,\n        backupKey: testData.wrwUser.backupKey,\n        bitgoKey: testData.wrwUser.bitgoKey,\n        walletPassphrase: testData.wrwUser.walletPassphrase,\n        recoveryDestination: destAddr,\n      });\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n      res.should.hasOwnProperty('scanIndex');\n      sandBox.assert.calledOnce(basecoin.getAccountInfo);\n      sandBox.assert.calledOnce(basecoin.getHeaderInfo);\n\n      // deserialize the txn and verify the fields are what we expect\n      const txBuilder = basecoin.getBuilder().from(res.serializedTx);\n      // some information isn't deserialized by the from method, so we will\n      // supply it again in order to re-build the txn\n      txBuilder\n        .validity({\n          firstValid: testData.westendBlock.blockNumber,\n          maxDuration: basecoin.SWEEP_TXN_DURATION,\n        })\n        .referenceBlock(testData.westendBlock.hash);\n      const tx = await txBuilder.build();\n      const txJson = tx.toJson();\n      should.deepEqual(txJson.sender, testData.wrwUser.walletAddress0);\n      should.deepEqual(txJson.blockNumber, testData.westendBlock.blockNumber);\n      should.deepEqual(txJson.referenceBlock, testData.westendBlock.hash);\n      should.deepEqual(txJson.genesisHash, genesisHash);\n      should.deepEqual(txJson.specVersion, specVersion);\n      should.deepEqual(txJson.nonce, nonce);\n      should.deepEqual(txJson.tip, 0);\n      should.deepEqual(txJson.transactionVersion, txVersion);\n      should.deepEqual(txJson.chainName, chainName);\n      should.deepEqual(txJson.eraPeriod, basecoin.SWEEP_TXN_DURATION);\n    });\n\n    it('should recover a txn for unsigned-sweep recoveries', async function () {\n      const res = await basecoin.recover({\n        bitgoKey: testData.wrwUser.bitgoKey,\n        recoveryDestination: destAddr,\n      });\n      res.should.not.be.empty();\n      res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');\n      res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('scanIndex');\n      sandBox.assert.calledOnce(basecoin.getAccountInfo);\n      sandBox.assert.calledOnce(basecoin.getHeaderInfo);\n\n      // deserialize the txn and verify the fields are what we expect\n      const txBuilder = basecoin.getBuilder().from(res.txRequests[0].transactions[0].unsignedTx.serializedTx);\n      // some information isn't deserialized by the from method, so we will\n      // supply it again in order to re-build the txn\n      txBuilder\n        .validity({\n          firstValid: testData.westendBlock.blockNumber,\n          maxDuration: basecoin.SWEEP_TXN_DURATION,\n        })\n        .referenceBlock(testData.westendBlock.hash)\n        .sender({ address: testData.wrwUser.walletAddress0 });\n      const tx = await txBuilder.build();\n      const txJson = tx.toJson();\n      should.deepEqual(txJson.sender, testData.wrwUser.walletAddress0);\n      should.deepEqual(txJson.blockNumber, testData.westendBlock.blockNumber);\n      should.deepEqual(txJson.referenceBlock, testData.westendBlock.hash);\n      should.deepEqual(txJson.genesisHash, genesisHash);\n      should.deepEqual(txJson.specVersion, specVersion);\n      should.deepEqual(txJson.nonce, nonce);\n      should.deepEqual(txJson.tip, 0);\n      should.deepEqual(txJson.transactionVersion, txVersion);\n      should.deepEqual(txJson.chainName, chainName);\n      should.deepEqual(txJson.eraPeriod, basecoin.SWEEP_TXN_DURATION);\n\n      const extras = SingletonRegistry.getInstance(utils.getMaterial(coins.get('tdot')))\n        .createType('ExtrinsicPayload', res.txRequests[0].transactions[0].unsignedTx.serializedTx, {\n          version: EXTRINSIC_VERSION,\n        })\n        .toJSON() as { tip?: string | number; assetId?: unknown; mode?: number | string };\n      should.equal(Number(extras.tip ?? 0), 0);\n      should.equal(Number(extras.mode ?? 0), 0);\n      should.equal(\n        extras.assetId === null || extras.assetId === undefined,\n        true,\n        `expected ChargeAsset assetId None, got ${JSON.stringify(extras.assetId)}`\n      );\n    });\n  });\n\n  describe('Recover Transactions (MPCv2):', () => {\n    const sandBox = sinon.createSandbox();\n    const destAddr = testData.accounts.account1.address;\n    const nonce = 123;\n    const walletPassphrase = testData.wrwUser.walletPassphrase;\n    let mpcV2UserKey: string;\n    let mpcV2BackupKey: string;\n    let mpcV2CommonKeyChain: string;\n    let mpcV2WalletAddress: string;\n    let mismatchedBitgoKey: string;\n    let mismatchedWalletAddress: string;\n\n    before(async function () {\n      const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n      const [otherUserDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n\n      mpcV2UserKey = await encrypt(walletPassphrase, userDkg.getReducedKeyShare().toString('base64'));\n      mpcV2BackupKey = await encrypt(walletPassphrase, backupDkg.getReducedKeyShare().toString('base64'));\n      mpcV2CommonKeyChain = userDkg.getCommonKeychain();\n      const mpc = await EDDSAMethods.getInitializedMpcInstance();\n      mpcV2WalletAddress = basecoin.getAddressFromPublicKey(\n        mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/0').slice(0, 64)\n      );\n\n      mismatchedBitgoKey = otherUserDkg.getCommonKeychain();\n      mismatchedWalletAddress = basecoin.getAddressFromPublicKey(\n        mpc.deriveUnhardened(mismatchedBitgoKey, 'm/0').slice(0, 64)\n      );\n    });\n\n    beforeEach(function () {\n      const accountInfoCB = sandBox.stub(Dot.prototype, 'getAccountInfo' as keyof Dot);\n      accountInfoCB.withArgs(mpcV2WalletAddress).resolves({\n        nonce: nonce,\n        freeBalance: 1510000000000,\n      });\n      accountInfoCB.withArgs(mismatchedWalletAddress).resolves({\n        nonce: nonce,\n        freeBalance: 1510000000000,\n      });\n      const headerInfoCB = sandBox.stub(Dot.prototype, 'getHeaderInfo' as keyof Dot);\n      headerInfoCB.resolves({\n        headerNumber: testData.westendBlock.blockNumber,\n        headerHash: testData.westendBlock.hash,\n      });\n      const getFeeCB = sandBox.stub(Dot.prototype, 'getFee' as keyof Dot);\n      getFeeCB.resolves(15783812856);\n      const getMaterialCB = sandBox.stub(Dot.prototype, 'getMaterial' as keyof Dot);\n      getMaterialCB.resolves(utils.getMaterial(coins.get('tdot')));\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should route to MPCv2 path for native DOT recovery when keycard is MPCv2', async function () {\n      const getTSSSignatureSpy = sandBox.spy(EDDSAMethods, 'getTSSSignature');\n\n      const res = (await basecoin.recover({\n        userKey: mpcV2UserKey,\n        backupKey: mpcV2BackupKey,\n        bitgoKey: mpcV2CommonKeyChain,\n        walletPassphrase,\n        recoveryDestination: destAddr,\n      })) as MPCTx;\n\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n      res.should.hasOwnProperty('scanIndex');\n      should.equal(res.scanIndex, 0);\n      sandBox.assert.calledOnce(basecoin.getAccountInfo);\n      sandBox.assert.notCalled(getTSSSignatureSpy);\n    });\n\n    it('should throw when MPCv2 commonKeyChain does not match bitgoKey', async function () {\n      await basecoin\n        .recover({\n          userKey: mpcV2UserKey,\n          backupKey: mpcV2BackupKey,\n          bitgoKey: mismatchedBitgoKey,\n          walletPassphrase,\n          recoveryDestination: destAddr,\n        })\n        .should.be.rejectedWith('EdDSA MPCv2 recovery: commonKeyChain from keycard does not match bitgoKey');\n    });\n\n    it('should throw missing userKey when backupKey and walletPassphrase are present but userKey is not', async function () {\n      await basecoin\n        .recover({\n          userKey: undefined,\n          backupKey: mpcV2BackupKey,\n          bitgoKey: mpcV2CommonKeyChain,\n          walletPassphrase,\n          recoveryDestination: destAddr,\n        })\n        .should.be.rejectedWith('missing userKey');\n    });\n\n    it('should throw missing backupKey when userKey and walletPassphrase are present but backupKey is not', async function () {\n      await basecoin\n        .recover({\n          userKey: mpcV2UserKey,\n          backupKey: undefined,\n          bitgoKey: mpcV2CommonKeyChain,\n          walletPassphrase,\n          recoveryDestination: destAddr,\n        })\n        .should.be.rejectedWith('missing backupKey');\n    });\n\n    it('should throw missing wallet passphrase when userKey and backupKey are present but walletPassphrase is not', async function () {\n      await basecoin\n        .recover({\n          userKey: mpcV2UserKey,\n          backupKey: mpcV2BackupKey,\n          bitgoKey: mpcV2CommonKeyChain,\n          walletPassphrase: undefined,\n          recoveryDestination: destAddr,\n        })\n        .should.be.rejectedWith('missing wallet passphrase');\n    });\n\n    it('should still use the MPCv1 path (getTSSSignature) for MPCv1 JSON keycards', async function () {\n      const getTSSSignatureSpy = sandBox.spy(EDDSAMethods, 'getTSSSignature');\n      (Dot.prototype as unknown as { getAccountInfo: sinon.SinonStub }).getAccountInfo\n        .withArgs(testData.wrwUser.walletAddress0)\n        .resolves({\n          nonce,\n          freeBalance: 1510000000000,\n        });\n\n      const result = (await basecoin.recover({\n        userKey: testData.wrwUser.userKey,\n        backupKey: testData.wrwUser.backupKey,\n        bitgoKey: testData.wrwUser.bitgoKey,\n        walletPassphrase: testData.wrwUser.walletPassphrase,\n        recoveryDestination: destAddr,\n      })) as MPCTx;\n\n      result.should.not.be.empty();\n      result.should.hasOwnProperty('serializedTx');\n      sandBox.assert.calledOnce(getTSSSignatureSpy);\n    });\n\n    it('should call getEddsaSigningMaterial exactly once per recover() call', async function () {\n      const getEddsaMaterialSpy = sandBox.spy(\n        basecoin as unknown as { getEddsaSigningMaterial: unknown },\n        'getEddsaSigningMaterial'\n      );\n\n      const res = (await basecoin.recover({\n        userKey: mpcV2UserKey,\n        backupKey: mpcV2BackupKey,\n        bitgoKey: mpcV2CommonKeyChain,\n        walletPassphrase,\n        recoveryDestination: destAddr,\n      })) as MPCTx;\n\n      res.should.not.be.empty();\n      sandBox.assert.calledOnce(getEddsaMaterialSpy);\n    });\n\n    it('should ignore a non-signing-material second arg (WRW openSSL WASM buffer)', async function () {\n      const getEddsaMaterialSpy = sandBox.spy(\n        basecoin as unknown as { getEddsaSigningMaterial: unknown },\n        'getEddsaSigningMaterial'\n      );\n\n      const res = (await basecoin.recover(\n        {\n          userKey: mpcV2UserKey,\n          backupKey: mpcV2BackupKey,\n          bitgoKey: mpcV2CommonKeyChain,\n          walletPassphrase,\n          recoveryDestination: destAddr,\n        },\n        new ArrayBuffer(8)\n      )) as MPCTx;\n\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n      sandBox.assert.calledOnce(getEddsaMaterialSpy);\n    });\n  });\n\n  describe('Build Consolidation Recoveries:', () => {\n    const sandBox = sinon.createSandbox();\n    const baseAddr = testData.consolidationWrwUser.walletAddress0;\n    const nonce = 123;\n\n    beforeEach(function () {\n      const accountInfoCB = sandBox.stub(Dot.prototype, 'getAccountInfo' as keyof Dot);\n      accountInfoCB.withArgs(testData.consolidationWrwUser.walletAddress1).resolves({\n        nonce: nonce,\n        freeBalance: 10000000000,\n      });\n      accountInfoCB.withArgs(testData.consolidationWrwUser.walletAddress2).resolves({\n        nonce: nonce,\n        freeBalance: 1510000000000,\n      });\n      accountInfoCB.withArgs(testData.consolidationWrwUser.walletAddress3).resolves({\n        nonce: nonce,\n        freeBalance: 1510000000000,\n      });\n      const headerInfoCB = sandBox.stub(Dot.prototype, 'getHeaderInfo' as keyof Dot);\n      headerInfoCB.resolves({\n        headerNumber: testData.westendBlock.blockNumber,\n        headerHash: testData.westendBlock.hash,\n      });\n      const getFeeCB = sandBox.stub(Dot.prototype, 'getFee' as keyof Dot);\n      getFeeCB.withArgs(baseAddr, testData.consolidationWrwUser.walletAddress1, 10000000000).resolves(15783812856);\n      getFeeCB.withArgs(baseAddr, testData.consolidationWrwUser.walletAddress2, 1510000000000).resolves(15783812856);\n      getFeeCB.withArgs(baseAddr, testData.consolidationWrwUser.walletAddress3, 1510000000000).resolves(15783812856);\n      const getMaterialCB = sandBox.stub(Dot.prototype, 'getMaterial' as keyof Dot);\n      getMaterialCB.resolves(utils.getMaterial(coins.get('tdot')));\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    // TODO(COIN-919): Fix failing test\n    xit('should build signed consolidation recoveries', async function () {\n      const res = await basecoin.recoverConsolidations({\n        userKey: testData.consolidationWrwUser.userKey,\n        backupKey: testData.consolidationWrwUser.backupKey,\n        bitgoKey: testData.consolidationWrwUser.bitgoKey,\n        walletPassphrase: testData.consolidationWrwUser.walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n      res.should.not.be.empty();\n      res.transactions.length.should.equal(2);\n      sandBox.assert.calledThrice(basecoin.getAccountInfo);\n      sandBox.assert.calledTwice(basecoin.getHeaderInfo);\n\n      const txn1 = res.transactions[0];\n      txn1.should.hasOwnProperty('serializedTx');\n      txn1.should.hasOwnProperty('scanIndex');\n      txn1.scanIndex.should.equal(2);\n      // deserialize the txn and verify the fields are what we expect\n      const txBuilder1 = basecoin.getBuilder().from(txn1.serializedTx);\n      // some information isn't deserialized by the from method, so we will\n      // supply it again in order to re-build the txn\n      txBuilder1\n        .validity({\n          firstValid: testData.westendBlock.blockNumber,\n          maxDuration: basecoin.MAX_VALIDITY_DURATION,\n        })\n        .referenceBlock(testData.westendBlock.hash);\n      const tx1 = await txBuilder1.build();\n      const txJson1 = tx1.toJson();\n      should.deepEqual(txJson1.sender, testData.consolidationWrwUser.walletAddress2);\n      should.deepEqual(txJson1.blockNumber, testData.westendBlock.blockNumber);\n      should.deepEqual(txJson1.referenceBlock, testData.westendBlock.hash);\n      should.deepEqual(txJson1.genesisHash, genesisHash);\n      should.deepEqual(txJson1.specVersion, specVersion);\n      should.deepEqual(txJson1.nonce, nonce);\n      should.deepEqual(txJson1.tip, 0);\n      should.deepEqual(txJson1.transactionVersion, txVersion);\n      should.deepEqual(txJson1.chainName, chainName);\n      // eraPeriod will always round to the next upper power of 2 for any input value, in this case 2400.\n      // 4096 is the \"highest\" value you can set, but the txn still may fail after 2400 blocks.\n      const eraPeriod = 4096;\n      should.deepEqual(txJson1.eraPeriod, eraPeriod);\n      should.deepEqual(txJson1.to, baseAddr);\n\n      res.lastScanIndex.should.equal(3);\n      const txn2 = res.transactions[1];\n      txn2.should.hasOwnProperty('serializedTx');\n      txn2.should.hasOwnProperty('scanIndex');\n      txn2.scanIndex.should.equal(3);\n      // deserialize the txn and verify the fields are what we expect\n      const txBuilder2 = basecoin.getBuilder().from(txn2.serializedTx);\n      // some information isn't deserialized by the from method, so we will\n      // supply it again in order to re-build the txn\n      txBuilder2\n        .validity({\n          firstValid: testData.westendBlock.blockNumber,\n          maxDuration: basecoin.MAX_VALIDITY_DURATION,\n        })\n        .referenceBlock(testData.westendBlock.hash);\n      const tx2 = await txBuilder2.build();\n      const txJson2 = tx2.toJson();\n      should.deepEqual(txJson2.sender, testData.consolidationWrwUser.walletAddress3);\n      should.deepEqual(txJson2.blockNumber, testData.westendBlock.blockNumber);\n      should.deepEqual(txJson2.referenceBlock, testData.westendBlock.hash);\n      should.deepEqual(txJson2.genesisHash, genesisHash);\n      should.deepEqual(txJson2.specVersion, specVersion);\n      should.deepEqual(txJson2.nonce, nonce);\n      should.deepEqual(txJson2.tip, 0);\n      should.deepEqual(txJson2.transactionVersion, txVersion);\n      should.deepEqual(txJson2.chainName, chainName);\n      should.deepEqual(txJson2.eraPeriod, eraPeriod);\n      should.deepEqual(txJson2.to, baseAddr);\n    });\n\n    it('should build unsigned consolidation recoveries', async function () {\n      const res = await basecoin.recoverConsolidations({\n        bitgoKey: testData.consolidationWrwUser.bitgoKey,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n      res.should.not.be.empty();\n      res.txRequests.length.should.equal(2);\n      sandBox.assert.calledThrice(basecoin.getAccountInfo);\n      sandBox.assert.calledTwice(basecoin.getHeaderInfo);\n\n      const txn1 = res.txRequests[0].transactions[0].unsignedTx;\n      txn1.should.hasOwnProperty('serializedTx');\n      txn1.should.hasOwnProperty('signableHex');\n      txn1.should.hasOwnProperty('scanIndex');\n      txn1.scanIndex.should.equal(2);\n      txn1.should.hasOwnProperty('coin');\n      txn1.coin.should.equal('tdot');\n      txn1.should.hasOwnProperty('derivationPath');\n      txn1.derivationPath.should.equal('m/2');\n\n      txn1.should.hasOwnProperty('coinSpecific');\n      const coinSpecific1 = txn1.coinSpecific;\n      coinSpecific1.should.hasOwnProperty('commonKeychain');\n      coinSpecific1.should.hasOwnProperty('firstValid');\n      coinSpecific1.firstValid.should.equal(testData.westendBlock.blockNumber);\n      coinSpecific1.should.hasOwnProperty('maxDuration');\n      coinSpecific1.maxDuration.should.equal(basecoin.MAX_VALIDITY_DURATION);\n\n      // deserialize the txn and verify the fields are what we expect\n      const txBuilder1 = basecoin.getBuilder().from(txn1.serializedTx);\n      // some information isn't deserialized by the from method, so we will\n      // supply it again in order to re-build the txn\n      txBuilder1\n        .validity({\n          firstValid: testData.westendBlock.blockNumber,\n          maxDuration: basecoin.MAX_VALIDITY_DURATION,\n        })\n        .referenceBlock(testData.westendBlock.hash)\n        .sender({ address: testData.consolidationWrwUser.walletAddress2 });\n      const tx1 = await txBuilder1.build();\n      const txJson1 = tx1.toJson();\n      should.deepEqual(txJson1.sender, testData.consolidationWrwUser.walletAddress2);\n      should.deepEqual(txJson1.blockNumber, testData.westendBlock.blockNumber);\n      should.deepEqual(txJson1.referenceBlock, testData.westendBlock.hash);\n      should.deepEqual(txJson1.genesisHash, genesisHash);\n      should.deepEqual(txJson1.specVersion, specVersion);\n      should.deepEqual(txJson1.nonce, nonce);\n      should.deepEqual(txJson1.tip, 0);\n      should.deepEqual(txJson1.transactionVersion, txVersion);\n      should.deepEqual(txJson1.chainName, chainName);\n      // eraPeriod will always round to the next upper power of 2 for any input value, in this case 2400.\n      // 4096 is the \"highest\" value you can set, but the txn still may fail after 2400 blocks.\n      const eraPeriod = 4096;\n      should.deepEqual(txJson1.eraPeriod, eraPeriod);\n      should.deepEqual(txJson1.to, baseAddr);\n\n      const txn2 = res.txRequests[1].transactions[0].unsignedTx;\n      txn2.should.hasOwnProperty('serializedTx');\n      txn2.should.hasOwnProperty('signableHex');\n      txn2.should.hasOwnProperty('scanIndex');\n      txn2.scanIndex.should.equal(3);\n      txn2.should.hasOwnProperty('coin');\n      txn2.coin.should.equal('tdot');\n      txn2.should.hasOwnProperty('derivationPath');\n      txn2.derivationPath.should.equal('m/3');\n\n      txn2.should.hasOwnProperty('coinSpecific');\n      const coinSpecific2 = txn2.coinSpecific;\n      coinSpecific2.should.hasOwnProperty('commonKeychain');\n      coinSpecific2.should.hasOwnProperty('firstValid');\n      coinSpecific2.firstValid.should.equal(testData.westendBlock.blockNumber);\n      coinSpecific2.should.hasOwnProperty('maxDuration');\n      coinSpecific2.maxDuration.should.equal(basecoin.MAX_VALIDITY_DURATION);\n      coinSpecific2.should.hasOwnProperty('commonKeychain');\n      coinSpecific2.should.hasOwnProperty('lastScanIndex');\n      coinSpecific2.lastScanIndex.should.equal(3);\n\n      // deserialize the txn and verify the fields are what we expect\n      const txBuilder2 = basecoin.getBuilder().from(txn2.serializedTx);\n      // some information isn't deserialized by the from method, so we will\n      // supply it again in order to re-build the txn\n      txBuilder2\n        .validity({\n          firstValid: testData.westendBlock.blockNumber,\n          maxDuration: basecoin.MAX_VALIDITY_DURATION,\n        })\n        .referenceBlock(testData.westendBlock.hash)\n        .sender({ address: testData.consolidationWrwUser.walletAddress3 });\n      const tx2 = await txBuilder2.build();\n      const txJson2 = tx2.toJson();\n      should.deepEqual(txJson2.sender, testData.consolidationWrwUser.walletAddress3);\n      should.deepEqual(txJson2.blockNumber, testData.westendBlock.blockNumber);\n      should.deepEqual(txJson2.referenceBlock, testData.westendBlock.hash);\n      should.deepEqual(txJson2.genesisHash, genesisHash);\n      should.deepEqual(txJson2.specVersion, specVersion);\n      should.deepEqual(txJson2.nonce, nonce);\n      should.deepEqual(txJson2.tip, 0);\n      should.deepEqual(txJson2.transactionVersion, txVersion);\n      should.deepEqual(txJson2.chainName, chainName);\n      should.deepEqual(txJson2.eraPeriod, eraPeriod);\n      should.deepEqual(txJson2.to, baseAddr);\n    });\n\n    it('should skip building consolidate transaction if balance is equal to zero', async function () {\n      await basecoin\n        .recoverConsolidations({\n          userKey: testData.consolidationWrwUser.userKey,\n          backupKey: testData.consolidationWrwUser.backupKey,\n          bitgoKey: testData.consolidationWrwUser.bitgoKey,\n          walletPassphrase: testData.consolidationWrwUser.walletPassphrase,\n          startingScanIndex: 1,\n          endingScanIndex: 2,\n        })\n        .should.rejectedWith('Did not find an address with funds to recover');\n    });\n\n    it('should throw if startingScanIndex is not ge to 1', async () => {\n      await basecoin\n        .recoverConsolidations({\n          userKey: testData.consolidationWrwUser.userKey,\n          backupKey: testData.consolidationWrwUser.backupKey,\n          bitgoKey: testData.consolidationWrwUser.bitgoKey,\n          startingScanIndex: -1,\n        })\n        .should.be.rejectedWith(\n          'Invalid starting or ending index to scan for addresses. startingScanIndex: -1, endingScanIndex: 19.'\n        );\n    });\n\n    it('should throw if scan factor is too high', async () => {\n      await basecoin\n        .recoverConsolidations({\n          userKey: testData.consolidationWrwUser.userKey,\n          backupKey: testData.consolidationWrwUser.backupKey,\n          bitgoKey: testData.consolidationWrwUser.bitgoKey,\n          startingScanIndex: 1,\n          endingScanIndex: 300,\n        })\n        .should.be.rejectedWith(\n          'Invalid starting or ending index to scan for addresses. startingScanIndex: 1, endingScanIndex: 300.'\n        );\n    });\n  });\n\n  describe('Build Consolidation Recoveries (MPCv2):', () => {\n    const sandBox = sinon.createSandbox();\n    const nonce = 123;\n    const walletPassphrase = testData.wrwUser.walletPassphrase;\n    let mpcV2UserKey: string;\n    let mpcV2BackupKey: string;\n    let mpcV2CommonKeyChain: string;\n    let baseAddr: string;\n    let mpcV2Address1: string;\n    let mpcV2Address2: string;\n    let mpcV2Address3: string;\n\n    before(async function () {\n      const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n\n      mpcV2UserKey = await encrypt(walletPassphrase, userDkg.getReducedKeyShare().toString('base64'));\n      mpcV2BackupKey = await encrypt(walletPassphrase, backupDkg.getReducedKeyShare().toString('base64'));\n      mpcV2CommonKeyChain = userDkg.getCommonKeychain();\n      const mpc = await EDDSAMethods.getInitializedMpcInstance();\n      baseAddr = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/0').slice(0, 64));\n      mpcV2Address1 = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/1').slice(0, 64));\n      mpcV2Address2 = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/2').slice(0, 64));\n      mpcV2Address3 = basecoin.getAddressFromPublicKey(mpc.deriveUnhardened(mpcV2CommonKeyChain, 'm/3').slice(0, 64));\n    });\n\n    beforeEach(function () {\n      const accountInfoCB = sandBox.stub(Dot.prototype, 'getAccountInfo' as keyof Dot);\n      accountInfoCB.withArgs(mpcV2Address1).resolves({ nonce, freeBalance: 0 });\n      accountInfoCB.withArgs(mpcV2Address2).resolves({ nonce, freeBalance: 1510000000000 });\n      accountInfoCB.withArgs(mpcV2Address3).resolves({ nonce, freeBalance: 1510000000000 });\n      const headerInfoCB = sandBox.stub(Dot.prototype, 'getHeaderInfo' as keyof Dot);\n      headerInfoCB.resolves({\n        headerNumber: testData.westendBlock.blockNumber,\n        headerHash: testData.westendBlock.hash,\n      });\n      const getFeeCB = sandBox.stub(Dot.prototype, 'getFee' as keyof Dot);\n      getFeeCB.resolves(15783812856);\n      const getMaterialCB = sandBox.stub(Dot.prototype, 'getMaterial' as keyof Dot);\n      getMaterialCB.resolves(utils.getMaterial(coins.get('tdot')));\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should build MPCv2 signed consolidation recoveries across 2+ funded indexes, sweeping to the MPCv2 base address', async function () {\n      const getEddsaMaterialSpy = sandBox.spy(\n        basecoin as unknown as { getEddsaSigningMaterial: unknown },\n        'getEddsaSigningMaterial'\n      );\n\n      const res = (await basecoin.recoverConsolidations({\n        userKey: mpcV2UserKey,\n        backupKey: mpcV2BackupKey,\n        bitgoKey: mpcV2CommonKeyChain,\n        walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      })) as MPCTxs;\n\n      res.should.not.be.empty();\n      res.transactions.length.should.equal(2);\n      should.equal(res.lastScanIndex, 3);\n\n      const txBuilder1 = basecoin.getBuilder().from(res.transactions[0].serializedTx);\n      txBuilder1\n        .validity({ firstValid: testData.westendBlock.blockNumber, maxDuration: basecoin.MAX_VALIDITY_DURATION })\n        .referenceBlock(testData.westendBlock.hash);\n      const tx1 = await txBuilder1.build();\n      should.deepEqual(tx1.toJson().to, baseAddr);\n\n      // recoverConsolidations must detect signing material exactly once at the top of the scan\n      // loop, not per-iteration inside recover() — precomputedMaterial bypasses per-call detection.\n      sandBox.assert.calledOnce(getEddsaMaterialSpy);\n    });\n\n    it('should call getEddsaSigningMaterial exactly once across all recover() iterations', async function () {\n      const getEddsaMaterialSpy = sandBox.spy(\n        basecoin as unknown as { getEddsaSigningMaterial: unknown },\n        'getEddsaSigningMaterial'\n      );\n\n      await basecoin.recoverConsolidations({\n        userKey: mpcV2UserKey,\n        backupKey: mpcV2BackupKey,\n        bitgoKey: mpcV2CommonKeyChain,\n        walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n\n      sandBox.assert.calledOnce(getEddsaMaterialSpy);\n    });\n\n    it('should leave MPCv1 base address derivation and signing unchanged (regression)', async function () {\n      const baseAddrV1 = testData.consolidationWrwUser.walletAddress0;\n      (basecoin.getAccountInfo as sinon.SinonStub).withArgs(testData.consolidationWrwUser.walletAddress1).resolves({\n        nonce,\n        freeBalance: 10000000000,\n      });\n      (basecoin.getAccountInfo as sinon.SinonStub).withArgs(testData.consolidationWrwUser.walletAddress2).resolves({\n        nonce,\n        freeBalance: 1510000000000,\n      });\n\n      const getTSSSignatureSpy = sandBox.spy(EDDSAMethods, 'getTSSSignature');\n\n      const res = (await basecoin.recoverConsolidations({\n        userKey: testData.consolidationWrwUser.userKey,\n        backupKey: testData.consolidationWrwUser.backupKey,\n        bitgoKey: testData.consolidationWrwUser.bitgoKey,\n        walletPassphrase: testData.consolidationWrwUser.walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 3,\n      })) as MPCTxs;\n\n      res.should.not.be.empty();\n      sandBox.assert.calledOnce(getTSSSignatureSpy);\n\n      const txBuilder1 = basecoin.getBuilder().from(res.transactions[0].serializedTx);\n      txBuilder1\n        .validity({ firstValid: testData.westendBlock.blockNumber, maxDuration: basecoin.MAX_VALIDITY_DURATION })\n        .referenceBlock(testData.westendBlock.hash);\n      const tx1 = await txBuilder1.build();\n      should.deepEqual(tx1.toJson().to, baseAddrV1);\n    });\n\n    it('should leave the unsigned (no passphrase) cold path unchanged when keycard is MPCv2', async function () {\n      const res = (await basecoin.recoverConsolidations({\n        bitgoKey: mpcV2CommonKeyChain,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      })) as { txRequests: unknown[] };\n\n      res.should.not.be.empty();\n      res.txRequests.length.should.equal(2);\n    });\n  });\n\n  describe('Recover Transaction Failures:', () => {\n    const sandBox = sinon.createSandbox();\n    const destAddr = testData.accounts.account1.address;\n    const nonce = 123;\n\n    beforeEach(function () {\n      const accountInfoCB = sandBox.stub(Dot.prototype, 'getAccountInfo' as keyof Dot);\n      accountInfoCB.resolves({\n        nonce: nonce,\n        freeBalance: 0,\n      });\n      const getFeeCB = sandBox.stub(Dot.prototype, 'getFee' as keyof Dot);\n      getFeeCB.resolves(15783812856);\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should fail to recover due to not finding an address with funds', async function () {\n      await basecoin\n        .recover({\n          userKey: testData.wrwUser.userKey,\n          backupKey: testData.wrwUser.backupKey,\n          bitgoKey: testData.wrwUser.bitgoKey,\n          walletPassphrase: testData.wrwUser.walletPassphrase,\n          recoveryDestination: destAddr,\n        })\n        .should.rejectedWith('Did not find address with funds to recover');\n    });\n  });\n\n  describe('Verify Transaction', function () {\n    const address1 = '5Ge59qRnZa8bxyhVFE6BDoY3kuhSrNVETRxXYLty1Hh6XTaf';\n    const address2 = '5DiMLZugmcKEH3igPZP367FqummZkWeW5Z6zDCHLfxRjnPXe';\n    it('should reject a txPrebuild with more than one recipient', async function () {\n      const wallet = new Wallet(bitgo, basecoin, {});\n\n      const txParams = {\n        recipients: [\n          { amount: '1000000000000', address: address1 },\n          { amount: '2500000000000', address: address2 },\n        ],\n        wallet: wallet,\n        walletPassphrase: 'fakeWalletPassphrase',\n      };\n\n      const txPrebuild = {\n        txHex:\n          '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',\n      };\n\n      await basecoin\n        .verifyTransaction({ txPrebuild, txParams })\n        .should.be.rejectedWith(\n          `tdot doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`\n        );\n    });\n\n    it('should reject a txPrebuild with more than invalid amount', async function () {\n      const wallet = new Wallet(bitgo, basecoin, {});\n      const txParams = {\n        recipients: [{ amount: '20000000000', address: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD' }],\n        wallet: wallet,\n        walletPassphrase: 'fakeWalletPassphrase',\n      };\n      const txPrebuild = {\n        txHex:\n          '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',\n      };\n\n      await basecoin\n        .verifyTransaction({ txPrebuild, txParams })\n        .should.be.rejectedWith(`Recipient amount 20000000000 does not match transaction amount 2000000000000`);\n    });\n\n    it('should reject a txPrebuild with more than invalid recipient', async function () {\n      const wallet = new Wallet(bitgo, basecoin, {});\n      const txParams = {\n        recipients: [{ amount: '2000000000000', address: '5CZh773vKGwKFCUjGc31AwXCbf7TPkavduk2XoujJMjbBD' }],\n        wallet: wallet,\n        walletPassphrase: 'fakeWalletPassphrase',\n      };\n      const txPrebuild = {\n        txHex:\n          '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',\n      };\n\n      await basecoin\n        .verifyTransaction({ txPrebuild, txParams })\n        .should.be.rejectedWith(\n          `Recipient address 5CZh773vKGwKFCUjGc31AwXCbf7TPkavduk2XoujJMjbBD does not match transaction destination address 5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD`\n        );\n    });\n\n    it('should accept a txPrebuild with more than valid recipient and amount', async function () {\n      const wallet = new Wallet(bitgo, basecoin, {});\n      const txParams = {\n        recipients: [{ amount: '2000000000000', address: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD' }],\n        wallet: wallet,\n        walletPassphrase: 'fakeWalletPassphrase',\n      };\n      const txPrebuild = {\n        txHex:\n          '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',\n      };\n\n      const result = await basecoin.verifyTransaction({ txPrebuild, txParams });\n      assert.strictEqual(result, true);\n    });\n\n    it('should verify a valid consolidation transaction', async function () {\n      const mockedWallet = {\n        coinSpecific: () => ({\n          baseAddress: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD',\n        }),\n      };\n      const txPrebuild = {\n        txHex:\n          '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',\n      };\n\n      const result = await basecoin.verifyTransaction({\n        txPrebuild,\n        txParams: {},\n        wallet: mockedWallet as any,\n        verification: {\n          consolidationToBaseAddress: true,\n        },\n      });\n      assert.strictEqual(result, true);\n    });\n\n    it('should reject a consolidation transaction with invalid destination address', async function () {\n      const mockedWallet = {\n        coinSpecific: () => ({\n          baseAddress: '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74',\n        }),\n      };\n      const txPrebuild = {\n        txHex:\n          '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300',\n      };\n\n      await basecoin\n        .verifyTransaction({\n          txPrebuild,\n          txParams: {},\n          wallet: mockedWallet as any,\n          verification: {\n            consolidationToBaseAddress: true,\n          },\n        })\n        .should.be.rejectedWith(\n          'Transaction destination address 5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD does not match wallet base address 5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74'\n        );\n    });\n\n    it('should verify a transferAll (sweep) transaction with empty txParams', async function () {\n      const mockedWallet = {\n        coinSpecific: () => ({\n          baseAddress: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq',\n        }),\n      };\n\n      // TransferAll tx (sweep) - uses method 0a04 (balances.transferAll)\n      const txPrebuild = {\n        txHex:\n          '0x900a04009f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f025401d50121030000009d880f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d00',\n      };\n\n      const result = await basecoin.verifyTransaction({\n        txPrebuild,\n        txParams: {},\n        wallet: mockedWallet as any,\n        verification: {\n          consolidationToBaseAddress: true,\n        },\n      });\n      assert.strictEqual(result, true);\n    });\n\n    it('should verify a transferAll (sweep) transaction with recipients in txParams', async function () {\n      const mockedWallet = {\n        coinSpecific: () => ({\n          baseAddress: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq',\n        }),\n      };\n\n      // TransferAll tx (sweep) - _amount is undefined for these transactions\n      const txPrebuild = {\n        txHex:\n          '0x900a04009f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f025401d50121030000009d880f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d00',\n      };\n\n      const txParams = {\n        recipients: [{ address: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq', amount: '1000000000000' }],\n      };\n\n      const result = await basecoin.verifyTransaction({\n        txPrebuild,\n        txParams,\n        wallet: mockedWallet as any,\n        verification: {\n          consolidationToBaseAddress: true,\n        },\n      });\n      assert.strictEqual(result, true);\n    });\n\n    const wasmTransferKeepAliveHex =\n      '0xa80a0300161b969b6b53ef81225feea3882284c778cd4a406d23215fcf492e83f75d42960b00204aa9d101eb600400000065900f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9a7b7420ee3e4fe2b88da0fc42b30897e18d56d8b56a1934211d9de730cf96de300';\n    const wasmTransferAllHex =\n      '0x900a04009f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f025401d50121030000009d880f001000000067f9723393ef76214df0118c34bbbd3dbebc8ed46a10973a8c969d48fe7598c9149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d00';\n\n    it('should accept a valid WASM-built payment (tdot)', async function () {\n      const txParams = {\n        recipients: [{ amount: '2000000000000', address: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD' }],\n      };\n      const result = await basecoin.verifyTransaction({ txPrebuild: { txHex: wasmTransferKeepAliveHex }, txParams });\n      assert.strictEqual(result, true);\n    });\n\n    it('should reject WASM-built payment with wrong amount (tdot)', async function () {\n      const txParams = {\n        recipients: [{ amount: '9999', address: '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD' }],\n      };\n      await basecoin\n        .verifyTransaction({ txPrebuild: { txHex: wasmTransferKeepAliveHex }, txParams })\n        .should.be.rejectedWith(/does not match transaction amount/);\n    });\n\n    it('should reject WASM-built payment with wrong recipient (tdot)', async function () {\n      const txParams = {\n        recipients: [{ amount: '2000000000000', address: '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74' }],\n      };\n      await basecoin\n        .verifyTransaction({ txPrebuild: { txHex: wasmTransferKeepAliveHex }, txParams })\n        .should.be.rejectedWith(/does not match transaction destination address/);\n    });\n\n    it('should verify WASM-built transferAll consolidation (tdot)', async function () {\n      const mockedWallet = {\n        coinSpecific: () => ({ baseAddress: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq' }),\n      };\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex: wasmTransferAllHex },\n        txParams: {},\n        wallet: mockedWallet as any,\n        verification: { consolidationToBaseAddress: true },\n      });\n      assert.strictEqual(result, true);\n    });\n\n    it('should verify WASM-built transferAll with recipients skips amount check (tdot)', async function () {\n      const mockedWallet = {\n        coinSpecific: () => ({ baseAddress: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq' }),\n      };\n      const txParams = {\n        recipients: [{ address: '5Ffp1wJCPu4hzVDTo7XaMLqZSvSadyUQmxWPDw74CBjECSoq', amount: '999999' }],\n      };\n      const result = await basecoin.verifyTransaction({\n        txPrebuild: { txHex: wasmTransferAllHex },\n        txParams,\n        wallet: mockedWallet as any,\n        verification: { consolidationToBaseAddress: true },\n      });\n      assert.strictEqual(result, true);\n    });\n\n    it('should decode wasm-built signing payload with legacy TransactionBuilderFactory', async function () {\n      const { TransactionBuilderFactory } = await import('../../src/lib');\n      const factory = new TransactionBuilderFactory(coins.get('tdot'));\n      const txBuilder = factory.from(wasmTransferKeepAliveHex);\n      txBuilder.sender({ address: '5EGoFA95omzemRssELLDjVenNZ68aXyUeqtKQScXSEBvVJkr' });\n      txBuilder.validity({ firstValid: 1000 });\n      txBuilder.referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d');\n      const tx = await txBuilder.build();\n      const json = tx.toJson();\n      assert.strictEqual((json as any).to, '5CZh773vKGwKFCYUjGc31AwXCbf7TPkavdeuk2XoujJMjbBD');\n      assert.strictEqual((json as any).amount, '2000000000000');\n    });\n  });\n\n  describe('isWalletAddress', () => {\n    it('should verify valid wallet address with correct keychain and index', async function () {\n      const address = '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74';\n      const commonKeychain =\n        '6d2d5150f6e435dfd9b4f225f2cc29d95ec3b61b34e8bec98693b1a7ffe44cd764f99ee5058838d785c73360ad4f24d78e0255ab2c368c09060b29a9b27f040e';\n      const index = '3';\n      const keychains = [{ id: '1', type: 'tss' as const, commonKeychain }];\n\n      const result = await basecoin.isWalletAddress({ keychains, address, index });\n      result.should.equal(true);\n    });\n\n    it('should return false for address with incorrect keychain', async function () {\n      const address = '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74';\n      const wrongKeychain =\n        '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';\n      const index = '3';\n      const keychains = [{ id: '1', type: 'tss' as const, commonKeychain: wrongKeychain }];\n\n      const result = await basecoin.isWalletAddress({ keychains, address, index });\n      result.should.equal(false);\n    });\n\n    it('should return false for address with incorrect index', async function () {\n      const address = '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74';\n      const commonKeychain =\n        '6d2d5150f6e435dfd9b4f225f2cc29d95ec3b61b34e8bec98693b1a7ffe44cd764f99ee5058838d785c73360ad4f24d78e0255ab2c368c09060b29a9b27f040e';\n      const wrongIndex = '999';\n      const keychains = [{ id: '1', type: 'tss' as const, commonKeychain }];\n\n      const result = await basecoin.isWalletAddress({ keychains, address, index: wrongIndex });\n      result.should.equal(false);\n    });\n\n    it('should throw error for invalid address', async function () {\n      const invalidAddress = 'invalidaddress';\n      const commonKeychain =\n        '6d2d5150f6e435dfd9b4f225f2cc29d95ec3b61b34e8bec98693b1a7ffe44cd764f99ee5058838d785c73360ad4f24d78e0255ab2c368c09060b29a9b27f040e';\n      const index = '3';\n      const keychains = [{ id: '1', type: 'tss' as const, commonKeychain }];\n\n      await assert.rejects(async () => await basecoin.isWalletAddress({ keychains, address: invalidAddress, index }), {\n        message: `invalid address: ${invalidAddress}`,\n      });\n    });\n  });\n\n  describe('getAddressFromPublicKey', () => {\n    it('should convert public key to SS58 address for testnet', function () {\n      const publicKey = '53845d7b6a6e4a666fa2a0f500b88849b02926da5590993731d2b428b7643690';\n      const expectedAddress = '5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74';\n\n      const address = basecoin.getAddressFromPublicKey(publicKey);\n      address.should.equal(expectedAddress);\n    });\n\n    it('should convert public key to SS58 address for mainnet', function () {\n      const publicKey = '53845d7b6a6e4a666fa2a0f500b88849b02926da5590993731d2b428b7643690';\n      // Mainnet uses different SS58 prefix (0) vs testnet (42)\n      const address = prodCoin.getAddressFromPublicKey(publicKey);\n      address.should.be.type('string');\n      address.length.should.be.greaterThan(0);\n      // Should be different from testnet address\n      address.should.not.equal('5DxD9nT16GQLrU6aB5pSS5VtxoZbVju3NHUCcawxZyZCTf74');\n    });\n  });\n\n  describe('createBroadcastableSweepTransaction (MPCv2):', () => {\n    const sandBox = sinon.createSandbox();\n    let userKeyShare: Buffer;\n    let backupKeyShare: Buffer;\n    let commonKeychain: string;\n    let mpcv2SweepTxRequest: any;\n    let mpcv2SignatureHex: string;\n\n    before(async function () {\n      const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n      commonKeychain = userDkg.getCommonKeychain();\n      userKeyShare = userDkg.getKeyShare();\n      backupKeyShare = backupDkg.getKeyShare();\n\n      const accountInfoCB = sandBox.stub(Dot.prototype, 'getAccountInfo' as keyof Dot);\n      accountInfoCB.resolves({ nonce: 123, freeBalance: 1510000000000 });\n      const headerInfoCB = sandBox.stub(Dot.prototype, 'getHeaderInfo' as keyof Dot);\n      headerInfoCB.resolves({\n        headerNumber: testData.westendBlock.blockNumber,\n        headerHash: testData.westendBlock.hash,\n      });\n      const getFeeCB = sandBox.stub(Dot.prototype, 'getFee' as keyof Dot);\n      getFeeCB.resolves(15783812856);\n      const getMaterialCB = sandBox.stub(Dot.prototype, 'getMaterial' as keyof Dot);\n      getMaterialCB.resolves(utils.getMaterial(coins.get('tdot')));\n\n      // no walletPassphrase -> unsigned sweep path returns MPCSweepTxs\n      const sweep = (await basecoin.recover({\n        bitgoKey: commonKeychain,\n        recoveryDestination: testData.accounts.account1.address,\n      })) as MPCSweepTxs;\n      sandBox.restore();\n\n      mpcv2SweepTxRequest = sweep.txRequests[0];\n      const unsignedTx = mpcv2SweepTxRequest.transactions[0].unsignedTx;\n      const signature = await signRecoveryEddsaMPCv2(\n        Buffer.from(unsignedTx.signableHex, 'hex'),\n        unsignedTx.derivationPath,\n        userKeyShare,\n        backupKeyShare,\n        commonKeychain\n      );\n      mpcv2SignatureHex = signature.toString('hex');\n    });\n\n    function buildParams(ovc: any): MPCSweepRecoveryOptions {\n      return {\n        signatureShares: [\n          {\n            txRequest: mpcv2SweepTxRequest,\n            tssVersion: '0.0.1',\n            ovc: [ovc],\n          },\n        ],\n      } as MPCSweepRecoveryOptions;\n    }\n\n    it('should take MPCv2 OVC output and generate a signed sweep transaction', async function () {\n      const params = buildParams({ eddsaMpcv2Signature: mpcv2SignatureHex });\n      const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);\n\n      recoveryTxn.transactions[0].serializedTx.should.not.equal(\n        mpcv2SweepTxRequest.transactions[0].unsignedTx.serializedTx\n      );\n      recoveryTxn.transactions[0].serializedTx.should.not.be.empty();\n      (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(0);\n      (recoveryTxn.lastScanIndex ?? 0).should.equal(0);\n    });\n\n    it('should reject a tampered MPCv2 signature', async function () {\n      const unsignedTx = mpcv2SweepTxRequest.transactions[0].unsignedTx;\n      const tamperedMessage = Buffer.concat([Buffer.from(unsignedTx.signableHex, 'hex'), Buffer.from('00', 'hex')]);\n      const tamperedSignature = await signRecoveryEddsaMPCv2(\n        tamperedMessage,\n        unsignedTx.derivationPath,\n        userKeyShare,\n        backupKeyShare,\n        commonKeychain\n      );\n\n      await basecoin\n        .createBroadcastableSweepTransaction(buildParams({ eddsaMpcv2Signature: tamperedSignature.toString('hex') }))\n        .should.be.rejectedWith('Invalid signature');\n    });\n\n    it('should throw when MPCv2 OVC is missing signature(s)', async function () {\n      await basecoin\n        .createBroadcastableSweepTransaction(buildParams({}))\n        .should.be.rejectedWith('Missing signature(s)');\n    });\n\n    it('should route MPCv1-shaped ovc to the MPCv1 verify branch and reject an invalid signature', async function () {\n      const mpc = await EDDSAMethods.getInitializedMpcInstance();\n      const derivedPubKey = mpc.deriveUnhardened(commonKeychain, 'm/0').slice(0, 64);\n      await basecoin\n        .createBroadcastableSweepTransaction(\n          buildParams({\n            eddsaSignature: { R: '00'.repeat(32), sigma: '00'.repeat(32), y: derivedPubKey },\n          })\n        )\n        .should.be.rejectedWith('Invalid signature');\n    });\n  });\n});\n"]}