@bitgo-beta/sdk-coin-ada 2.3.14-beta.202 → 2.3.14-beta.2021

package/dist/test/unit/ada.js

@@ -0,0 +1,1704 @@
+"use strict";
+/**
+ * @prettier
+ */
+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 should = require("should");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const crypto_1 = require("crypto");
+const sinon = __importStar(require("sinon"));
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const resources_1 = require("../resources");
+const _ = __importStar(require("lodash"));
+const CardanoWasm = __importStar(require("@emurgo/cardano-serialization-lib-nodejs"));
+const src_1 = require("../../src");
+const lib_1 = require("../../src/lib");
+const enum_1 = require("../../../sdk-core/src/account-lib/baseCoin/enum");
+const assert_1 = __importDefault(require("assert"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const nock_1 = __importDefault(require("nock"));
+describe('ADA', function () {
+    const coinName = 'ada';
+    const tcoinName = 't' + coinName;
+    let bitgo;
+    let basecoin;
+    let newTxPrebuild;
+    let newTxParams;
+    const txPrebuild = {
+        txHex: resources_1.rawTx.unsignedTx,
+        txInfo: {},
+    };
+    const txParams = {
+        recipients: [
+            {
+                address: resources_1.rawTx.outputAddress1.address,
+                amount: '5000000',
+            },
+            {
+                address: resources_1.rawTx.outputAddress2.address,
+                amount: '248329150',
+            },
+        ],
+    };
+    const transactionExplanation = {
+        displayOrder: ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'type'],
+        id: 'f48f6ea0f75f3f942855cc0edf29e81e1e0724e75f5db8a1575b166fb202176c',
+        outputs: [
+            {
+                address: 'addr_test1qqnnvptrc3rec64q2n9jh572ncu5wvdtt8uvg4g3aj96s5dwu9nj70mlahzglm9939uevupsmj8dcdqv25d5n5r8vw8sn7prey',
+                amount: '7823121',
+            },
+            {
+                address: 'addr_test1vr8rakm66rcfv4fcxqykg5lf0yv7lsyk9mvapx369jpvtcgfcuk7f',
+                amount: '13041729',
+            },
+        ],
+        outputAmount: '20864850',
+        changeOutputs: [],
+        changeAmount: '0',
+        fee: { fee: '167173' },
+        type: 'Transfer',
+        certificates: [],
+        withdrawals: [],
+        pledgeDetails: undefined,
+    };
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.initializeTestVars();
+        bitgo.safeRegister(coinName, src_1.Ada.createInstance);
+        bitgo.safeRegister(tcoinName, src_1.Tada.createInstance);
+        basecoin = bitgo.coin(tcoinName);
+        newTxPrebuild = () => {
+            return _.cloneDeep(txPrebuild);
+        };
+        newTxParams = () => {
+            return _.cloneDeep(txParams);
+        };
+    });
+    it('should instantiate the coin', function () {
+        let localBasecoin = bitgo.coin(tcoinName);
+        localBasecoin.should.be.an.instanceof(src_1.Tada);
+        localBasecoin.getChain().should.equal(tcoinName);
+        localBasecoin.getFullName().should.equal('Testnet Ada');
+        localBasecoin = bitgo.coin(coinName);
+        localBasecoin.should.be.an.instanceof(src_1.Ada);
+        localBasecoin.getChain().should.equal(coinName);
+        localBasecoin.getFullName().should.equal('Cardano ADA');
+    });
+    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(false);
+        });
+        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', () => {
+        it('should sign transaction', async function () {
+            const signed = await basecoin.signTransaction({
+                txPrebuild: {
+                    txHex: resources_1.rawTx.unsignedTx2,
+                },
+                pubs: [resources_1.publicKeys.pubKey1],
+                prv: resources_1.privateKeys.prvKey4,
+            });
+            signed.txHex.should.equal(resources_1.rawTx.signedTx2);
+        });
+        it('should fail to sign transaction with an invalid key', async function () {
+            try {
+                await basecoin.signTransaction({
+                    txPrebuild: {
+                        txHex: resources_1.rawTx.unsignedTx2,
+                    },
+                    pubs: [resources_1.publicKeys.pubKey1],
+                    prv: resources_1.privateKeys.prvKey2,
+                });
+            }
+            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: resources_1.rawTx.unsignedTx,
+                        key: resources_1.enterpriseAccounts.account1.publicKey,
+                    },
+                    prv: resources_1.enterpriseAccounts.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('Verify transaction: ', () => {
+        it('should succeed to verify unsigned transaction in hex encoding', async () => {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            const verification = {};
+            const isTransactionVerified = await basecoin.verifyTransaction({ txParams, txPrebuild, verification });
+            isTransactionVerified.should.equal(true);
+        });
+        it('should succeed to verify signed transaction in hex encoding', async () => {
+            const txPrebuild = {
+                txHex: resources_1.rawTx.signedTx,
+                txInfo: {},
+            };
+            const txParams = newTxParams();
+            const verification = {};
+            const isTransactionVerified = await basecoin.verifyTransaction({ txParams, txPrebuild, verification });
+            isTransactionVerified.should.equal(true);
+        });
+        it('should fail verify transactions when have different recipients', async () => {
+            const txPrebuild = newTxPrebuild();
+            const txParams = {
+                recipients: [
+                    {
+                        address: '9f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f0254',
+                        amount: '1000000000000000000000000',
+                    },
+                    {
+                        address: '9f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f0254',
+                        amount: '2000000000000000000000000',
+                    },
+                ],
+            };
+            const verification = {};
+            await basecoin
+                .verifyTransaction({ txParams, txPrebuild, verification })
+                .should.be.rejectedWith('cannot find recipient in expected output');
+        });
+        it('should verify when input `recipients` is absent', async function () {
+            const txParams = newTxParams();
+            txParams.recipients = undefined;
+            const txPrebuild = newTxPrebuild();
+            const validTransaction = await basecoin.verifyTransaction({ txParams, txPrebuild });
+            validTransaction.should.equal(true);
+        });
+        it('should fail verify when txHex is invalid', async function () {
+            const txParams = newTxParams();
+            txParams.recipients = undefined;
+            const txPrebuild = {};
+            await basecoin
+                .verifyTransaction({ txParams, txPrebuild })
+                .should.rejectedWith('missing required tx prebuild property txHex');
+        });
+        it('should succeed to verify transactions when recipients has extra data', async function () {
+            const txPrebuild = newTxPrebuild();
+            const txParams = newTxParams();
+            txParams.data = 'data';
+            const validTransaction = await basecoin.verifyTransaction({ txParams, txPrebuild });
+            validTransaction.should.equal(true);
+        });
+        it('should verify a valid consolidation transaction', async () => {
+            const consolidationTx = {
+                txRequestId: '1b5c79c5-ab7c-4f47-912b-de6a95fb0779',
+                walletId: '64fa31a94db65a0007c9691b',
+                txHex: '84a40081825820db46c7c76ea54fec2ca0a2f94b77a238931a8dce2387c99a12b08dd8aac21c4f000181825839004601fc016ac38580916d3520bc76b659298156008738d347aa93142f4601fc016ac38580916d3520bc76b659298156008738d347aa93142f1a3b984357021a000286a9031a060e37eea0f5f6',
+                feeInfo: {
+                    fee: 165545,
+                    feeString: '165545',
+                },
+                txInfo: {
+                    minerFee: '165545',
+                    spendAmount: '999834455',
+                    spendAmounts: [
+                        {
+                            coinName: 'tada',
+                            amountString: '999834455',
+                        },
+                    ],
+                    payGoFee: '0',
+                    outputs: [
+                        {
+                            address: 'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',
+                            value: 999834455,
+                            wallet: '64fa31a94db65a0007c9691b',
+                            wallets: ['64fa31a94db65a0007c9691b'],
+                            enterprise: '62cc59b727443a0007089033',
+                            enterprises: ['62cc59b727443a0007089033'],
+                            valueString: '999834455',
+                            coinName: 'tada',
+                            walletType: 'hot',
+                            walletTypes: ['hot'],
+                        },
+                    ],
+                    inputs: [
+                        {
+                            value: 1000000000,
+                            address: 'addr_test1qqlzxfl7tlgp999x4a7334pchycpkk72pykrsr3mryl3yj6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsvpgl8w',
+                            valueString: '1000000000',
+                        },
+                    ],
+                    type: '0',
+                },
+                consolidateId: '68b9fc18558006aab53785615fea7c28',
+                coin: 'tada',
+            };
+            const mockedWallet = {
+                coinSpecific: () => {
+                    return {
+                        rootAddress: 'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',
+                    };
+                },
+            };
+            try {
+                const isVerified = await basecoin.verifyTransaction({
+                    txParams: {},
+                    txPrebuild: consolidationTx,
+                    wallet: mockedWallet,
+                    verification: {
+                        consolidationToBaseAddress: true,
+                    },
+                });
+                isVerified.should.equal(true);
+            }
+            catch (e) {
+                assert_1.default.fail('Transaction should pass verification');
+            }
+        });
+        it('should verify a valid sponsored consolidation transaction', async () => {
+            const consolidationTx = {
+                txRequestId: '1b5c79c5-ab7c-4f47-912b-de6a95fb0779',
+                walletId: '64fa31a94db65a0007c9691b',
+                txHex: '84a40082825820227f65d20ac6e49602d79c623c51911ead824235e01eb2a1e7e33a72f0747cbb00825820227f65d20ac6e49602d79c623c51911ead824235e01eb2a1e7e33a72f0747cbb0201828258390022098270a5c19c9fb706dce0e7e4566b234ec5f0010623cd63f198ad22098270a5c19c9fb706dce0e7e4566b234ec5f0010623cd63f198ad1a0098968082581d60cf90f9fb02c88bad3c5294d90587458c4f160a2db26ba8af3da255b11a05d42fb8021a0002a491031a06d8c048a0f5f6',
+                feeInfo: {
+                    fee: 165545,
+                    feeString: '165545',
+                },
+                txInfo: {
+                    minerFee: '165545',
+                    spendAmount: '999834455',
+                    spendAmounts: [
+                        {
+                            coinName: 'tada',
+                            amountString: '999834455',
+                        },
+                    ],
+                    payGoFee: '0',
+                    outputs: [
+                        {
+                            address: 'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',
+                            value: 999834455,
+                            wallet: '64fa31a94db65a0007c9691b',
+                            wallets: ['64fa31a94db65a0007c9691b'],
+                            enterprise: '62cc59b727443a0007089033',
+                            enterprises: ['62cc59b727443a0007089033'],
+                            valueString: '999834455',
+                            coinName: 'tada',
+                            walletType: 'hot',
+                            walletTypes: ['hot'],
+                        },
+                    ],
+                    inputs: [
+                        {
+                            value: 1000000000,
+                            address: 'addr_test1qqlzxfl7tlgp999x4a7334pchycpkk72pykrsr3mryl3yj6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsvpgl8w',
+                            valueString: '1000000000',
+                        },
+                    ],
+                    type: '0',
+                    feeAddress: 'addr_test1vr8ep70mqtyghtfu222djpv8gkxy79s29kexh2908k39tvge02d5j',
+                },
+                consolidateId: '68b9fc18558006aab53785615fea7c28',
+                coin: 'tada',
+            };
+            const mockedWallet = {
+                coinSpecific: () => {
+                    return {
+                        rootAddress: 'addr_test1qq3qnqns5hqee8ahqmwwpely2e4jxnk97qqsvg7dv0ce3tfzpxp8pfwpnj0mwpkuurn7g4ntyd8vtuqpqc3u6cl3nzksvggu82',
+                    };
+                },
+            };
+            try {
+                const isVerified = await basecoin.verifyTransaction({
+                    txParams: {},
+                    txPrebuild: consolidationTx,
+                    wallet: mockedWallet,
+                    verification: {
+                        consolidationToBaseAddress: true,
+                    },
+                });
+                isVerified.should.equal(true);
+            }
+            catch (e) {
+                assert_1.default.fail('Transaction should pass verification');
+            }
+        });
+        it('should fail to sign a spoofed consolidation transaction', async function () {
+            // Set up wallet data
+            const walletData = {
+                id: '5b34252f1bf349930e34020a00000000',
+                coin: 'tada',
+                keys: [
+                    '5b3424f91bf349930e34017500000000',
+                    '5b3424f91bf349930e34017600000000',
+                    '5b3424f91bf349930e34017700000000',
+                ],
+                coinSpecific: {
+                    rootAddress: 'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',
+                },
+                multisigType: 'tss',
+            };
+            const fakePrv = await (0, sdk_api_1.encrypt)('password', 'prv');
+            const walletObj = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+            const bgUrl = sdk_core_1.common.Environments['mock'].uri;
+            (0, nock_1.default)(bgUrl)
+                .get('/api/v2/tada/key/5b3424f91bf349930e34017500000000')
+                .reply(200, [
+                {
+                    encryptedPrv: fakePrv,
+                },
+            ]);
+            // Mock the API response for buildAccountConsolidations
+            (0, nock_1.default)(bgUrl)
+                .post('/api/v2/tada/wallet/5b34252f1bf349930e34020a00000000/consolidateAccount/build')
+                .reply(200, [
+                {
+                    txRequestId: '1b5c79c5-ab7c-4f47-912b-de6a95fb0779',
+                    walletId: '64fa31a94db65a0007c9691b',
+                    txHex: '84a40081825820db46c7c76ea54fec2ca0a2f94b77a238931a8dce2387c99a12b08dd8aac21c4f01018282581d6033c378cee41b2e15ac848f7f6f1d2f78155ab12d93b713de898d855f1a00989680825839004601fc016ac38580916d3520bc76b659298156008738d347aa93142f4601fc016ac38580916d3520bc76b659298156008738d347aa93142f1b0000000217acebe9021a00028db5031a060e3b41a0f5f6',
+                    feeInfo: {
+                        fee: 165545,
+                        feeString: '165545',
+                    },
+                    txInfo: {
+                        minerFee: '165545',
+                        spendAmount: '999834455',
+                        spendAmounts: [
+                            {
+                                coinName: 'tada',
+                                amountString: '999834455',
+                            },
+                        ],
+                        payGoFee: '0',
+                        outputs: [
+                            {
+                                address: 'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',
+                                value: 999834455,
+                                wallet: '64fa31a94db65a0007c9691b',
+                                wallets: ['64fa31a94db65a0007c9691b'],
+                                enterprise: '62cc59b727443a0007089033',
+                                enterprises: ['62cc59b727443a0007089033'],
+                                valueString: '999834455',
+                                coinName: 'tada',
+                                walletType: 'hot',
+                                walletTypes: ['hot'],
+                            },
+                        ],
+                        inputs: [
+                            {
+                                value: 1000000000,
+                                address: 'addr_test1qqlzxfl7tlgp999x4a7334pchycpkk72pykrsr3mryl3yj6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsvpgl8w',
+                                valueString: '1000000000',
+                            },
+                        ],
+                        type: '0',
+                    },
+                    consolidateId: '68b9fc18558006aab53785615fea7c28',
+                    coin: 'tada',
+                },
+            ]);
+            // Call the function to test
+            await assert_1.default.rejects(async () => {
+                await walletObj.sendAccountConsolidations({
+                    walletPassphrase: 'password',
+                });
+            }, {
+                message: 'tx outputs does not match with expected address',
+            });
+        });
+    });
+    describe('Explain Transactions:', () => {
+        it('should explain an unsigned transfer transaction', async function () {
+            const explainedTransaction = await basecoin.explainTransaction({
+                txPrebuild: {
+                    txHex: resources_1.rawTx.unsignedTx2,
+                },
+            });
+            console.log(explainedTransaction);
+            explainedTransaction.should.deepEqual(transactionExplanation);
+        });
+        it('should fail to explain transaction with missing params', async function () {
+            try {
+                await basecoin.explainTransaction({
+                    txPrebuild: {},
+                });
+            }
+            catch (error) {
+                should.equal(error.message, 'Invalid transaction');
+            }
+        });
+        it('should fail to explain transaction with wrong params', async function () {
+            try {
+                await basecoin.explainTransaction({
+                    txPrebuild: {
+                        txHex: 'invalidTxHex',
+                    },
+                });
+            }
+            catch (error) {
+                should.equal(error.message, 'Invalid transaction');
+            }
+        });
+    });
+    describe('Parse Raw Transactions', () => {
+        it('should parse staking pledge transaction', function () {
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(resources_1.rawTx.unsignedNewPledgeTx);
+            should.equal(tx.type, enum_1.TransactionType.StakingPledge);
+        });
+        it('should parse staking activation tx', function () {
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(resources_1.rawTx.unsignedStakingActiveTx);
+            should.equal(tx.type, enum_1.TransactionType.StakingActivate);
+        });
+        it('should parse staking deactivation tx', function () {
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(resources_1.rawTx.unsignedStakingDeactiveTx);
+            should.equal(tx.type, enum_1.TransactionType.StakingDeactivate);
+        });
+    });
+    describe('Parse Transactions:', () => {
+        it('should parse an unsigned transfer transaction', async function () {
+            const parsedTransaction = await basecoin.parseTransaction({
+                txPrebuild: {
+                    txHex: resources_1.rawTx.unsignedTx2,
+                },
+            });
+            parsedTransaction.should.deepEqual(transactionExplanation);
+        });
+        it('should parse a signed transfer transaction', async function () {
+            const parsedTransaction = await basecoin.parseTransaction({
+                txPrebuild: {
+                    txHex: resources_1.rawTx.signedTx2,
+                },
+            });
+            parsedTransaction.should.deepEqual(transactionExplanation);
+        });
+        it('should fail parse a signed transfer transaction when explainTransaction response is undefined', async function () {
+            const stub = sinon.stub(src_1.Ada.prototype, 'explainTransaction');
+            stub.resolves(undefined);
+            await basecoin
+                .parseTransaction({
+                txPrebuild: {
+                    txHex: resources_1.rawTx.signedTx,
+                },
+            })
+                .should.be.rejectedWith('Invalid transaction');
+            stub.restore();
+        });
+    });
+    describe('Recover Transactions:', () => {
+        const destAddr = resources_1.address.address2;
+        const sandBox = sinon.createSandbox();
+        let callBack;
+        beforeEach(function () {
+            callBack = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack
+                .withArgs('address_info', {
+                _addresses: [resources_1.wrwUser.walletAddress0],
+            })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            callBack.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+        });
+        afterEach(function () {
+            sandBox.restore();
+        });
+        it('should take OVC output and generate a signed sweep transaction', async function () {
+            const params = resources_1.ovcResponse;
+            const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);
+            recoveryTxn.transactions[0].serializedTx.should.equal('84a400818258204bd0f991c1532cffe31d4a10db492b43175ec326765b6b29ceee598df2b61f470001818258390087379ebc5533ebe621963c915c3cbc5f08537fcdca4af8f8ae08ed4c87379ebc5533ebe621963c915c3cbc5f08537fcdca4af8f8ae08ed4c1a05f359ff021a00028701031a024972e1a10081825820bbacb13431b99208e6e8cdbf710147feaf06a39d71565e60b411ce9e4fa3f137584001a4ab8236563f69ff309e5786e8f39c629ed57676c692159cb2e0494c9e663355384c13c749d04c17a80ba2a45cc127df480fc64a43199a772f11acd5b14a0ff5f6');
+            recoveryTxn.transactions[0].scanIndex.should.equal(0);
+            recoveryTxn.lastScanIndex.should.equal(0);
+        });
+        it('should take consolidation OVC output and generate multiple signed sweep transactions', async function () {
+            const params = resources_1.ovcResponse2;
+            const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);
+            recoveryTxn.transactions[0].serializedTx.should.equal('84a400818258203e62e5ee8b12012c4b949f9777b72165239bb2146ae8b078b4d1c5ca8d3168e300018182583900baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd08004baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd080041a00960f7f021a00028701031a0250f7eaa10081825820500e0d725a5ba3a306da3503dfe57b8a14068a09b61b36ec068fcf8cf5c391de5840c836ce6d3262d5654706ea06721522d3b75f6d545245047a7be7463629d88b3f4264b995f591df52bdffcf09da1e6ab9e88de3714c6e2ec1961786cf1c586a07f5f6');
+            recoveryTxn.transactions[0].scanIndex.should.equal(1);
+            recoveryTxn.transactions[1].serializedTx.should.equal('84a4008182582029c10acf0e08f9523325c88243565af6b32274992189c1153903c410bed7c2c700018182583900baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd08004baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd080041a00960f7f021a00028701031a0250f7eaa1008182582062770b224bd314bc526fbd6a94e9082fb6458c425e6e09bad74004dd897e962358403842544f2ff28be054eb7c7997bc303b1e251eb13a41802c82318e592bb24eaa3197c450e797cc8559f0356cd5cdd1ab5eb80c5173e34e9e1d1737533a89520cf5f6');
+            recoveryTxn.transactions[1].scanIndex.should.equal(2);
+            recoveryTxn.transactions[2].serializedTx.should.equal('84a40081825820dd140f133d865e1bb5642e708fe685bf7601d71d0c99511e5d552da7f8bd10ff00018182583900baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd08004baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd080041a00960f7f021a00028701031a0250f7eaa1008182582053b4bb74aa38add458dafc8153f0aa8266acad59322b877ca9c23c5d3873779d5840e94ce7896957d094c6bafbf2ec10df5ebb0f1d2a27a7e31f2d45c531fb687edd6c4d33f8e9b99c7692b6fac6d8399bd8fd47641baae9bbb69f518d42ad11710af5f6');
+            recoveryTxn.transactions[2].scanIndex.should.equal(3);
+            recoveryTxn.transactions[3].serializedTx.should.equal('84a4008182582015a1d6db5d3f592aa1cda185b6359ca0e2921c3c51959f64222a6b7d95d3392300018182583900baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd08004baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd080041a00960f7f021a00028701031a0250f7eaa10081825820600f86ca22d670f0a990ade4e882c05e654343263494735a31517de0819676735840fe199f8e247a4cfabfeb4f9cb574aa35739a0aa98860ee0a85d720c4ab4fecfac7b4504df310b3e4bea04711f60652d4a8cf5eb41817293b8d29977fe695f704f5f6');
+            recoveryTxn.transactions[3].scanIndex.should.equal(4);
+            recoveryTxn.lastScanIndex.should.equal(20);
+        });
+        it('should recover a txn for non-bitgo recoveries', async function () {
+            const res = await basecoin.recover({
+                userKey: resources_1.wrwUser.userKey,
+                backupKey: resources_1.wrwUser.backupKey,
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                walletPassphrase: resources_1.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            });
+            res.should.not.be.empty();
+            res.should.hasOwnProperty('serializedTx');
+            sandBox.assert.calledTwice(basecoin.getDataFromNode);
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(res.serializedTx);
+            const txJson = tx.toJson();
+            const fee = Number(tx.explainTransaction().fee.fee);
+            should.deepEqual(txJson.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_1.tx_hash);
+            should.deepEqual(txJson.inputs[0].transaction_index, resources_1.testnetUTXO.UTXO_1.tx_index);
+            should.deepEqual(txJson.outputs[0].address, destAddr);
+            should.deepEqual(Number(txJson.outputs[0].amount) + fee, resources_1.testnetUTXO.UTXO_1.value);
+        });
+        it('should recover a txn for unsigned sweep recoveries', async function () {
+            const res = await basecoin.recover({
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                recoveryDestination: destAddr,
+            });
+            res.should.not.be.empty();
+            res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');
+            sandBox.assert.calledTwice(basecoin.getDataFromNode);
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(res.txRequests[0].transactions[0].unsignedTx.serializedTx);
+            const txJson = tx.toJson();
+            const fee = Number(tx.explainTransaction().fee.fee);
+            should.deepEqual(txJson.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_1.tx_hash);
+            should.deepEqual(txJson.inputs[0].transaction_index, resources_1.testnetUTXO.UTXO_1.tx_index);
+            should.deepEqual(txJson.outputs[0].address, destAddr);
+            should.deepEqual(Number(txJson.outputs[0].amount) + fee, resources_1.testnetUTXO.UTXO_1.value);
+        });
+        it('should recover ADA plus token UTXOs - token and ADA both appear in outputs (unsigned sweep)', async function () {
+            callBack
+                .withArgs('address_info', { _addresses: [resources_1.wrwUser.walletAddress0] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.ADAAndTokenUTXOs);
+            const res = await basecoin.recover({
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                recoveryDestination: destAddr,
+            });
+            res.should.not.be.empty();
+            const unsignedTx = res.txRequests[0].transactions[0].unsignedTx;
+            unsignedTx.should.hasOwnProperty('serializedTx');
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(unsignedTx.serializedTx);
+            const txJson = tx.toJson();
+            txJson.inputs.length.should.equal(2);
+            should.deepEqual(txJson.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_1.tx_hash);
+            should.deepEqual(txJson.inputs[1].transaction_id, resources_1.testnetUTXO.UTXO_TOKEN.tx_hash);
+            txJson.outputs.length.should.equal(2);
+            const tokenPolicyId = '2533cca6eb42076e144e9f2772c390dece9fce173bc38c72294b3924';
+            const tokenEncodedAssetName = '5741544552';
+            const tokenQuantity = '111';
+            const minADAForToken = 1500000;
+            const tokenOutput = txJson.outputs.find((o) => o.multiAssets !== undefined);
+            should.exist(tokenOutput);
+            should.deepEqual(tokenOutput.address, destAddr);
+            should.deepEqual(Number(tokenOutput.amount), minADAForToken);
+            const expectedPolicyId = CardanoWasm.ScriptHash.from_bytes(Buffer.from(tokenPolicyId, 'hex'));
+            const expectedAssetName = CardanoWasm.AssetName.new(Buffer.from(tokenEncodedAssetName, 'hex'));
+            tokenOutput.multiAssets
+                .get_asset(expectedPolicyId, expectedAssetName)
+                .to_str()
+                .should.equal(tokenQuantity);
+            const adaOutput = txJson.outputs.find((o) => o.multiAssets === undefined);
+            should.exist(adaOutput);
+            should.deepEqual(adaOutput.address, destAddr);
+            const fee = Number(tx.explainTransaction().fee.fee);
+            const totalBalance = resources_1.testnetUTXO.UTXO_1.value + resources_1.testnetUTXO.UTXO_TOKEN.value;
+            should.deepEqual(Number(adaOutput.amount), totalBalance - minADAForToken - fee);
+            const explained = tx.explainTransaction();
+            const explainedTokenOutput = explained.outputs.find((o) => o.amount === minADAForToken.toString());
+            should.exist(explainedTokenOutput);
+            // inputs and outputs in parsedTx should carry multiAssets
+            const parsedTxInputs = res.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs;
+            parsedTxInputs.length.should.equal(1);
+            should.exist(parsedTxInputs[0].multiAssets);
+            parsedTxInputs[0].multiAssets.length.should.equal(1);
+            should.deepEqual(parsedTxInputs[0].multiAssets[0].policy_id, tokenPolicyId);
+            should.deepEqual(parsedTxInputs[0].multiAssets[0].asset_name, tokenEncodedAssetName);
+            should.deepEqual(parsedTxInputs[0].multiAssets[0].quantity, tokenQuantity);
+            const parsedTxOutputs = res.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs;
+            const parsedTokenOutput = parsedTxOutputs.find((o) => o.multiAssets !== undefined);
+            should.exist(parsedTokenOutput);
+            parsedTokenOutput.multiAssets.length.should.equal(1);
+            should.deepEqual(parsedTokenOutput.multiAssets[0].policy_id, tokenPolicyId);
+            should.deepEqual(parsedTokenOutput.multiAssets[0].asset_name, tokenEncodedAssetName);
+            should.deepEqual(parsedTokenOutput.multiAssets[0].quantity, tokenQuantity);
+            // pure ADA output should not have multiAssets
+            const parsedAdaOutput = parsedTxOutputs.find((o) => o.multiAssets === undefined);
+            should.exist(parsedAdaOutput);
+        });
+        it('should recover ADA plus token UTXOs - token and ADA both appear in outputs (signed)', async function () {
+            callBack
+                .withArgs('address_info', { _addresses: [resources_1.wrwUser.walletAddress0] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.ADAAndTokenUTXOs);
+            const res = await basecoin.recover({
+                userKey: resources_1.wrwUser.userKey,
+                backupKey: resources_1.wrwUser.backupKey,
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                walletPassphrase: resources_1.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            });
+            res.should.not.be.empty();
+            res.should.hasOwnProperty('serializedTx');
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(res.serializedTx);
+            const txJson = tx.toJson();
+            txJson.inputs.length.should.equal(2);
+            should.deepEqual(txJson.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_1.tx_hash);
+            should.deepEqual(txJson.inputs[1].transaction_id, resources_1.testnetUTXO.UTXO_TOKEN.tx_hash);
+            // expect 2 outputs: one token output + one ADA change output, both at destAddr
+            txJson.outputs.length.should.equal(2);
+            const tokenPolicyId = '2533cca6eb42076e144e9f2772c390dece9fce173bc38c72294b3924';
+            const tokenEncodedAssetName = '5741544552';
+            const tokenQuantity = '111';
+            const minADAForToken = 1500000;
+            const tokenOutput = txJson.outputs.find((o) => o.multiAssets !== undefined);
+            should.exist(tokenOutput);
+            should.deepEqual(tokenOutput.address, destAddr);
+            should.deepEqual(Number(tokenOutput.amount), minADAForToken);
+            const expectedPolicyId = CardanoWasm.ScriptHash.from_bytes(Buffer.from(tokenPolicyId, 'hex'));
+            const expectedAssetName = CardanoWasm.AssetName.new(Buffer.from(tokenEncodedAssetName, 'hex'));
+            tokenOutput.multiAssets
+                .get_asset(expectedPolicyId, expectedAssetName)
+                .to_str()
+                .should.equal(tokenQuantity);
+            const adaOutput = txJson.outputs.find((o) => o.multiAssets === undefined);
+            should.exist(adaOutput);
+            should.deepEqual(adaOutput.address, destAddr);
+            const fee = Number(tx.explainTransaction().fee.fee);
+            const totalBalance = resources_1.testnetUTXO.UTXO_1.value + resources_1.testnetUTXO.UTXO_TOKEN.value;
+            should.deepEqual(Number(adaOutput.amount), totalBalance - minADAForToken - fee);
+        });
+    });
+    describe('Recover Transactions (MPCv2):', () => {
+        const destAddr = resources_1.address.address2;
+        const sandBox = sinon.createSandbox();
+        const walletPassphrase = resources_1.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();
+            mismatchedBitgoKey = otherUserDkg.getCommonKeychain();
+            mpcV2WalletAddress = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 0 }))
+                .address;
+            mismatchedWalletAddress = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mismatchedBitgoKey, index: 0 }))
+                .address;
+        });
+        let callBack;
+        beforeEach(function () {
+            callBack = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack
+                .withArgs('address_info', { _addresses: [mpcV2WalletAddress] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            callBack
+                .withArgs('address_info', { _addresses: [mismatchedWalletAddress] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            callBack.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+        });
+        afterEach(function () {
+            sandBox.restore();
+        });
+        it('should route to MPCv2 path for native ADA 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');
+            sandBox.assert.notCalled(getTSSSignatureSpy);
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(res.serializedTx);
+            const txJson = tx.toJson();
+            should.deepEqual(txJson.outputs[0].address, destAddr);
+        });
+        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 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 malformed precomputedMaterial and detect signing material itself (regression: WRW openSSLBytes collision)', async function () {
+            // WRW's generic Electron 'recover' IPC handler passes openSSLBytes (an ArrayBuffer)
+            // as a second positional argument to every coin's recover(), regardless of whether
+            // that coin uses it. Previously this was blindly trusted as precomputedMaterial,
+            // producing `JSON.parse(undefined)` -> SyntaxError: "undefined" is not valid JSON.
+            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);
+        });
+        it('should route to MPCv1 path when keycard is MPCv1 (regression)', async function () {
+            callBack
+                .withArgs('address_info', { _addresses: [resources_1.wrwUser.walletAddress0] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            const getTSSSignatureSpy = sandBox.spy(sdk_core_1.EDDSAMethods, 'getTSSSignature');
+            const res = await basecoin.recover({
+                userKey: resources_1.wrwUser.userKey,
+                backupKey: resources_1.wrwUser.backupKey,
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                walletPassphrase: resources_1.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            });
+            res.should.not.be.empty();
+            res.should.hasOwnProperty('serializedTx');
+            sandBox.assert.calledOnce(getTSSSignatureSpy);
+        });
+        it('should produce a cryptographically valid Ed25519 signature', async function () {
+            const signRecoverySpy = sandBox.spy(basecoin, 'signAdaMpcV2Recovery');
+            await basecoin.recover({
+                userKey: mpcV2UserKey,
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                recoveryDestination: destAddr,
+            });
+            const rawSig = await signRecoverySpy.firstCall.returnValue;
+            const signablePayload = signRecoverySpy.firstCall.args[0].message;
+            const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+            const accountId = MPC.deriveUnhardened(mpcV2CommonKeyChain, 'm/0').slice(0, 64);
+            const isValid = tweetnacl_1.default.sign.detached.verify(new Uint8Array(signablePayload), new Uint8Array(rawSig), new Uint8Array(Buffer.from(accountId, 'hex')));
+            isValid.should.be.true();
+        });
+        it('should throw missing userKey when backupKey and walletPassphrase are present but userKey is not', async function () {
+            callBack.resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            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 () {
+            callBack.resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            await basecoin
+                .recover({
+                userKey: mpcV2UserKey,
+                backupKey: undefined,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                recoveryDestination: destAddr,
+            })
+                .should.be.rejectedWith('missing backupKey');
+        });
+        it('should throw a clear error when the MPCv1 backup keycard fails to decrypt', async function () {
+            callBack
+                .withArgs('address_info', { _addresses: [resources_1.wrwUser.walletAddress0] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            await basecoin
+                .recover({
+                userKey: resources_1.wrwUser.userKey,
+                backupKey: 'not-a-valid-encrypted-keycard',
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                walletPassphrase: resources_1.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            })
+                .should.be.rejectedWith('Error decrypting backup keychain: invalid password or corrupted key');
+        });
+    });
+    describe('Recover Transactions Multiple UTXO:', () => {
+        const destAddr = resources_1.address.address2;
+        const sandBox = sinon.createSandbox();
+        beforeEach(function () {
+            const callBack = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack
+                .withArgs('address_info', {
+                _addresses: [resources_1.wrwUser.walletAddress0],
+            })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.TwoUTXO);
+            callBack.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+        });
+        afterEach(function () {
+            sandBox.restore();
+        });
+        it('should recover a txn for non-bitgo recoveries', async function () {
+            const res = await basecoin.recover({
+                userKey: resources_1.wrwUser.userKey,
+                backupKey: resources_1.wrwUser.backupKey,
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                walletPassphrase: resources_1.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            });
+            res.should.not.be.empty();
+            res.should.hasOwnProperty('serializedTx');
+            sandBox.assert.calledTwice(basecoin.getDataFromNode);
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(res.serializedTx);
+            const txJson = tx.toJson();
+            const fee = Number(tx.explainTransaction().fee.fee);
+            should.deepEqual(txJson.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_1.tx_hash);
+            should.deepEqual(txJson.inputs[0].transaction_index, resources_1.testnetUTXO.UTXO_1.tx_index);
+            should.deepEqual(txJson.inputs[1].transaction_id, resources_1.testnetUTXO.UTXO_2.tx_hash);
+            should.deepEqual(txJson.inputs[1].transaction_index, resources_1.testnetUTXO.UTXO_2.tx_index);
+            should.deepEqual(txJson.outputs[0].address, destAddr);
+            should.deepEqual(Number(txJson.outputs[0].amount) + fee, resources_1.testnetUTXO.UTXO_1.value + resources_1.testnetUTXO.UTXO_2.value);
+        });
+        it('should recover a txn for unsigned sweep recoveries', async function () {
+            const res = await basecoin.recover({
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                recoveryDestination: destAddr,
+            });
+            res.should.not.be.empty();
+            res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');
+            sandBox.assert.calledTwice(basecoin.getDataFromNode);
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(res.txRequests[0].transactions[0].unsignedTx.serializedTx);
+            const txJson = tx.toJson();
+            const fee = Number(tx.explainTransaction().fee.fee);
+            should.deepEqual(txJson.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_1.tx_hash);
+            should.deepEqual(txJson.inputs[0].transaction_index, resources_1.testnetUTXO.UTXO_1.tx_index);
+            should.deepEqual(txJson.inputs[1].transaction_id, resources_1.testnetUTXO.UTXO_2.tx_hash);
+            should.deepEqual(txJson.inputs[1].transaction_index, resources_1.testnetUTXO.UTXO_2.tx_index);
+            should.deepEqual(txJson.outputs[0].address, destAddr);
+            should.deepEqual(Number(txJson.outputs[0].amount) + fee, resources_1.testnetUTXO.UTXO_1.value + resources_1.testnetUTXO.UTXO_2.value);
+        });
+    });
+    describe('Build Consolidation Recoveries:', () => {
+        const baseAddr = resources_1.consolidationWrwUser.walletAddress0;
+        const sandBox = sinon.createSandbox();
+        beforeEach(function () {
+            const callBack = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack
+                .withArgs('address_info', {
+                _addresses: [resources_1.consolidationWrwUser.walletAddress1],
+            })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.ZeroUTXO);
+            callBack
+                .withArgs('address_info', {
+                _addresses: [resources_1.consolidationWrwUser.walletAddress2],
+            })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            callBack
+                .withArgs('address_info', {
+                _addresses: [resources_1.consolidationWrwUser.walletAddress3],
+            })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO2);
+            callBack.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+        });
+        afterEach(function () {
+            sandBox.restore();
+        });
+        it('should build signed consolidation recoveries', async function () {
+            const res = await basecoin.recoverConsolidations({
+                userKey: resources_1.consolidationWrwUser.userKey,
+                backupKey: resources_1.consolidationWrwUser.backupKey,
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                walletPassphrase: resources_1.consolidationWrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            res.should.not.be.empty();
+            res.transactions.length.should.equal(2);
+            res.lastScanIndex.should.equal(3);
+            const txn1 = res.transactions[0];
+            const tx1 = new lib_1.Transaction(basecoin);
+            tx1.fromRawTransaction(txn1.serializedTx);
+            const txJson1 = tx1.toJson();
+            const fee1 = Number(tx1.explainTransaction().fee.fee);
+            should.deepEqual(txJson1.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_1.tx_hash);
+            should.deepEqual(txJson1.inputs[0].transaction_index, resources_1.testnetUTXO.UTXO_1.tx_index);
+            should.deepEqual(txJson1.outputs[0].address, baseAddr);
+            should.deepEqual(Number(txJson1.outputs[0].amount) + fee1, resources_1.testnetUTXO.UTXO_1.value);
+            const txn2 = res.transactions[1];
+            const tx2 = new lib_1.Transaction(basecoin);
+            tx2.fromRawTransaction(txn2.serializedTx);
+            const txJson2 = tx2.toJson();
+            const fee2 = Number(tx2.explainTransaction().fee.fee);
+            should.deepEqual(txJson2.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_2.tx_hash);
+            should.deepEqual(txJson2.inputs[0].transaction_index, resources_1.testnetUTXO.UTXO_2.tx_index);
+            should.deepEqual(txJson2.outputs[0].address, baseAddr);
+            should.deepEqual(Number(txJson2.outputs[0].amount) + fee2, resources_1.testnetUTXO.UTXO_2.value);
+        });
+        it('should skip building consolidate transaction if balance is equal to zero', async function () {
+            await basecoin
+                .recoverConsolidations({
+                userKey: resources_1.consolidationWrwUser.userKey,
+                backupKey: resources_1.consolidationWrwUser.backupKey,
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                walletPassphrase: resources_1.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: resources_1.consolidationWrwUser.userKey,
+                backupKey: resources_1.consolidationWrwUser.backupKey,
+                bitgoKey: resources_1.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: resources_1.consolidationWrwUser.userKey,
+                backupKey: resources_1.consolidationWrwUser.backupKey,
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                startingScanIndex: 1,
+                endingScanIndex: 300,
+            })
+                .should.be.rejectedWith('Invalid starting or ending index to scan for addresses. startingScanIndex: 1, endingScanIndex: 300.');
+        });
+        it('should build unsigned consolidation recoveries', async function () {
+            const res = await basecoin.recoverConsolidations({
+                userKey: resources_1.consolidationWrwUser.userKey,
+                backupKey: resources_1.consolidationWrwUser.backupKey,
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                walletPassphrase: resources_1.consolidationWrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            res.should.not.be.empty();
+            res.transactions.length.should.equal(2);
+        });
+        it('should build unsigned consolidation recoveries for WRW (ADA only) and assert build response', async function () {
+            const res = await basecoin.recoverConsolidations({
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            res.should.not.be.empty();
+            res.txRequests.length.should.equal(2);
+            // Assert first consolidation txRequest structure
+            const txRequest1 = res.txRequests[0];
+            txRequest1.transactions.length.should.equal(1);
+            const unsignedTx1 = txRequest1.transactions[0].unsignedTx;
+            unsignedTx1.should.hasOwnProperty('serializedTx');
+            unsignedTx1.should.hasOwnProperty('parsedTx');
+            unsignedTx1.should.hasOwnProperty('coinSpecific');
+            // Deserialize and verify inputs/outputs
+            const tx1 = new lib_1.Transaction(basecoin);
+            tx1.fromRawTransaction(unsignedTx1.serializedTx);
+            const txJson1 = tx1.toJson();
+            const fee1 = Number(tx1.explainTransaction().fee.fee);
+            should.deepEqual(txJson1.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_1.tx_hash);
+            should.deepEqual(txJson1.inputs[0].transaction_index, resources_1.testnetUTXO.UTXO_1.tx_index);
+            should.deepEqual(txJson1.outputs[0].address, baseAddr);
+            should.deepEqual(Number(txJson1.outputs[0].amount) + fee1, resources_1.testnetUTXO.UTXO_1.value);
+            // parsedTx inputs/outputs must be present and carry correct address
+            const parsedTx1Inputs = unsignedTx1.parsedTx.inputs;
+            parsedTx1Inputs.length.should.equal(1);
+            should.deepEqual(parsedTx1Inputs[0].address, resources_1.consolidationWrwUser.walletAddress2);
+            const parsedTx1Outputs = unsignedTx1.parsedTx.outputs;
+            parsedTx1Outputs.length.should.be.greaterThan(0);
+            should.deepEqual(parsedTx1Outputs[0].address, baseAddr);
+            // Assert second consolidation txRequest structure
+            const txRequest2 = res.txRequests[1];
+            const unsignedTx2 = txRequest2.transactions[0].unsignedTx;
+            unsignedTx2.should.hasOwnProperty('serializedTx');
+            const tx2 = new lib_1.Transaction(basecoin);
+            tx2.fromRawTransaction(unsignedTx2.serializedTx);
+            const txJson2 = tx2.toJson();
+            const fee2 = Number(tx2.explainTransaction().fee.fee);
+            should.deepEqual(txJson2.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_2.tx_hash);
+            should.deepEqual(txJson2.inputs[0].transaction_index, resources_1.testnetUTXO.UTXO_2.tx_index);
+            should.deepEqual(txJson2.outputs[0].address, baseAddr);
+            should.deepEqual(Number(txJson2.outputs[0].amount) + fee2, resources_1.testnetUTXO.UTXO_2.value);
+            // lastScanIndex must be set in coinSpecific of the last txRequest
+            const lastCoinSpecific = unsignedTx2.coinSpecific;
+            lastCoinSpecific.should.hasOwnProperty('lastScanIndex');
+            lastCoinSpecific.lastScanIndex.should.equal(3);
+        });
+        it('should build unsigned consolidation recoveries for WRW (ADA + Token) and assert build response', async function () {
+            // Override walletAddress2 to return ADA+Token UTXOs
+            sandBox.restore();
+            const callBack2 = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack2
+                .withArgs('address_info', { _addresses: [resources_1.consolidationWrwUser.walletAddress1] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.ZeroUTXO);
+            callBack2
+                .withArgs('address_info', { _addresses: [resources_1.consolidationWrwUser.walletAddress2] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.ADAAndTokenUTXOs);
+            callBack2
+                .withArgs('address_info', { _addresses: [resources_1.consolidationWrwUser.walletAddress3] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.ZeroUTXO);
+            callBack2.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+            const tokenPolicyId = '2533cca6eb42076e144e9f2772c390dece9fce173bc38c72294b3924';
+            const tokenEncodedAssetName = '5741544552';
+            const tokenQuantity = '111';
+            const minADAForToken = 1500000;
+            const res = await basecoin.recoverConsolidations({
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            res.should.not.be.empty();
+            res.txRequests.length.should.equal(1);
+            const unsignedTx = res.txRequests[0].transactions[0].unsignedTx;
+            unsignedTx.should.hasOwnProperty('serializedTx');
+            const tx = new lib_1.Transaction(basecoin);
+            tx.fromRawTransaction(unsignedTx.serializedTx);
+            const txJson = tx.toJson();
+            // Two inputs: ADA UTXO + Token UTXO
+            txJson.inputs.length.should.equal(2);
+            should.deepEqual(txJson.inputs[0].transaction_id, resources_1.testnetUTXO.UTXO_1.tx_hash);
+            should.deepEqual(txJson.inputs[1].transaction_id, resources_1.testnetUTXO.UTXO_TOKEN.tx_hash);
+            // Two outputs: token output (with multiAssets) + pure ADA change to base address
+            txJson.outputs.length.should.equal(2);
+            const tokenOutput = txJson.outputs.find((o) => o.multiAssets !== undefined);
+            should.exist(tokenOutput);
+            should.deepEqual(tokenOutput.address, baseAddr);
+            should.deepEqual(Number(tokenOutput.amount), minADAForToken);
+            const expectedPolicyId = CardanoWasm.ScriptHash.from_bytes(Buffer.from(tokenPolicyId, 'hex'));
+            const expectedAssetName = CardanoWasm.AssetName.new(Buffer.from(tokenEncodedAssetName, 'hex'));
+            tokenOutput.multiAssets
+                .get_asset(expectedPolicyId, expectedAssetName)
+                .to_str()
+                .should.equal(tokenQuantity);
+            const adaOutput = txJson.outputs.find((o) => o.multiAssets === undefined);
+            should.exist(adaOutput);
+            should.deepEqual(adaOutput.address, baseAddr);
+            const fee = Number(tx.explainTransaction().fee.fee);
+            const totalBalance = resources_1.testnetUTXO.UTXO_1.value + resources_1.testnetUTXO.UTXO_TOKEN.value;
+            should.deepEqual(Number(adaOutput.amount), totalBalance - minADAForToken - fee);
+            // parsedTx inputs must carry multiAssets for the token UTXO
+            const parsedTxInputs = unsignedTx.parsedTx.inputs;
+            parsedTxInputs.length.should.equal(1);
+            should.deepEqual(parsedTxInputs[0].address, resources_1.consolidationWrwUser.walletAddress2);
+            should.exist(parsedTxInputs[0].multiAssets);
+            parsedTxInputs[0].multiAssets.length.should.equal(1);
+            should.deepEqual(parsedTxInputs[0].multiAssets[0].policy_id, tokenPolicyId);
+            should.deepEqual(parsedTxInputs[0].multiAssets[0].asset_name, tokenEncodedAssetName);
+            should.deepEqual(parsedTxInputs[0].multiAssets[0].quantity, tokenQuantity);
+            // parsedTx outputs must carry multiAssets for the token output
+            const parsedTxOutputs = unsignedTx.parsedTx.outputs;
+            const parsedTokenOutput = parsedTxOutputs.find((o) => o.multiAssets !== undefined);
+            should.exist(parsedTokenOutput);
+            parsedTokenOutput.multiAssets.length.should.equal(1);
+            should.deepEqual(parsedTokenOutput.multiAssets[0].policy_id, tokenPolicyId);
+            should.deepEqual(parsedTokenOutput.multiAssets[0].asset_name, tokenEncodedAssetName);
+            should.deepEqual(parsedTokenOutput.multiAssets[0].quantity, tokenQuantity);
+            // pure ADA output must not have multiAssets
+            const parsedAdaOutput = parsedTxOutputs.find((o) => o.multiAssets === undefined);
+            should.exist(parsedAdaOutput);
+            // lastScanIndex in coinSpecific of the last txRequest
+            unsignedTx.coinSpecific.should.hasOwnProperty('lastScanIndex');
+            unsignedTx.coinSpecific.lastScanIndex.should.equal(3);
+        });
+        it('should throw error if all addresses have balance less than 1 ADA', async function () {
+            sandBox.restore();
+            const callBack = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack.withArgs('address_info', sinon.match.has('_addresses')).resolves({
+                status: 200,
+                body: [
+                    {
+                        balance: 500000,
+                        utxo_set: [
+                            {
+                                tx_hash: '8df8d41207980f9e21de698bd5d6c395c39e420f7de27f8539052dd34e3a28d6',
+                                tx_index: 0,
+                                value: 500000,
+                            },
+                        ],
+                    },
+                ],
+            });
+            callBack.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+            await basecoin
+                .recoverConsolidations({
+                userKey: resources_1.consolidationWrwUser.userKey,
+                backupKey: resources_1.consolidationWrwUser.backupKey,
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                walletPassphrase: resources_1.consolidationWrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            })
+                .should.be.rejectedWith('Did not find an address with funds to recover.');
+        });
+        it('should build even if single address has no funds', async function () {
+            const res = await basecoin.recoverConsolidations({
+                userKey: resources_1.consolidationWrwUser.userKey,
+                backupKey: resources_1.consolidationWrwUser.backupKey,
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                walletPassphrase: resources_1.consolidationWrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            res.should.not.be.empty();
+            res.transactions.length.should.equal(2);
+        });
+        it('should build even if single address has insufficient funds', async function () {
+            const res = await basecoin.recoverConsolidations({
+                userKey: resources_1.consolidationWrwUser.userKey,
+                backupKey: resources_1.consolidationWrwUser.backupKey,
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                walletPassphrase: resources_1.consolidationWrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            res.should.not.be.empty();
+            res.transactions.length.should.equal(2);
+        });
+    });
+    describe('Build Consolidation Recoveries (MPCv2):', () => {
+        const sandBox = sinon.createSandbox();
+        const walletPassphrase = resources_1.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();
+            baseAddr = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 0 })).address;
+            mpcV2Address1 = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 1 })).address;
+            mpcV2Address2 = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 2 })).address;
+            mpcV2Address3 = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 3 })).address;
+        });
+        beforeEach(function () {
+            const callBack = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack
+                .withArgs('address_info', { _addresses: [mpcV2Address1] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.ZeroUTXO);
+            callBack
+                .withArgs('address_info', { _addresses: [mpcV2Address2] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            callBack
+                .withArgs('address_info', { _addresses: [mpcV2Address3] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO2);
+            callBack.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+        });
+        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);
+            res.lastScanIndex.should.equal(3);
+            const tx1 = new lib_1.Transaction(basecoin);
+            tx1.fromRawTransaction(res.transactions[0].serializedTx);
+            should.deepEqual(tx1.toJson().outputs[0].address, 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 leave MPCv1 base address derivation and signing unchanged (regression)', async function () {
+            sandBox.restore();
+            const callBack = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack
+                .withArgs('address_info', { _addresses: [resources_1.consolidationWrwUser.walletAddress1] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.ZeroUTXO);
+            callBack
+                .withArgs('address_info', { _addresses: [resources_1.consolidationWrwUser.walletAddress2] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO);
+            callBack
+                .withArgs('address_info', { _addresses: [resources_1.consolidationWrwUser.walletAddress3] })
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneUTXO2);
+            callBack.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+            const getTSSSignatureSpy = sandBox.spy(sdk_core_1.EDDSAMethods, 'getTSSSignature');
+            const res = await basecoin.recoverConsolidations({
+                userKey: resources_1.consolidationWrwUser.userKey,
+                backupKey: resources_1.consolidationWrwUser.backupKey,
+                bitgoKey: resources_1.consolidationWrwUser.bitgoKey,
+                walletPassphrase: resources_1.consolidationWrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            });
+            res.should.not.be.empty();
+            sandBox.assert.called(getTSSSignatureSpy);
+            const tx1 = new lib_1.Transaction(basecoin);
+            tx1.fromRawTransaction(res.transactions[0].serializedTx);
+            should.deepEqual(tx1.toJson().outputs[0].address, resources_1.consolidationWrwUser.walletAddress0);
+        });
+        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);
+        });
+        it('should throw missing userKey before scanning when walletPassphrase is set but userKey is omitted', async function () {
+            const getEddsaMaterialSpy = sandBox.spy(basecoin, 'getEddsaSigningMaterial');
+            await basecoin
+                .recoverConsolidations({
+                backupKey: mpcV2BackupKey,
+                bitgoKey: mpcV2CommonKeyChain,
+                walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+            })
+                .should.be.rejectedWith('missing userKey');
+            sandBox.assert.notCalled(getEddsaMaterialSpy);
+            sandBox.assert.notCalled(basecoin.getDataFromNode);
+        });
+    });
+    describe('Recover Transactions Failure:', () => {
+        const destAddr = resources_1.address.address2;
+        const sandBox = sinon.createSandbox();
+        afterEach(function () {
+            sandBox.restore();
+        });
+        it('should fail to recover due to not finding an address with funds', async function () {
+            const callBack = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack
+                .withArgs('address_info', sinon.match.has('_addresses'))
+                .resolves(resources_1.endpointResponses.addressInfoResponse.ZeroUTXO);
+            callBack.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+            await basecoin
+                .recover({
+                userKey: resources_1.wrwUser.userKey,
+                backupKey: resources_1.wrwUser.backupKey,
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                walletPassphrase: resources_1.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            })
+                .should.rejectedWith('Did not find address with funds to recover.');
+            sandBox.assert.calledOnce(basecoin.getDataFromNode);
+        });
+        it('should fail to recover due to not having more than 1 ADA in funds', async function () {
+            const callBack = sandBox.stub(src_1.Ada.prototype, 'getDataFromNode');
+            callBack
+                .withArgs('address_info', sinon.match.has('_addresses'))
+                .resolves(resources_1.endpointResponses.addressInfoResponse.OneSmallUTXO);
+            callBack.withArgs('tip').resolves(resources_1.endpointResponses.tipInfoResponse);
+            await basecoin
+                .recover({
+                userKey: resources_1.wrwUser.userKey,
+                backupKey: resources_1.wrwUser.backupKey,
+                bitgoKey: resources_1.wrwUser.bitgoKey,
+                walletPassphrase: resources_1.wrwUser.walletPassphrase,
+                recoveryDestination: destAddr,
+            })
+                .should.rejectedWith('Insufficient funds to recover, minimum required is 1 ADA plus fees, got 834455 fees: 165545');
+            sandBox.assert.calledTwice(basecoin.getDataFromNode);
+        });
+    });
+    describe('Verify wallet address (isWalletAddress):', () => {
+        const commonKeychain = 'ed312d0db4615688219c43231eb4b98d5883c0b44bcfef1956290555995ad68ef7c22917b4a8b69183864b83cc7028655cd7a70ef76d6948d809a15050054840';
+        it('should verify a valid wallet address at index 0', async function () {
+            const keychains = [
+                {
+                    id: '1',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'user',
+                },
+                {
+                    id: '2',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'backup',
+                },
+                {
+                    id: '3',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'bitgo',
+                },
+            ];
+            const address = 'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq';
+            const isValid = await basecoin.isWalletAddress({
+                address,
+                keychains,
+                index: 0,
+            });
+            isValid.should.equal(true);
+        });
+        it('should fail to verify an address with wrong index', async function () {
+            const keychains = [
+                {
+                    id: '1',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'user',
+                },
+                {
+                    id: '2',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'backup',
+                },
+                {
+                    id: '3',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'bitgo',
+                },
+            ];
+            const isValid = await basecoin.isWalletAddress({
+                address: 'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq',
+                keychains,
+                index: 2,
+            });
+            isValid.should.equal(false);
+        });
+        it('should fail to verify a random address not from wallet', async function () {
+            const keychains = [
+                {
+                    id: '1',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'user',
+                },
+                {
+                    id: '2',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'backup',
+                },
+                {
+                    id: '3',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'bitgo',
+                },
+            ];
+            // Use a random valid ADA address not from this wallet
+            const randomAddress = 'addr_test1vr8rakm66rcfv4fcxqykg5lf0yv7lsyk9mvapx369jpvtcgfcuk7f';
+            const isValid = await basecoin.isWalletAddress({
+                address: randomAddress,
+                keychains,
+                index: 0,
+            });
+            isValid.should.equal(false);
+        });
+        it('should throw error for invalid address format', async function () {
+            const keychains = [
+                {
+                    id: '1',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'user',
+                },
+                {
+                    id: '2',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'backup',
+                },
+                {
+                    id: '3',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'bitgo',
+                },
+            ];
+            const invalidAddress = 'not_a_valid_address';
+            await basecoin
+                .isWalletAddress({
+                address: invalidAddress,
+                keychains,
+                index: 0,
+            })
+                .should.be.rejectedWith('Invalid Cardano Address: not_a_valid_address');
+        });
+        it('should throw error when keychains are missing', async function () {
+            const address = 'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq';
+            await basecoin
+                .isWalletAddress({
+                address,
+                keychains: [],
+                index: 0,
+            })
+                .should.be.rejectedWith('missing required param keychains');
+        });
+        it('should throw error when commonKeychain is missing', async function () {
+            const keychains = [
+                {
+                    id: '1',
+                    type: 'tss',
+                    source: 'user',
+                    // commonKeychain is missing
+                },
+            ];
+            const address = 'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq';
+            await basecoin
+                .isWalletAddress({
+                address,
+                keychains,
+                index: 0,
+            })
+                .should.be.rejectedWith('missing required param commonKeychain');
+        });
+        it('should throw error when keychains have mismatched commonKeychains', async function () {
+            const keychains = [
+                {
+                    id: '1',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'user',
+                },
+                {
+                    id: '2',
+                    commonKeychain: 'differentKeychain1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+                    type: 'tss',
+                    source: 'backup',
+                },
+            ];
+            const address = 'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq';
+            await basecoin
+                .isWalletAddress({
+                address,
+                keychains,
+                index: 0,
+            })
+                .should.be.rejectedWith('all keychains must have the same commonKeychain for MPC coins');
+        });
+        it('should verify address when derivedFromParentWithSeed is present', async function () {
+            const derivedFromParentWithSeed = 'testDerivationSeed123';
+            const keychains = [
+                {
+                    id: '1',
+                    commonKeychain: commonKeychain,
+                    derivedFromParentWithSeed: derivedFromParentWithSeed,
+                    type: 'tss',
+                    source: 'user',
+                },
+                {
+                    id: '2',
+                    commonKeychain: commonKeychain,
+                    derivedFromParentWithSeed: derivedFromParentWithSeed,
+                    type: 'tss',
+                    source: 'backup',
+                },
+                {
+                    id: '3',
+                    commonKeychain: commonKeychain,
+                    derivedFromParentWithSeed: derivedFromParentWithSeed,
+                    type: 'tss',
+                    source: 'bitgo',
+                },
+            ];
+            const { address: expectedAddress } = await basecoin.getAdaAddressAndAccountId({
+                bitgoKey: commonKeychain,
+                index: 0,
+                seed: derivedFromParentWithSeed,
+            });
+            const isValid = await basecoin.isWalletAddress({
+                address: expectedAddress,
+                keychains,
+                index: 0,
+            });
+            isValid.should.equal(true);
+        });
+        it('should fail verification when derivedFromParentWithSeed is missing but address was created with seed', async function () {
+            const derivedFromParentWithSeed = 'testDerivationSeed123';
+            const { address: addressWithSeed } = await basecoin.getAdaAddressAndAccountId({
+                bitgoKey: commonKeychain,
+                index: 0,
+                seed: derivedFromParentWithSeed,
+            });
+            const keychainsWithoutSeed = [
+                {
+                    id: '1',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'user',
+                },
+                {
+                    id: '2',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'backup',
+                },
+                {
+                    id: '3',
+                    commonKeychain: commonKeychain,
+                    type: 'tss',
+                    source: 'bitgo',
+                },
+            ];
+            const isValid = await basecoin.isWalletAddress({
+                address: addressWithSeed,
+                keychains: keychainsWithoutSeed,
+                index: 0,
+            });
+            isValid.should.equal(false);
+        });
+    });
+    describe('Verify token consolidation transaction:', () => {
+        it('should fail to verify a spoofed token consolidation transaction with incorrect address', async () => {
+            const consolidationTx = {
+                txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',
+                walletId: '63068ed4efa63a000877f02fd4b0fa6d',
+                txHex: '84a400818258204bd0f991c1532cffe31d4a10db492b43175ec326765b6b29ceee598df2b61f470001818258390087379ebc5533ebe621963c915c3cbc5f08537fcdca4af8f8ae08ed4c87379ebc5533ebe621963c915c3cbc5f08537fcdca4af8f8ae08ed4c1a05f359ff021a00028701031a024972e1a10081825820bbacb13431b99208e6e8cdbf710147feaf06a39d71565e60b411ce9e4fa3f137584001a4ab8236563f69ff309e5786e8f39c629ed57676c692159cb2e0494c9e663355384c13c749d04c17a80ba2a45cc127df480fc64a43199a772f11acd5b14a0ff5f6',
+                feeInfo: {
+                    fee: 10000,
+                    feeString: '10000',
+                },
+                txInfo: {
+                    inputs: [
+                        {
+                            address: '8iLa26KSbdpBUzNK7uYq8FvyuyA5h4k4erDHsDcPbHus',
+                            value: 2.0173228e10,
+                            valueString: '20173228000',
+                        },
+                        {
+                            address: '8P2kX7Tyh9eS3RKdaBhqbEtQGAX58DXzL7mhDQABGX2d',
+                            value: 10000,
+                            valueString: '10000',
+                        },
+                    ],
+                    minerFee: '10000',
+                    outputs: [
+                        {
+                            address: 'addr_test1vr8rakm66rcfv4fcxqykg5lf0yv7lsyk9mvapx369jpvtcgfcuk7f',
+                            coinName: 'tada:usdt',
+                            enterprise: {
+                                $oid: '5553ba8ae7a5c77006719661',
+                            },
+                            enterprises: [
+                                {
+                                    $oid: '5553ba8ae7a5c77006719661',
+                                },
+                            ],
+                            value: 2.0173228e10,
+                            valueString: '20173228000',
+                            wallet: {
+                                $oid: '62f4c3720d92c50008257eb5',
+                            },
+                            walletType: 'hot',
+                            wallets: [
+                                {
+                                    $oid: '62f4c3720d92c50008257eb5',
+                                },
+                            ],
+                        },
+                    ],
+                    payGoFee: '0',
+                    spendAmount: '20173228000',
+                    spendAmounts: [
+                        {
+                            amountString: '20173228000',
+                            coinName: 'tada:usdt',
+                        },
+                    ],
+                    type: 'Send',
+                },
+                consolidateId: '6712d7fda6de4906d658c04aebbf8f9b',
+                coin: 'tada',
+            };
+            // Mock the wallet with a different address than the transaction's output
+            const mockedWallet = {
+                coinSpecific: () => {
+                    return {
+                        rootAddress: 'addr_test1qqnnvptrc3rec64q2n9jh572ncu5wvdtt8uvg4g3aj96s5dwu9nj70mlahzglm9939uevupsmj8dcdqv25d5n5r8vw8sn7prey',
+                    };
+                },
+            };
+            await basecoin
+                .verifyTransaction({
+                txParams: {},
+                txPrebuild: consolidationTx,
+                wallet: mockedWallet,
+                verification: {
+                    consolidationToBaseAddress: true,
+                },
+            })
+                .should.be.rejectedWith('tx outputs does not match with expected address');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ada.js","sourceRoot":"","sources":["../../../test/unit/ada.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\n\nimport should = require('should');\nimport nacl from 'tweetnacl';\nimport { randomBytes } from 'crypto';\nimport * as sinon from 'sinon';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI, encrypt } from '@bitgo-beta/sdk-api';\nimport {\n  address,\n  consolidationWrwUser,\n  endpointResponses,\n  enterpriseAccounts as accounts,\n  ovcResponse,\n  ovcResponse2,\n  privateKeys,\n  publicKeys,\n  rawTx,\n  testnetUTXO,\n  wrwUser,\n} from '../resources';\nimport * as _ from 'lodash';\nimport * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';\nimport { Ada, KeyPair, Tada } from '../../src';\nimport { Transaction } from '../../src/lib';\nimport { TransactionType } from '../../../sdk-core/src/account-lib/baseCoin/enum';\nimport assert from 'assert';\nimport { common, EDDSAMethods, Wallet } from '@bitgo-beta/sdk-core';\nimport { MPSUtil } from '@bitgo-beta/sdk-lib-mpc';\nimport nock from 'nock';\n\ndescribe('ADA', function () {\n  const coinName = 'ada';\n  const tcoinName = 't' + coinName;\n  let bitgo: TestBitGoAPI;\n  let basecoin;\n  let newTxPrebuild;\n  let newTxParams;\n\n  const txPrebuild = {\n    txHex: rawTx.unsignedTx,\n    txInfo: {},\n  };\n\n  const txParams = {\n    recipients: [\n      {\n        address: rawTx.outputAddress1.address,\n        amount: '5000000',\n      },\n      {\n        address: rawTx.outputAddress2.address,\n        amount: '248329150',\n      },\n    ],\n  };\n\n  const transactionExplanation = {\n    displayOrder: ['id', 'outputAmount', 'changeAmount', 'outputs', 'changeOutputs', 'fee', 'type'],\n    id: 'f48f6ea0f75f3f942855cc0edf29e81e1e0724e75f5db8a1575b166fb202176c',\n    outputs: [\n      {\n        address:\n          'addr_test1qqnnvptrc3rec64q2n9jh572ncu5wvdtt8uvg4g3aj96s5dwu9nj70mlahzglm9939uevupsmj8dcdqv25d5n5r8vw8sn7prey',\n        amount: '7823121',\n      },\n      {\n        address: 'addr_test1vr8rakm66rcfv4fcxqykg5lf0yv7lsyk9mvapx369jpvtcgfcuk7f',\n        amount: '13041729',\n      },\n    ],\n    outputAmount: '20864850',\n    changeOutputs: [],\n    changeAmount: '0',\n    fee: { fee: '167173' },\n    type: 'Transfer',\n    certificates: [],\n    withdrawals: [],\n    pledgeDetails: undefined,\n  };\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.initializeTestVars();\n    bitgo.safeRegister(coinName, Ada.createInstance);\n    bitgo.safeRegister(tcoinName, Tada.createInstance);\n    basecoin = bitgo.coin(tcoinName);\n    newTxPrebuild = () => {\n      return _.cloneDeep(txPrebuild);\n    };\n    newTxParams = () => {\n      return _.cloneDeep(txParams);\n    };\n  });\n\n  it('should instantiate the coin', function () {\n    let localBasecoin = bitgo.coin(tcoinName);\n    localBasecoin.should.be.an.instanceof(Tada);\n    localBasecoin.getChain().should.equal(tcoinName);\n    localBasecoin.getFullName().should.equal('Testnet Ada');\n\n    localBasecoin = bitgo.coin(coinName);\n    localBasecoin.should.be.an.instanceof(Ada);\n    localBasecoin.getChain().should.equal(coinName);\n    localBasecoin.getFullName().should.equal('Cardano ADA');\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(false);\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    it('should sign transaction', async function () {\n      const signed = await basecoin.signTransaction({\n        txPrebuild: {\n          txHex: rawTx.unsignedTx2,\n        },\n        pubs: [publicKeys.pubKey1],\n        prv: privateKeys.prvKey4,\n      });\n      signed.txHex.should.equal(rawTx.signedTx2);\n    });\n\n    it('should fail to sign transaction with an invalid key', async function () {\n      try {\n        await basecoin.signTransaction({\n          txPrebuild: {\n            txHex: rawTx.unsignedTx2,\n          },\n          pubs: [publicKeys.pubKey1],\n          prv: privateKeys.prvKey2,\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: rawTx.unsignedTx,\n            key: accounts.account1.publicKey,\n          },\n          prv: 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('Verify transaction: ', () => {\n    it('should succeed to verify unsigned transaction in hex encoding', async () => {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      const verification = {};\n\n      const isTransactionVerified = await basecoin.verifyTransaction({ txParams, txPrebuild, verification });\n      isTransactionVerified.should.equal(true);\n    });\n\n    it('should succeed to verify signed transaction in hex encoding', async () => {\n      const txPrebuild = {\n        txHex: rawTx.signedTx,\n        txInfo: {},\n      };\n\n      const txParams = newTxParams();\n      const verification = {};\n\n      const isTransactionVerified = await basecoin.verifyTransaction({ txParams, txPrebuild, verification });\n      isTransactionVerified.should.equal(true);\n    });\n\n    it('should fail verify transactions when have different recipients', async () => {\n      const txPrebuild = newTxPrebuild();\n\n      const txParams = {\n        recipients: [\n          {\n            address: '9f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f0254',\n            amount: '1000000000000000000000000',\n          },\n          {\n            address: '9f7b0675db59d19b4bd9c8c72eaabba75a9863d02b30115b8b3c3ca5c20f0254',\n            amount: '2000000000000000000000000',\n          },\n        ],\n      };\n\n      const verification = {};\n\n      await basecoin\n        .verifyTransaction({ txParams, txPrebuild, verification })\n        .should.be.rejectedWith('cannot find recipient in expected output');\n    });\n\n    it('should verify when input `recipients` is absent', async function () {\n      const txParams = newTxParams();\n      txParams.recipients = undefined;\n      const txPrebuild = newTxPrebuild();\n      const validTransaction = await basecoin.verifyTransaction({ txParams, txPrebuild });\n      validTransaction.should.equal(true);\n    });\n\n    it('should fail verify when txHex is invalid', async function () {\n      const txParams = newTxParams();\n      txParams.recipients = undefined;\n      const txPrebuild = {};\n      await basecoin\n        .verifyTransaction({ txParams, txPrebuild })\n        .should.rejectedWith('missing required tx prebuild property txHex');\n    });\n\n    it('should succeed to verify transactions when recipients has extra data', async function () {\n      const txPrebuild = newTxPrebuild();\n      const txParams = newTxParams();\n      txParams.data = 'data';\n\n      const validTransaction = await basecoin.verifyTransaction({ txParams, txPrebuild });\n      validTransaction.should.equal(true);\n    });\n\n    it('should verify a valid consolidation transaction', async () => {\n      const consolidationTx = {\n        txRequestId: '1b5c79c5-ab7c-4f47-912b-de6a95fb0779',\n        walletId: '64fa31a94db65a0007c9691b',\n        txHex:\n          '84a40081825820db46c7c76ea54fec2ca0a2f94b77a238931a8dce2387c99a12b08dd8aac21c4f000181825839004601fc016ac38580916d3520bc76b659298156008738d347aa93142f4601fc016ac38580916d3520bc76b659298156008738d347aa93142f1a3b984357021a000286a9031a060e37eea0f5f6',\n        feeInfo: {\n          fee: 165545,\n          feeString: '165545',\n        },\n        txInfo: {\n          minerFee: '165545',\n          spendAmount: '999834455',\n          spendAmounts: [\n            {\n              coinName: 'tada',\n              amountString: '999834455',\n            },\n          ],\n          payGoFee: '0',\n          outputs: [\n            {\n              address:\n                'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',\n              value: 999834455,\n              wallet: '64fa31a94db65a0007c9691b',\n              wallets: ['64fa31a94db65a0007c9691b'],\n              enterprise: '62cc59b727443a0007089033',\n              enterprises: ['62cc59b727443a0007089033'],\n              valueString: '999834455',\n              coinName: 'tada',\n              walletType: 'hot',\n              walletTypes: ['hot'],\n            },\n          ],\n          inputs: [\n            {\n              value: 1000000000,\n              address:\n                'addr_test1qqlzxfl7tlgp999x4a7334pchycpkk72pykrsr3mryl3yj6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsvpgl8w',\n              valueString: '1000000000',\n            },\n          ],\n          type: '0',\n        },\n        consolidateId: '68b9fc18558006aab53785615fea7c28',\n        coin: 'tada',\n      };\n\n      const mockedWallet = {\n        coinSpecific: () => {\n          return {\n            rootAddress:\n              'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',\n          };\n        },\n      };\n\n      try {\n        const isVerified = await basecoin.verifyTransaction({\n          txParams: {},\n          txPrebuild: consolidationTx,\n          wallet: mockedWallet,\n          verification: {\n            consolidationToBaseAddress: true,\n          },\n        });\n        isVerified.should.equal(true);\n      } catch (e) {\n        assert.fail('Transaction should pass verification');\n      }\n    });\n\n    it('should verify a valid sponsored consolidation transaction', async () => {\n      const consolidationTx = {\n        txRequestId: '1b5c79c5-ab7c-4f47-912b-de6a95fb0779',\n        walletId: '64fa31a94db65a0007c9691b',\n        txHex:\n          '84a40082825820227f65d20ac6e49602d79c623c51911ead824235e01eb2a1e7e33a72f0747cbb00825820227f65d20ac6e49602d79c623c51911ead824235e01eb2a1e7e33a72f0747cbb0201828258390022098270a5c19c9fb706dce0e7e4566b234ec5f0010623cd63f198ad22098270a5c19c9fb706dce0e7e4566b234ec5f0010623cd63f198ad1a0098968082581d60cf90f9fb02c88bad3c5294d90587458c4f160a2db26ba8af3da255b11a05d42fb8021a0002a491031a06d8c048a0f5f6',\n        feeInfo: {\n          fee: 165545,\n          feeString: '165545',\n        },\n        txInfo: {\n          minerFee: '165545',\n          spendAmount: '999834455',\n          spendAmounts: [\n            {\n              coinName: 'tada',\n              amountString: '999834455',\n            },\n          ],\n          payGoFee: '0',\n          outputs: [\n            {\n              address:\n                'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',\n              value: 999834455,\n              wallet: '64fa31a94db65a0007c9691b',\n              wallets: ['64fa31a94db65a0007c9691b'],\n              enterprise: '62cc59b727443a0007089033',\n              enterprises: ['62cc59b727443a0007089033'],\n              valueString: '999834455',\n              coinName: 'tada',\n              walletType: 'hot',\n              walletTypes: ['hot'],\n            },\n          ],\n          inputs: [\n            {\n              value: 1000000000,\n              address:\n                'addr_test1qqlzxfl7tlgp999x4a7334pchycpkk72pykrsr3mryl3yj6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsvpgl8w',\n              valueString: '1000000000',\n            },\n          ],\n          type: '0',\n          feeAddress: 'addr_test1vr8ep70mqtyghtfu222djpv8gkxy79s29kexh2908k39tvge02d5j',\n        },\n        consolidateId: '68b9fc18558006aab53785615fea7c28',\n        coin: 'tada',\n      };\n\n      const mockedWallet = {\n        coinSpecific: () => {\n          return {\n            rootAddress:\n              'addr_test1qq3qnqns5hqee8ahqmwwpely2e4jxnk97qqsvg7dv0ce3tfzpxp8pfwpnj0mwpkuurn7g4ntyd8vtuqpqc3u6cl3nzksvggu82',\n          };\n        },\n      };\n\n      try {\n        const isVerified = await basecoin.verifyTransaction({\n          txParams: {},\n          txPrebuild: consolidationTx,\n          wallet: mockedWallet,\n          verification: {\n            consolidationToBaseAddress: true,\n          },\n        });\n        isVerified.should.equal(true);\n      } catch (e) {\n        assert.fail('Transaction should pass verification');\n      }\n    });\n\n    it('should fail to sign a spoofed consolidation transaction', async function () {\n      // Set up wallet data\n      const walletData = {\n        id: '5b34252f1bf349930e34020a00000000',\n        coin: 'tada',\n        keys: [\n          '5b3424f91bf349930e34017500000000',\n          '5b3424f91bf349930e34017600000000',\n          '5b3424f91bf349930e34017700000000',\n        ],\n        coinSpecific: {\n          rootAddress:\n            'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',\n        },\n        multisigType: 'tss',\n      };\n      const fakePrv = await encrypt('password', 'prv');\n\n      const walletObj = new Wallet(bitgo, basecoin, walletData);\n      const bgUrl = common.Environments['mock'].uri;\n\n      nock(bgUrl)\n        .get('/api/v2/tada/key/5b3424f91bf349930e34017500000000')\n        .reply(200, [\n          {\n            encryptedPrv: fakePrv,\n          },\n        ]);\n\n      // Mock the API response for buildAccountConsolidations\n      nock(bgUrl)\n        .post('/api/v2/tada/wallet/5b34252f1bf349930e34020a00000000/consolidateAccount/build')\n        .reply(200, [\n          {\n            txRequestId: '1b5c79c5-ab7c-4f47-912b-de6a95fb0779',\n            walletId: '64fa31a94db65a0007c9691b',\n            txHex:\n              '84a40081825820db46c7c76ea54fec2ca0a2f94b77a238931a8dce2387c99a12b08dd8aac21c4f01018282581d6033c378cee41b2e15ac848f7f6f1d2f78155ab12d93b713de898d855f1a00989680825839004601fc016ac38580916d3520bc76b659298156008738d347aa93142f4601fc016ac38580916d3520bc76b659298156008738d347aa93142f1b0000000217acebe9021a00028db5031a060e3b41a0f5f6',\n            feeInfo: {\n              fee: 165545,\n              feeString: '165545',\n            },\n            txInfo: {\n              minerFee: '165545',\n              spendAmount: '999834455',\n              spendAmounts: [\n                {\n                  coinName: 'tada',\n                  amountString: '999834455',\n                },\n              ],\n              payGoFee: '0',\n              outputs: [\n                {\n                  address:\n                    'addr_test1qprqrlqpdtpctqy3d56jp0rkkevjnq2kqzrn356842f3gt6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsjdmg2s',\n                  value: 999834455,\n                  wallet: '64fa31a94db65a0007c9691b',\n                  wallets: ['64fa31a94db65a0007c9691b'],\n                  enterprise: '62cc59b727443a0007089033',\n                  enterprises: ['62cc59b727443a0007089033'],\n                  valueString: '999834455',\n                  coinName: 'tada',\n                  walletType: 'hot',\n                  walletTypes: ['hot'],\n                },\n              ],\n              inputs: [\n                {\n                  value: 1000000000,\n                  address:\n                    'addr_test1qqlzxfl7tlgp999x4a7334pchycpkk72pykrsr3mryl3yj6xq87qz6krskqfzmf4yz78ddje9xq4vqy88rf5025nzshsvpgl8w',\n                  valueString: '1000000000',\n                },\n              ],\n              type: '0',\n            },\n            consolidateId: '68b9fc18558006aab53785615fea7c28',\n            coin: 'tada',\n          },\n        ]);\n\n      // Call the function to test\n      await assert.rejects(\n        async () => {\n          await walletObj.sendAccountConsolidations({\n            walletPassphrase: 'password',\n          });\n        },\n        {\n          message: 'tx outputs does not match with expected address',\n        }\n      );\n    });\n  });\n\n  describe('Explain Transactions:', () => {\n    it('should explain an unsigned transfer transaction', async function () {\n      const explainedTransaction = await basecoin.explainTransaction({\n        txPrebuild: {\n          txHex: rawTx.unsignedTx2,\n        },\n      });\n      console.log(explainedTransaction);\n      explainedTransaction.should.deepEqual(transactionExplanation);\n    });\n\n    it('should fail to explain transaction with missing params', async function () {\n      try {\n        await basecoin.explainTransaction({\n          txPrebuild: {},\n        });\n      } catch (error) {\n        should.equal(error.message, 'Invalid transaction');\n      }\n    });\n\n    it('should fail to explain transaction with wrong params', async function () {\n      try {\n        await basecoin.explainTransaction({\n          txPrebuild: {\n            txHex: 'invalidTxHex',\n          },\n        });\n      } catch (error) {\n        should.equal(error.message, 'Invalid transaction');\n      }\n    });\n  });\n\n  describe('Parse Raw Transactions', () => {\n    it('should parse staking pledge transaction', function () {\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(rawTx.unsignedNewPledgeTx);\n      should.equal(tx.type, TransactionType.StakingPledge);\n    });\n\n    it('should parse staking activation tx', function () {\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(rawTx.unsignedStakingActiveTx);\n      should.equal(tx.type, TransactionType.StakingActivate);\n    });\n\n    it('should parse staking deactivation tx', function () {\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(rawTx.unsignedStakingDeactiveTx);\n      should.equal(tx.type, TransactionType.StakingDeactivate);\n    });\n  });\n\n  describe('Parse Transactions:', () => {\n    it('should parse an unsigned transfer transaction', async function () {\n      const parsedTransaction = await basecoin.parseTransaction({\n        txPrebuild: {\n          txHex: rawTx.unsignedTx2,\n        },\n      });\n\n      parsedTransaction.should.deepEqual(transactionExplanation);\n    });\n\n    it('should parse a signed transfer transaction', async function () {\n      const parsedTransaction = await basecoin.parseTransaction({\n        txPrebuild: {\n          txHex: rawTx.signedTx2,\n        },\n      });\n\n      parsedTransaction.should.deepEqual(transactionExplanation);\n    });\n\n    it('should fail parse a signed transfer transaction when explainTransaction response is undefined', async function () {\n      const stub = sinon.stub(Ada.prototype, 'explainTransaction');\n      stub.resolves(undefined);\n      await basecoin\n        .parseTransaction({\n          txPrebuild: {\n            txHex: rawTx.signedTx,\n          },\n        })\n        .should.be.rejectedWith('Invalid transaction');\n      stub.restore();\n    });\n  });\n\n  describe('Recover Transactions:', () => {\n    const destAddr = address.address2;\n    const sandBox = sinon.createSandbox();\n    let callBack: sinon.SinonStub;\n\n    beforeEach(function () {\n      callBack = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack\n        .withArgs('address_info', {\n          _addresses: [wrwUser.walletAddress0],\n        })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO);\n      callBack.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should take OVC output and generate a signed sweep transaction', async function () {\n      const params = ovcResponse;\n      const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);\n      recoveryTxn.transactions[0].serializedTx.should.equal(\n        '84a400818258204bd0f991c1532cffe31d4a10db492b43175ec326765b6b29ceee598df2b61f470001818258390087379ebc5533ebe621963c915c3cbc5f08537fcdca4af8f8ae08ed4c87379ebc5533ebe621963c915c3cbc5f08537fcdca4af8f8ae08ed4c1a05f359ff021a00028701031a024972e1a10081825820bbacb13431b99208e6e8cdbf710147feaf06a39d71565e60b411ce9e4fa3f137584001a4ab8236563f69ff309e5786e8f39c629ed57676c692159cb2e0494c9e663355384c13c749d04c17a80ba2a45cc127df480fc64a43199a772f11acd5b14a0ff5f6'\n      );\n      recoveryTxn.transactions[0].scanIndex.should.equal(0);\n      recoveryTxn.lastScanIndex.should.equal(0);\n    });\n\n    it('should take consolidation OVC output and generate multiple signed sweep transactions', async function () {\n      const params = ovcResponse2;\n      const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);\n      recoveryTxn.transactions[0].serializedTx.should.equal(\n        '84a400818258203e62e5ee8b12012c4b949f9777b72165239bb2146ae8b078b4d1c5ca8d3168e300018182583900baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd08004baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd080041a00960f7f021a00028701031a0250f7eaa10081825820500e0d725a5ba3a306da3503dfe57b8a14068a09b61b36ec068fcf8cf5c391de5840c836ce6d3262d5654706ea06721522d3b75f6d545245047a7be7463629d88b3f4264b995f591df52bdffcf09da1e6ab9e88de3714c6e2ec1961786cf1c586a07f5f6'\n      );\n      recoveryTxn.transactions[0].scanIndex.should.equal(1);\n      recoveryTxn.transactions[1].serializedTx.should.equal(\n        '84a4008182582029c10acf0e08f9523325c88243565af6b32274992189c1153903c410bed7c2c700018182583900baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd08004baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd080041a00960f7f021a00028701031a0250f7eaa1008182582062770b224bd314bc526fbd6a94e9082fb6458c425e6e09bad74004dd897e962358403842544f2ff28be054eb7c7997bc303b1e251eb13a41802c82318e592bb24eaa3197c450e797cc8559f0356cd5cdd1ab5eb80c5173e34e9e1d1737533a89520cf5f6'\n      );\n      recoveryTxn.transactions[1].scanIndex.should.equal(2);\n      recoveryTxn.transactions[2].serializedTx.should.equal(\n        '84a40081825820dd140f133d865e1bb5642e708fe685bf7601d71d0c99511e5d552da7f8bd10ff00018182583900baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd08004baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd080041a00960f7f021a00028701031a0250f7eaa1008182582053b4bb74aa38add458dafc8153f0aa8266acad59322b877ca9c23c5d3873779d5840e94ce7896957d094c6bafbf2ec10df5ebb0f1d2a27a7e31f2d45c531fb687edd6c4d33f8e9b99c7692b6fac6d8399bd8fd47641baae9bbb69f518d42ad11710af5f6'\n      );\n      recoveryTxn.transactions[2].scanIndex.should.equal(3);\n      recoveryTxn.transactions[3].serializedTx.should.equal(\n        '84a4008182582015a1d6db5d3f592aa1cda185b6359ca0e2921c3c51959f64222a6b7d95d3392300018182583900baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd08004baf55ebcf9ada1b8ecb1640880fba54d2817690f12b3a106afd080041a00960f7f021a00028701031a0250f7eaa10081825820600f86ca22d670f0a990ade4e882c05e654343263494735a31517de0819676735840fe199f8e247a4cfabfeb4f9cb574aa35739a0aa98860ee0a85d720c4ab4fecfac7b4504df310b3e4bea04711f60652d4a8cf5eb41817293b8d29977fe695f704f5f6'\n      );\n      recoveryTxn.transactions[3].scanIndex.should.equal(4);\n      recoveryTxn.lastScanIndex.should.equal(20);\n    });\n\n    it('should recover a txn for non-bitgo recoveries', async function () {\n      const res = await basecoin.recover({\n        userKey: wrwUser.userKey,\n        backupKey: wrwUser.backupKey,\n        bitgoKey: wrwUser.bitgoKey,\n        walletPassphrase: wrwUser.walletPassphrase,\n        recoveryDestination: destAddr,\n      });\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n      sandBox.assert.calledTwice(basecoin.getDataFromNode);\n\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(res.serializedTx);\n      const txJson = tx.toJson();\n      const fee = Number(tx.explainTransaction().fee.fee);\n      should.deepEqual(txJson.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);\n      should.deepEqual(txJson.inputs[0].transaction_index, testnetUTXO.UTXO_1.tx_index);\n      should.deepEqual(txJson.outputs[0].address, destAddr);\n      should.deepEqual(Number(txJson.outputs[0].amount) + fee, testnetUTXO.UTXO_1.value);\n    });\n\n    it('should recover a txn for unsigned sweep recoveries', async function () {\n      const res = await basecoin.recover({\n        bitgoKey: wrwUser.bitgoKey,\n        recoveryDestination: destAddr,\n      });\n      res.should.not.be.empty();\n      res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');\n      sandBox.assert.calledTwice(basecoin.getDataFromNode);\n\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(res.txRequests[0].transactions[0].unsignedTx.serializedTx);\n      const txJson = tx.toJson();\n      const fee = Number(tx.explainTransaction().fee.fee);\n      should.deepEqual(txJson.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);\n      should.deepEqual(txJson.inputs[0].transaction_index, testnetUTXO.UTXO_1.tx_index);\n      should.deepEqual(txJson.outputs[0].address, destAddr);\n      should.deepEqual(Number(txJson.outputs[0].amount) + fee, testnetUTXO.UTXO_1.value);\n    });\n\n    it('should recover ADA plus token UTXOs - token and ADA both appear in outputs (unsigned sweep)', async function () {\n      callBack\n        .withArgs('address_info', { _addresses: [wrwUser.walletAddress0] })\n        .resolves(endpointResponses.addressInfoResponse.ADAAndTokenUTXOs);\n\n      const res = await basecoin.recover({\n        bitgoKey: wrwUser.bitgoKey,\n        recoveryDestination: destAddr,\n      });\n      res.should.not.be.empty();\n      const unsignedTx = res.txRequests[0].transactions[0].unsignedTx;\n      unsignedTx.should.hasOwnProperty('serializedTx');\n\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(unsignedTx.serializedTx);\n      const txJson = tx.toJson();\n\n      txJson.inputs.length.should.equal(2);\n      should.deepEqual(txJson.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);\n      should.deepEqual(txJson.inputs[1].transaction_id, testnetUTXO.UTXO_TOKEN.tx_hash);\n\n      txJson.outputs.length.should.equal(2);\n\n      const tokenPolicyId = '2533cca6eb42076e144e9f2772c390dece9fce173bc38c72294b3924';\n      const tokenEncodedAssetName = '5741544552';\n      const tokenQuantity = '111';\n      const minADAForToken = 1500000;\n\n      const tokenOutput = txJson.outputs.find((o) => o.multiAssets !== undefined);\n      should.exist(tokenOutput);\n      should.deepEqual(tokenOutput!.address, destAddr);\n      should.deepEqual(Number(tokenOutput!.amount), minADAForToken);\n      const expectedPolicyId = CardanoWasm.ScriptHash.from_bytes(Buffer.from(tokenPolicyId, 'hex'));\n      const expectedAssetName = CardanoWasm.AssetName.new(Buffer.from(tokenEncodedAssetName, 'hex'));\n      (tokenOutput!.multiAssets as CardanoWasm.MultiAsset)\n        .get_asset(expectedPolicyId, expectedAssetName)\n        .to_str()\n        .should.equal(tokenQuantity);\n\n      const adaOutput = txJson.outputs.find((o) => o.multiAssets === undefined);\n      should.exist(adaOutput);\n      should.deepEqual(adaOutput!.address, destAddr);\n      const fee = Number(tx.explainTransaction().fee.fee);\n      const totalBalance = testnetUTXO.UTXO_1.value + testnetUTXO.UTXO_TOKEN.value;\n      should.deepEqual(Number(adaOutput!.amount), totalBalance - minADAForToken - fee);\n\n      const explained = tx.explainTransaction();\n      const explainedTokenOutput = explained.outputs.find((o) => o.amount === minADAForToken.toString());\n      should.exist(explainedTokenOutput);\n\n      // inputs and outputs in parsedTx should carry multiAssets\n      const parsedTxInputs = res.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs as {\n        address: string;\n        valueString: string;\n        multiAssets?: { policy_id: string; asset_name: string; quantity: string }[];\n      }[];\n      parsedTxInputs.length.should.equal(1);\n      should.exist(parsedTxInputs[0].multiAssets);\n      parsedTxInputs[0].multiAssets!.length.should.equal(1);\n      should.deepEqual(parsedTxInputs[0].multiAssets![0].policy_id, tokenPolicyId);\n      should.deepEqual(parsedTxInputs[0].multiAssets![0].asset_name, tokenEncodedAssetName);\n      should.deepEqual(parsedTxInputs[0].multiAssets![0].quantity, tokenQuantity);\n\n      const parsedTxOutputs = res.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs as {\n        address: string;\n        valueString: string;\n        multiAssets?: { policy_id: string; asset_name: string; quantity: string }[];\n      }[];\n      const parsedTokenOutput = parsedTxOutputs.find((o) => o.multiAssets !== undefined);\n      should.exist(parsedTokenOutput);\n      parsedTokenOutput!.multiAssets!.length.should.equal(1);\n      should.deepEqual(parsedTokenOutput!.multiAssets![0].policy_id, tokenPolicyId);\n      should.deepEqual(parsedTokenOutput!.multiAssets![0].asset_name, tokenEncodedAssetName);\n      should.deepEqual(parsedTokenOutput!.multiAssets![0].quantity, tokenQuantity);\n      // pure ADA output should not have multiAssets\n      const parsedAdaOutput = parsedTxOutputs.find((o) => o.multiAssets === undefined);\n      should.exist(parsedAdaOutput);\n    });\n\n    it('should recover ADA plus token UTXOs - token and ADA both appear in outputs (signed)', async function () {\n      callBack\n        .withArgs('address_info', { _addresses: [wrwUser.walletAddress0] })\n        .resolves(endpointResponses.addressInfoResponse.ADAAndTokenUTXOs);\n\n      const res = await basecoin.recover({\n        userKey: wrwUser.userKey,\n        backupKey: wrwUser.backupKey,\n        bitgoKey: wrwUser.bitgoKey,\n        walletPassphrase: wrwUser.walletPassphrase,\n        recoveryDestination: destAddr,\n      });\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(res.serializedTx);\n      const txJson = tx.toJson();\n\n      txJson.inputs.length.should.equal(2);\n      should.deepEqual(txJson.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);\n      should.deepEqual(txJson.inputs[1].transaction_id, testnetUTXO.UTXO_TOKEN.tx_hash);\n\n      // expect 2 outputs: one token output + one ADA change output, both at destAddr\n      txJson.outputs.length.should.equal(2);\n\n      const tokenPolicyId = '2533cca6eb42076e144e9f2772c390dece9fce173bc38c72294b3924';\n      const tokenEncodedAssetName = '5741544552';\n      const tokenQuantity = '111';\n      const minADAForToken = 1500000;\n\n      const tokenOutput = txJson.outputs.find((o) => o.multiAssets !== undefined);\n      should.exist(tokenOutput);\n      should.deepEqual(tokenOutput!.address, destAddr);\n      should.deepEqual(Number(tokenOutput!.amount), minADAForToken);\n      const expectedPolicyId = CardanoWasm.ScriptHash.from_bytes(Buffer.from(tokenPolicyId, 'hex'));\n      const expectedAssetName = CardanoWasm.AssetName.new(Buffer.from(tokenEncodedAssetName, 'hex'));\n      (tokenOutput!.multiAssets as CardanoWasm.MultiAsset)\n        .get_asset(expectedPolicyId, expectedAssetName)\n        .to_str()\n        .should.equal(tokenQuantity);\n\n      const adaOutput = txJson.outputs.find((o) => o.multiAssets === undefined);\n      should.exist(adaOutput);\n      should.deepEqual(adaOutput!.address, destAddr);\n      const fee = Number(tx.explainTransaction().fee.fee);\n      const totalBalance = testnetUTXO.UTXO_1.value + testnetUTXO.UTXO_TOKEN.value;\n      should.deepEqual(Number(adaOutput!.amount), totalBalance - minADAForToken - fee);\n    });\n  });\n\n  describe('Recover Transactions (MPCv2):', () => {\n    const destAddr = address.address2;\n    const sandBox = sinon.createSandbox();\n    const walletPassphrase = 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      mismatchedBitgoKey = otherUserDkg.getCommonKeychain();\n\n      mpcV2WalletAddress = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 0 }))\n        .address;\n      mismatchedWalletAddress = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mismatchedBitgoKey, index: 0 }))\n        .address;\n    });\n\n    let callBack: sinon.SinonStub;\n\n    beforeEach(function () {\n      callBack = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack\n        .withArgs('address_info', { _addresses: [mpcV2WalletAddress] })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO);\n      callBack\n        .withArgs('address_info', { _addresses: [mismatchedWalletAddress] })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO);\n      callBack.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should route to MPCv2 path for native ADA 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      });\n\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n      sandBox.assert.notCalled(getTSSSignatureSpy);\n\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(res.serializedTx);\n      const txJson = tx.toJson();\n      should.deepEqual(txJson.outputs[0].address, destAddr);\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 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      });\n\n      res.should.not.be.empty();\n      sandBox.assert.calledOnce(getEddsaMaterialSpy);\n    });\n\n    it('should ignore a malformed precomputedMaterial and detect signing material itself (regression: WRW openSSLBytes collision)', async function () {\n      // WRW's generic Electron 'recover' IPC handler passes openSSLBytes (an ArrayBuffer)\n      // as a second positional argument to every coin's recover(), regardless of whether\n      // that coin uses it. Previously this was blindly trusted as precomputedMaterial,\n      // producing `JSON.parse(undefined)` -> SyntaxError: \"undefined\" is not valid JSON.\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) as any\n      );\n\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n      sandBox.assert.calledOnce(getEddsaMaterialSpy);\n    });\n\n    it('should route to MPCv1 path when keycard is MPCv1 (regression)', async function () {\n      callBack\n        .withArgs('address_info', { _addresses: [wrwUser.walletAddress0] })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO);\n\n      const getTSSSignatureSpy = sandBox.spy(EDDSAMethods, 'getTSSSignature');\n\n      const res = await basecoin.recover({\n        userKey: wrwUser.userKey,\n        backupKey: wrwUser.backupKey,\n        bitgoKey: wrwUser.bitgoKey,\n        walletPassphrase: wrwUser.walletPassphrase,\n        recoveryDestination: destAddr,\n      });\n\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n      sandBox.assert.calledOnce(getTSSSignatureSpy);\n    });\n\n    it('should produce a cryptographically valid Ed25519 signature', async function () {\n      const signRecoverySpy = sandBox.spy(\n        basecoin as unknown as { signAdaMpcV2Recovery: unknown },\n        'signAdaMpcV2Recovery'\n      );\n\n      await basecoin.recover({\n        userKey: mpcV2UserKey,\n        backupKey: mpcV2BackupKey,\n        bitgoKey: mpcV2CommonKeyChain,\n        walletPassphrase,\n        recoveryDestination: destAddr,\n      });\n\n      const rawSig: Buffer = await (signRecoverySpy.firstCall.returnValue as Promise<Buffer>);\n      const signablePayload: Buffer = (signRecoverySpy.firstCall.args[0] as { message: Buffer }).message;\n\n      const MPC = await EDDSAMethods.getInitializedMpcInstance();\n      const accountId = MPC.deriveUnhardened(mpcV2CommonKeyChain, 'm/0').slice(0, 64);\n\n      const isValid = nacl.sign.detached.verify(\n        new Uint8Array(signablePayload),\n        new Uint8Array(rawSig),\n        new Uint8Array(Buffer.from(accountId, 'hex'))\n      );\n      isValid.should.be.true();\n    });\n\n    it('should throw missing userKey when backupKey and walletPassphrase are present but userKey is not', async function () {\n      callBack.resolves(endpointResponses.addressInfoResponse.OneUTXO);\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      callBack.resolves(endpointResponses.addressInfoResponse.OneUTXO);\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 a clear error when the MPCv1 backup keycard fails to decrypt', async function () {\n      callBack\n        .withArgs('address_info', { _addresses: [wrwUser.walletAddress0] })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO);\n\n      await basecoin\n        .recover({\n          userKey: wrwUser.userKey,\n          backupKey: 'not-a-valid-encrypted-keycard',\n          bitgoKey: wrwUser.bitgoKey,\n          walletPassphrase: wrwUser.walletPassphrase,\n          recoveryDestination: destAddr,\n        })\n        .should.be.rejectedWith('Error decrypting backup keychain: invalid password or corrupted key');\n    });\n  });\n\n  describe('Recover Transactions Multiple UTXO:', () => {\n    const destAddr = address.address2;\n    const sandBox = sinon.createSandbox();\n\n    beforeEach(function () {\n      const callBack = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack\n        .withArgs('address_info', {\n          _addresses: [wrwUser.walletAddress0],\n        })\n        .resolves(endpointResponses.addressInfoResponse.TwoUTXO);\n      callBack.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should recover a txn for non-bitgo recoveries', async function () {\n      const res = await basecoin.recover({\n        userKey: wrwUser.userKey,\n        backupKey: wrwUser.backupKey,\n        bitgoKey: wrwUser.bitgoKey,\n        walletPassphrase: wrwUser.walletPassphrase,\n        recoveryDestination: destAddr,\n      });\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n      sandBox.assert.calledTwice(basecoin.getDataFromNode);\n\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(res.serializedTx);\n      const txJson = tx.toJson();\n      const fee = Number(tx.explainTransaction().fee.fee);\n      should.deepEqual(txJson.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);\n      should.deepEqual(txJson.inputs[0].transaction_index, testnetUTXO.UTXO_1.tx_index);\n      should.deepEqual(txJson.inputs[1].transaction_id, testnetUTXO.UTXO_2.tx_hash);\n      should.deepEqual(txJson.inputs[1].transaction_index, testnetUTXO.UTXO_2.tx_index);\n      should.deepEqual(txJson.outputs[0].address, destAddr);\n      should.deepEqual(Number(txJson.outputs[0].amount) + fee, testnetUTXO.UTXO_1.value + testnetUTXO.UTXO_2.value);\n    });\n\n    it('should recover a txn for unsigned sweep recoveries', async function () {\n      const res = await basecoin.recover({\n        bitgoKey: wrwUser.bitgoKey,\n        recoveryDestination: destAddr,\n      });\n      res.should.not.be.empty();\n      res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');\n      sandBox.assert.calledTwice(basecoin.getDataFromNode);\n\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(res.txRequests[0].transactions[0].unsignedTx.serializedTx);\n      const txJson = tx.toJson();\n      const fee = Number(tx.explainTransaction().fee.fee);\n      should.deepEqual(txJson.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);\n      should.deepEqual(txJson.inputs[0].transaction_index, testnetUTXO.UTXO_1.tx_index);\n      should.deepEqual(txJson.inputs[1].transaction_id, testnetUTXO.UTXO_2.tx_hash);\n      should.deepEqual(txJson.inputs[1].transaction_index, testnetUTXO.UTXO_2.tx_index);\n      should.deepEqual(txJson.outputs[0].address, destAddr);\n      should.deepEqual(Number(txJson.outputs[0].amount) + fee, testnetUTXO.UTXO_1.value + testnetUTXO.UTXO_2.value);\n    });\n  });\n\n  describe('Build Consolidation Recoveries:', () => {\n    const baseAddr = consolidationWrwUser.walletAddress0;\n    const sandBox = sinon.createSandbox();\n\n    beforeEach(function () {\n      const callBack = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack\n        .withArgs('address_info', {\n          _addresses: [consolidationWrwUser.walletAddress1],\n        })\n        .resolves(endpointResponses.addressInfoResponse.ZeroUTXO);\n      callBack\n        .withArgs('address_info', {\n          _addresses: [consolidationWrwUser.walletAddress2],\n        })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO);\n      callBack\n        .withArgs('address_info', {\n          _addresses: [consolidationWrwUser.walletAddress3],\n        })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO2);\n      callBack.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should build signed consolidation recoveries', async function () {\n      const res = await basecoin.recoverConsolidations({\n        userKey: consolidationWrwUser.userKey,\n        backupKey: consolidationWrwUser.backupKey,\n        bitgoKey: consolidationWrwUser.bitgoKey,\n        walletPassphrase: consolidationWrwUser.walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n      res.should.not.be.empty();\n      res.transactions.length.should.equal(2);\n      res.lastScanIndex.should.equal(3);\n      const txn1 = res.transactions[0];\n      const tx1 = new Transaction(basecoin);\n      tx1.fromRawTransaction(txn1.serializedTx);\n      const txJson1 = tx1.toJson();\n      const fee1 = Number(tx1.explainTransaction().fee.fee);\n      should.deepEqual(txJson1.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);\n      should.deepEqual(txJson1.inputs[0].transaction_index, testnetUTXO.UTXO_1.tx_index);\n      should.deepEqual(txJson1.outputs[0].address, baseAddr);\n      should.deepEqual(Number(txJson1.outputs[0].amount) + fee1, testnetUTXO.UTXO_1.value);\n\n      const txn2 = res.transactions[1];\n      const tx2 = new Transaction(basecoin);\n      tx2.fromRawTransaction(txn2.serializedTx);\n      const txJson2 = tx2.toJson();\n      const fee2 = Number(tx2.explainTransaction().fee.fee);\n      should.deepEqual(txJson2.inputs[0].transaction_id, testnetUTXO.UTXO_2.tx_hash);\n      should.deepEqual(txJson2.inputs[0].transaction_index, testnetUTXO.UTXO_2.tx_index);\n      should.deepEqual(txJson2.outputs[0].address, baseAddr);\n      should.deepEqual(Number(txJson2.outputs[0].amount) + fee2, testnetUTXO.UTXO_2.value);\n    });\n\n    it('should skip building consolidate transaction if balance is equal to zero', async function () {\n      await basecoin\n        .recoverConsolidations({\n          userKey: consolidationWrwUser.userKey,\n          backupKey: consolidationWrwUser.backupKey,\n          bitgoKey: consolidationWrwUser.bitgoKey,\n          walletPassphrase: 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: consolidationWrwUser.userKey,\n          backupKey: consolidationWrwUser.backupKey,\n          bitgoKey: 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: consolidationWrwUser.userKey,\n          backupKey: consolidationWrwUser.backupKey,\n          bitgoKey: 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    it('should build unsigned consolidation recoveries', async function () {\n      const res = await basecoin.recoverConsolidations({\n        userKey: consolidationWrwUser.userKey,\n        backupKey: consolidationWrwUser.backupKey,\n        bitgoKey: consolidationWrwUser.bitgoKey,\n        walletPassphrase: consolidationWrwUser.walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n      res.should.not.be.empty();\n      res.transactions.length.should.equal(2);\n    });\n\n    it('should build unsigned consolidation recoveries for WRW (ADA only) and assert build response', async function () {\n      const res = await basecoin.recoverConsolidations({\n        bitgoKey: consolidationWrwUser.bitgoKey,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n      res.should.not.be.empty();\n      res.txRequests.length.should.equal(2);\n\n      // Assert first consolidation txRequest structure\n      const txRequest1 = res.txRequests[0];\n      txRequest1.transactions.length.should.equal(1);\n      const unsignedTx1 = txRequest1.transactions[0].unsignedTx;\n      unsignedTx1.should.hasOwnProperty('serializedTx');\n      unsignedTx1.should.hasOwnProperty('parsedTx');\n      unsignedTx1.should.hasOwnProperty('coinSpecific');\n\n      // Deserialize and verify inputs/outputs\n      const tx1 = new Transaction(basecoin);\n      tx1.fromRawTransaction(unsignedTx1.serializedTx);\n      const txJson1 = tx1.toJson();\n      const fee1 = Number(tx1.explainTransaction().fee.fee);\n      should.deepEqual(txJson1.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);\n      should.deepEqual(txJson1.inputs[0].transaction_index, testnetUTXO.UTXO_1.tx_index);\n      should.deepEqual(txJson1.outputs[0].address, baseAddr);\n      should.deepEqual(Number(txJson1.outputs[0].amount) + fee1, testnetUTXO.UTXO_1.value);\n\n      // parsedTx inputs/outputs must be present and carry correct address\n      const parsedTx1Inputs = unsignedTx1.parsedTx.inputs;\n      parsedTx1Inputs.length.should.equal(1);\n      should.deepEqual(parsedTx1Inputs[0].address, consolidationWrwUser.walletAddress2);\n      const parsedTx1Outputs = unsignedTx1.parsedTx.outputs;\n      parsedTx1Outputs.length.should.be.greaterThan(0);\n      should.deepEqual(parsedTx1Outputs[0].address, baseAddr);\n\n      // Assert second consolidation txRequest structure\n      const txRequest2 = res.txRequests[1];\n      const unsignedTx2 = txRequest2.transactions[0].unsignedTx;\n      unsignedTx2.should.hasOwnProperty('serializedTx');\n\n      const tx2 = new Transaction(basecoin);\n      tx2.fromRawTransaction(unsignedTx2.serializedTx);\n      const txJson2 = tx2.toJson();\n      const fee2 = Number(tx2.explainTransaction().fee.fee);\n      should.deepEqual(txJson2.inputs[0].transaction_id, testnetUTXO.UTXO_2.tx_hash);\n      should.deepEqual(txJson2.inputs[0].transaction_index, testnetUTXO.UTXO_2.tx_index);\n      should.deepEqual(txJson2.outputs[0].address, baseAddr);\n      should.deepEqual(Number(txJson2.outputs[0].amount) + fee2, testnetUTXO.UTXO_2.value);\n\n      // lastScanIndex must be set in coinSpecific of the last txRequest\n      const lastCoinSpecific = unsignedTx2.coinSpecific;\n      lastCoinSpecific.should.hasOwnProperty('lastScanIndex');\n      lastCoinSpecific.lastScanIndex.should.equal(3);\n    });\n\n    it('should build unsigned consolidation recoveries for WRW (ADA + Token) and assert build response', async function () {\n      // Override walletAddress2 to return ADA+Token UTXOs\n      sandBox.restore();\n      const callBack2 = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack2\n        .withArgs('address_info', { _addresses: [consolidationWrwUser.walletAddress1] })\n        .resolves(endpointResponses.addressInfoResponse.ZeroUTXO);\n      callBack2\n        .withArgs('address_info', { _addresses: [consolidationWrwUser.walletAddress2] })\n        .resolves(endpointResponses.addressInfoResponse.ADAAndTokenUTXOs);\n      callBack2\n        .withArgs('address_info', { _addresses: [consolidationWrwUser.walletAddress3] })\n        .resolves(endpointResponses.addressInfoResponse.ZeroUTXO);\n      callBack2.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\n\n      const tokenPolicyId = '2533cca6eb42076e144e9f2772c390dece9fce173bc38c72294b3924';\n      const tokenEncodedAssetName = '5741544552';\n      const tokenQuantity = '111';\n      const minADAForToken = 1500000;\n\n      const res = await basecoin.recoverConsolidations({\n        bitgoKey: consolidationWrwUser.bitgoKey,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n      res.should.not.be.empty();\n      res.txRequests.length.should.equal(1);\n\n      const unsignedTx = res.txRequests[0].transactions[0].unsignedTx;\n      unsignedTx.should.hasOwnProperty('serializedTx');\n\n      const tx = new Transaction(basecoin);\n      tx.fromRawTransaction(unsignedTx.serializedTx);\n      const txJson = tx.toJson();\n\n      // Two inputs: ADA UTXO + Token UTXO\n      txJson.inputs.length.should.equal(2);\n      should.deepEqual(txJson.inputs[0].transaction_id, testnetUTXO.UTXO_1.tx_hash);\n      should.deepEqual(txJson.inputs[1].transaction_id, testnetUTXO.UTXO_TOKEN.tx_hash);\n\n      // Two outputs: token output (with multiAssets) + pure ADA change to base address\n      txJson.outputs.length.should.equal(2);\n      const tokenOutput = txJson.outputs.find((o) => o.multiAssets !== undefined);\n      should.exist(tokenOutput);\n      should.deepEqual(tokenOutput!.address, baseAddr);\n      should.deepEqual(Number(tokenOutput!.amount), minADAForToken);\n      const expectedPolicyId = CardanoWasm.ScriptHash.from_bytes(Buffer.from(tokenPolicyId, 'hex'));\n      const expectedAssetName = CardanoWasm.AssetName.new(Buffer.from(tokenEncodedAssetName, 'hex'));\n      (tokenOutput!.multiAssets as CardanoWasm.MultiAsset)\n        .get_asset(expectedPolicyId, expectedAssetName)\n        .to_str()\n        .should.equal(tokenQuantity);\n\n      const adaOutput = txJson.outputs.find((o) => o.multiAssets === undefined);\n      should.exist(adaOutput);\n      should.deepEqual(adaOutput!.address, baseAddr);\n      const fee = Number(tx.explainTransaction().fee.fee);\n      const totalBalance = testnetUTXO.UTXO_1.value + testnetUTXO.UTXO_TOKEN.value;\n      should.deepEqual(Number(adaOutput!.amount), totalBalance - minADAForToken - fee);\n\n      // parsedTx inputs must carry multiAssets for the token UTXO\n      const parsedTxInputs = unsignedTx.parsedTx.inputs as {\n        address: string;\n        valueString: string;\n        multiAssets?: { policy_id: string; asset_name: string; quantity: string }[];\n      }[];\n      parsedTxInputs.length.should.equal(1);\n      should.deepEqual(parsedTxInputs[0].address, consolidationWrwUser.walletAddress2);\n      should.exist(parsedTxInputs[0].multiAssets);\n      parsedTxInputs[0].multiAssets!.length.should.equal(1);\n      should.deepEqual(parsedTxInputs[0].multiAssets![0].policy_id, tokenPolicyId);\n      should.deepEqual(parsedTxInputs[0].multiAssets![0].asset_name, tokenEncodedAssetName);\n      should.deepEqual(parsedTxInputs[0].multiAssets![0].quantity, tokenQuantity);\n\n      // parsedTx outputs must carry multiAssets for the token output\n      const parsedTxOutputs = unsignedTx.parsedTx.outputs as {\n        address: string;\n        valueString: string;\n        multiAssets?: { policy_id: string; asset_name: string; quantity: string }[];\n      }[];\n      const parsedTokenOutput = parsedTxOutputs.find((o) => o.multiAssets !== undefined);\n      should.exist(parsedTokenOutput);\n      parsedTokenOutput!.multiAssets!.length.should.equal(1);\n      should.deepEqual(parsedTokenOutput!.multiAssets![0].policy_id, tokenPolicyId);\n      should.deepEqual(parsedTokenOutput!.multiAssets![0].asset_name, tokenEncodedAssetName);\n      should.deepEqual(parsedTokenOutput!.multiAssets![0].quantity, tokenQuantity);\n      // pure ADA output must not have multiAssets\n      const parsedAdaOutput = parsedTxOutputs.find((o) => o.multiAssets === undefined);\n      should.exist(parsedAdaOutput);\n\n      // lastScanIndex in coinSpecific of the last txRequest\n      unsignedTx.coinSpecific.should.hasOwnProperty('lastScanIndex');\n      unsignedTx.coinSpecific.lastScanIndex.should.equal(3);\n    });\n\n    it('should throw error if all addresses have balance less than 1 ADA', async function () {\n      sandBox.restore();\n      const callBack = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack.withArgs('address_info', sinon.match.has('_addresses')).resolves({\n        status: 200,\n        body: [\n          {\n            balance: 500000,\n            utxo_set: [\n              {\n                tx_hash: '8df8d41207980f9e21de698bd5d6c395c39e420f7de27f8539052dd34e3a28d6',\n                tx_index: 0,\n                value: 500000,\n              },\n            ],\n          },\n        ],\n      });\n      callBack.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\n\n      await basecoin\n        .recoverConsolidations({\n          userKey: consolidationWrwUser.userKey,\n          backupKey: consolidationWrwUser.backupKey,\n          bitgoKey: consolidationWrwUser.bitgoKey,\n          walletPassphrase: consolidationWrwUser.walletPassphrase,\n          startingScanIndex: 1,\n          endingScanIndex: 4,\n        })\n        .should.be.rejectedWith('Did not find an address with funds to recover.');\n    });\n\n    it('should build even if single address has no funds', async function () {\n      const res = await basecoin.recoverConsolidations({\n        userKey: consolidationWrwUser.userKey,\n        backupKey: consolidationWrwUser.backupKey,\n        bitgoKey: consolidationWrwUser.bitgoKey,\n        walletPassphrase: consolidationWrwUser.walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n      res.should.not.be.empty();\n      res.transactions.length.should.equal(2);\n    });\n\n    it('should build even if single address has insufficient funds', async function () {\n      const res = await basecoin.recoverConsolidations({\n        userKey: consolidationWrwUser.userKey,\n        backupKey: consolidationWrwUser.backupKey,\n        bitgoKey: consolidationWrwUser.bitgoKey,\n        walletPassphrase: consolidationWrwUser.walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n      res.should.not.be.empty();\n      res.transactions.length.should.equal(2);\n    });\n  });\n\n  describe('Build Consolidation Recoveries (MPCv2):', () => {\n    const sandBox = sinon.createSandbox();\n    const walletPassphrase = 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\n      baseAddr = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 0 })).address;\n      mpcV2Address1 = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 1 })).address;\n      mpcV2Address2 = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 2 })).address;\n      mpcV2Address3 = (await basecoin.getAdaAddressAndAccountId({ bitgoKey: mpcV2CommonKeyChain, index: 3 })).address;\n    });\n\n    beforeEach(function () {\n      const callBack = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack\n        .withArgs('address_info', { _addresses: [mpcV2Address1] })\n        .resolves(endpointResponses.addressInfoResponse.ZeroUTXO);\n      callBack\n        .withArgs('address_info', { _addresses: [mpcV2Address2] })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO);\n      callBack\n        .withArgs('address_info', { _addresses: [mpcV2Address3] })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO2);\n      callBack.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\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      });\n\n      res.should.not.be.empty();\n      res.transactions.length.should.equal(2);\n      res.lastScanIndex.should.equal(3);\n\n      const tx1 = new Transaction(basecoin);\n      tx1.fromRawTransaction(res.transactions[0].serializedTx);\n      should.deepEqual(tx1.toJson().outputs[0].address, 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 leave MPCv1 base address derivation and signing unchanged (regression)', async function () {\n      sandBox.restore();\n      const callBack = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack\n        .withArgs('address_info', { _addresses: [consolidationWrwUser.walletAddress1] })\n        .resolves(endpointResponses.addressInfoResponse.ZeroUTXO);\n      callBack\n        .withArgs('address_info', { _addresses: [consolidationWrwUser.walletAddress2] })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO);\n      callBack\n        .withArgs('address_info', { _addresses: [consolidationWrwUser.walletAddress3] })\n        .resolves(endpointResponses.addressInfoResponse.OneUTXO2);\n      callBack.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\n\n      const getTSSSignatureSpy = sandBox.spy(EDDSAMethods, 'getTSSSignature');\n\n      const res = await basecoin.recoverConsolidations({\n        userKey: consolidationWrwUser.userKey,\n        backupKey: consolidationWrwUser.backupKey,\n        bitgoKey: consolidationWrwUser.bitgoKey,\n        walletPassphrase: consolidationWrwUser.walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n      });\n\n      res.should.not.be.empty();\n      sandBox.assert.called(getTSSSignatureSpy);\n\n      const tx1 = new Transaction(basecoin);\n      tx1.fromRawTransaction(res.transactions[0].serializedTx);\n      should.deepEqual(tx1.toJson().outputs[0].address, consolidationWrwUser.walletAddress0);\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      });\n\n      res.should.not.be.empty();\n      res.txRequests.length.should.equal(2);\n    });\n\n    it('should throw missing userKey before scanning when walletPassphrase is set but userKey is omitted', async function () {\n      const getEddsaMaterialSpy = sandBox.spy(\n        basecoin as unknown as { getEddsaSigningMaterial: unknown },\n        'getEddsaSigningMaterial'\n      );\n\n      await basecoin\n        .recoverConsolidations({\n          backupKey: mpcV2BackupKey,\n          bitgoKey: mpcV2CommonKeyChain,\n          walletPassphrase,\n          startingScanIndex: 1,\n          endingScanIndex: 4,\n        })\n        .should.be.rejectedWith('missing userKey');\n\n      sandBox.assert.notCalled(getEddsaMaterialSpy);\n      sandBox.assert.notCalled(basecoin.getDataFromNode as sinon.SinonStub);\n    });\n  });\n\n  describe('Recover Transactions Failure:', () => {\n    const destAddr = address.address2;\n    const sandBox = sinon.createSandbox();\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      const callBack = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack\n        .withArgs('address_info', sinon.match.has('_addresses'))\n        .resolves(endpointResponses.addressInfoResponse.ZeroUTXO);\n      callBack.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\n      await basecoin\n        .recover({\n          userKey: wrwUser.userKey,\n          backupKey: wrwUser.backupKey,\n          bitgoKey: wrwUser.bitgoKey,\n          walletPassphrase: wrwUser.walletPassphrase,\n          recoveryDestination: destAddr,\n        })\n        .should.rejectedWith('Did not find address with funds to recover.');\n      sandBox.assert.calledOnce(basecoin.getDataFromNode);\n    });\n\n    it('should fail to recover due to not having more than 1 ADA in funds', async function () {\n      const callBack = sandBox.stub(Ada.prototype, 'getDataFromNode' as keyof Ada);\n      callBack\n        .withArgs('address_info', sinon.match.has('_addresses'))\n        .resolves(endpointResponses.addressInfoResponse.OneSmallUTXO);\n      callBack.withArgs('tip').resolves(endpointResponses.tipInfoResponse);\n      await basecoin\n        .recover({\n          userKey: wrwUser.userKey,\n          backupKey: wrwUser.backupKey,\n          bitgoKey: wrwUser.bitgoKey,\n          walletPassphrase: wrwUser.walletPassphrase,\n          recoveryDestination: destAddr,\n        })\n        .should.rejectedWith(\n          'Insufficient funds to recover, minimum required is 1 ADA plus fees, got 834455 fees: 165545'\n        );\n      sandBox.assert.calledTwice(basecoin.getDataFromNode);\n    });\n  });\n\n  describe('Verify wallet address (isWalletAddress):', () => {\n    const commonKeychain =\n      'ed312d0db4615688219c43231eb4b98d5883c0b44bcfef1956290555995ad68ef7c22917b4a8b69183864b83cc7028655cd7a70ef76d6948d809a15050054840';\n\n    it('should verify a valid wallet address at index 0', async function () {\n      const keychains = [\n        {\n          id: '1',\n          commonKeychain: commonKeychain,\n          type: 'tss',\n          source: 'user',\n        },\n        {\n          id: '2',\n          commonKeychain: commonKeychain,\n          type: 'tss',\n          source: 'backup',\n        },\n        {\n          id: '3',\n          commonKeychain: commonKeychain,\n          type: 'tss',\n          source: 'bitgo',\n        },\n      ];\n\n      const address =\n        'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq';\n      const isValid = await basecoin.isWalletAddress({\n        address,\n        keychains,\n        index: 0,\n      });\n\n      isValid.should.equal(true);\n    });\n\n    it('should fail to verify an address with wrong index', async function () {\n      const keychains = [\n        {\n          id: '1',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'user' as const,\n        },\n        {\n          id: '2',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'backup' as const,\n        },\n        {\n          id: '3',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'bitgo' as const,\n        },\n      ];\n\n      const isValid = await basecoin.isWalletAddress({\n        address:\n          'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq',\n        keychains,\n        index: 2,\n      });\n\n      isValid.should.equal(false);\n    });\n\n    it('should fail to verify a random address not from wallet', async function () {\n      const keychains = [\n        {\n          id: '1',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'user' as const,\n        },\n        {\n          id: '2',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'backup' as const,\n        },\n        {\n          id: '3',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'bitgo' as const,\n        },\n      ];\n\n      // Use a random valid ADA address not from this wallet\n      const randomAddress = 'addr_test1vr8rakm66rcfv4fcxqykg5lf0yv7lsyk9mvapx369jpvtcgfcuk7f';\n\n      const isValid = await basecoin.isWalletAddress({\n        address: randomAddress,\n        keychains,\n        index: 0,\n      });\n\n      isValid.should.equal(false);\n    });\n\n    it('should throw error for invalid address format', async function () {\n      const keychains = [\n        {\n          id: '1',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'user' as const,\n        },\n        {\n          id: '2',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'backup' as const,\n        },\n        {\n          id: '3',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'bitgo' as const,\n        },\n      ];\n\n      const invalidAddress = 'not_a_valid_address';\n\n      await basecoin\n        .isWalletAddress({\n          address: invalidAddress,\n          keychains,\n          index: 0,\n        })\n        .should.be.rejectedWith('Invalid Cardano Address: not_a_valid_address');\n    });\n\n    it('should throw error when keychains are missing', async function () {\n      const address =\n        'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq';\n\n      await basecoin\n        .isWalletAddress({\n          address,\n          keychains: [],\n          index: 0,\n        })\n        .should.be.rejectedWith('missing required param keychains');\n    });\n\n    it('should throw error when commonKeychain is missing', async function () {\n      const keychains = [\n        {\n          id: '1',\n          type: 'tss' as const,\n          source: 'user' as const,\n          // commonKeychain is missing\n        },\n      ];\n\n      const address =\n        'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq';\n\n      await basecoin\n        .isWalletAddress({\n          address,\n          keychains,\n          index: 0,\n        })\n        .should.be.rejectedWith('missing required param commonKeychain');\n    });\n\n    it('should throw error when keychains have mismatched commonKeychains', async function () {\n      const keychains = [\n        {\n          id: '1',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'user' as const,\n        },\n        {\n          id: '2',\n          commonKeychain: 'differentKeychain1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',\n          type: 'tss' as const,\n          source: 'backup' as const,\n        },\n      ];\n\n      const address =\n        'addr_test1qzvmazmpgfhjyppwlsw29zjjwazcsfk62z9zv5vsv24p0wyeh69kzsn0ygzzalqu5299ya693qnd55y2yegeqc42z7uq0ge2pq';\n\n      await basecoin\n        .isWalletAddress({\n          address,\n          keychains,\n          index: 0,\n        })\n        .should.be.rejectedWith('all keychains must have the same commonKeychain for MPC coins');\n    });\n\n    it('should verify address when derivedFromParentWithSeed is present', async function () {\n      const derivedFromParentWithSeed = 'testDerivationSeed123';\n\n      const keychains = [\n        {\n          id: '1',\n          commonKeychain: commonKeychain,\n          derivedFromParentWithSeed: derivedFromParentWithSeed,\n          type: 'tss' as const,\n          source: 'user' as const,\n        },\n        {\n          id: '2',\n          commonKeychain: commonKeychain,\n          derivedFromParentWithSeed: derivedFromParentWithSeed,\n          type: 'tss' as const,\n          source: 'backup' as const,\n        },\n        {\n          id: '3',\n          commonKeychain: commonKeychain,\n          derivedFromParentWithSeed: derivedFromParentWithSeed,\n          type: 'tss' as const,\n          source: 'bitgo' as const,\n        },\n      ];\n\n      const { address: expectedAddress } = await (basecoin as any).getAdaAddressAndAccountId({\n        bitgoKey: commonKeychain,\n        index: 0,\n        seed: derivedFromParentWithSeed,\n      });\n\n      const isValid = await basecoin.isWalletAddress({\n        address: expectedAddress,\n        keychains,\n        index: 0,\n      });\n\n      isValid.should.equal(true);\n    });\n\n    it('should fail verification when derivedFromParentWithSeed is missing but address was created with seed', async function () {\n      const derivedFromParentWithSeed = 'testDerivationSeed123';\n      const { address: addressWithSeed } = await (basecoin as any).getAdaAddressAndAccountId({\n        bitgoKey: commonKeychain,\n        index: 0,\n        seed: derivedFromParentWithSeed,\n      });\n\n      const keychainsWithoutSeed = [\n        {\n          id: '1',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'user' as const,\n        },\n        {\n          id: '2',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'backup' as const,\n        },\n        {\n          id: '3',\n          commonKeychain: commonKeychain,\n          type: 'tss' as const,\n          source: 'bitgo' as const,\n        },\n      ];\n\n      const isValid = await basecoin.isWalletAddress({\n        address: addressWithSeed,\n        keychains: keychainsWithoutSeed,\n        index: 0,\n      });\n\n      isValid.should.equal(false);\n    });\n  });\n\n  describe('Verify token consolidation transaction:', () => {\n    it('should fail to verify a spoofed token consolidation transaction with incorrect address', async () => {\n      const consolidationTx = {\n        txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',\n        walletId: '63068ed4efa63a000877f02fd4b0fa6d',\n        txHex:\n          '84a400818258204bd0f991c1532cffe31d4a10db492b43175ec326765b6b29ceee598df2b61f470001818258390087379ebc5533ebe621963c915c3cbc5f08537fcdca4af8f8ae08ed4c87379ebc5533ebe621963c915c3cbc5f08537fcdca4af8f8ae08ed4c1a05f359ff021a00028701031a024972e1a10081825820bbacb13431b99208e6e8cdbf710147feaf06a39d71565e60b411ce9e4fa3f137584001a4ab8236563f69ff309e5786e8f39c629ed57676c692159cb2e0494c9e663355384c13c749d04c17a80ba2a45cc127df480fc64a43199a772f11acd5b14a0ff5f6',\n        feeInfo: {\n          fee: 10000,\n          feeString: '10000',\n        },\n        txInfo: {\n          inputs: [\n            {\n              address: '8iLa26KSbdpBUzNK7uYq8FvyuyA5h4k4erDHsDcPbHus',\n              value: 2.0173228e10,\n              valueString: '20173228000',\n            },\n            {\n              address: '8P2kX7Tyh9eS3RKdaBhqbEtQGAX58DXzL7mhDQABGX2d',\n              value: 10000,\n              valueString: '10000',\n            },\n          ],\n          minerFee: '10000',\n          outputs: [\n            {\n              address: 'addr_test1vr8rakm66rcfv4fcxqykg5lf0yv7lsyk9mvapx369jpvtcgfcuk7f',\n              coinName: 'tada:usdt',\n              enterprise: {\n                $oid: '5553ba8ae7a5c77006719661',\n              },\n              enterprises: [\n                {\n                  $oid: '5553ba8ae7a5c77006719661',\n                },\n              ],\n              value: 2.0173228e10,\n              valueString: '20173228000',\n              wallet: {\n                $oid: '62f4c3720d92c50008257eb5',\n              },\n              walletType: 'hot',\n              wallets: [\n                {\n                  $oid: '62f4c3720d92c50008257eb5',\n                },\n              ],\n            },\n          ],\n          payGoFee: '0',\n          spendAmount: '20173228000',\n          spendAmounts: [\n            {\n              amountString: '20173228000',\n              coinName: 'tada:usdt',\n            },\n          ],\n          type: 'Send',\n        },\n        consolidateId: '6712d7fda6de4906d658c04aebbf8f9b',\n        coin: 'tada',\n      };\n\n      // Mock the wallet with a different address than the transaction's output\n      const mockedWallet = {\n        coinSpecific: () => {\n          return {\n            rootAddress:\n              'addr_test1qqnnvptrc3rec64q2n9jh572ncu5wvdtt8uvg4g3aj96s5dwu9nj70mlahzglm9939uevupsmj8dcdqv25d5n5r8vw8sn7prey',\n          };\n        },\n      };\n\n      await basecoin\n        .verifyTransaction({\n          txParams: {},\n          txPrebuild: consolidationTx,\n          wallet: mockedWallet,\n          verification: {\n            consolidationToBaseAddress: true,\n          },\n        })\n        .should.be.rejectedWith('tx outputs does not match with expected address');\n    });\n  });\n});\n"]}