@bitgo-beta/sdk-coin-sol 7.6.4-beta.31 → 7.6.4-beta.310

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

@@ -0,0 +1,3326 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const _ = __importStar(require("lodash"));
+const nock_1 = __importDefault(require("nock"));
+const should = __importStar(require("should"));
+const sinon = __importStar(require("sinon"));
+const spl_token_1 = require("@solana/spl-token");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const statics_1 = require("@bitgo-beta/statics");
+const src_1 = require("../../src");
+const lib_1 = require("../../src/lib");
+const utils_1 = require("../../src/lib/utils");
+const testData = __importStar(require("../fixtures/sol"));
+const resources = __importStar(require("../resources/sol"));
+const solBackupKey_1 = require("./fixtures/solBackupKey");
+const getBuilderFactory_1 = require("./getBuilderFactory");
+describe('SOL:', function () {
+    let bitgo;
+    let basecoin;
+    let keyPair;
+    let newTxPrebuild;
+    let newTxPrebuildTokenTransfer;
+    let newTxParams;
+    let newTxParamsWithError;
+    let newTxParamsWithExtraData;
+    let newTxParamsTokenTransfer;
+    const badAddresses = resources.addresses.invalidAddresses;
+    const goodAddresses = resources.addresses.validAddresses;
+    const keypair = {
+        pub: resources.accountWithSeed.publicKey,
+        prv: resources.accountWithSeed.privateKey.base58,
+    };
+    const txPrebuild = {
+        recipients: [
+            {
+                address: 'lionteste212',
+                amount: '1000',
+            },
+        ],
+        txBase64: resources.TRANSFER_UNSIGNED_TX_WITH_MEMO_AND_DURABLE_NONCE,
+        txInfo: {
+            feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+            nonce: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',
+        },
+        txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',
+        isVotingTransaction: false,
+        coin: 'tsol',
+    };
+    const txParams = {
+        txPrebuild,
+        recipients: [
+            {
+                address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                amount: '300000',
+            },
+        ],
+    };
+    const memo = { value: 'test memo' };
+    const durableNonce = {
+        walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+        authWalletAddress: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+    };
+    const errorDurableNonce = {
+        walletNonceAddress: '8YM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+        authWalletAddress: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+    };
+    const txParamsWithError = {
+        txPrebuild,
+        recipients: [
+            {
+                address: 'CP5Dpaa42mMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                amount: '300000',
+            },
+        ],
+    };
+    const txParamsWithExtraData = {
+        txPrebuild,
+        recipients: [
+            {
+                address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                amount: '300000',
+                data: undefined,
+            },
+        ],
+    };
+    const txPrebuildTokenTransfer = {
+        recipients: [
+            {
+                address: 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg',
+                amount: '1',
+            },
+        ],
+        txHex: resources.TOKEN_TRANSFER_TO_NATIVE_UNSIGNED_TX_HEX,
+        txInfo: {
+            feePayer: '4DujymUFbQ8GBKtAwAZrQ6QqpvtBEivL48h4ta2oJGd2',
+            nonce: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',
+        },
+        txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',
+        isVotingTransaction: false,
+        coin: 'tsol',
+    };
+    const txParamsTokenTransfer = {
+        txPrebuild,
+        recipients: [
+            {
+                address: 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg',
+                amount: '1',
+            },
+        ],
+    };
+    const errorMemo = { value: 'different memo' };
+    const errorFeePayer = '5hr5fisPi6DXCuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe';
+    const factory = (0, getBuilderFactory_1.getBuilderFactory)('tsol');
+    const wallet = new src_1.KeyPair(resources.authAccount).getKeys();
+    const stakeAccount = new src_1.KeyPair(resources.stakeAccount).getKeys();
+    const blockHash = resources.blockHashes.validBlockHashes[0];
+    const amount = '10000';
+    const validator = resources.validator;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('sol', src_1.Tsol.createInstance);
+        bitgo.safeRegister('tsol', src_1.Tsol.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('tsol');
+        keyPair = basecoin.generateKeyPair(resources.accountWithSeed.seed);
+        newTxPrebuild = () => {
+            return _.cloneDeep(txPrebuild);
+        };
+        newTxPrebuildTokenTransfer = () => {
+            return _.cloneDeep(txPrebuildTokenTransfer);
+        };
+        newTxParams = () => {
+            return _.cloneDeep(txParams);
+        };
+        newTxParamsWithError = () => {
+            return _.cloneDeep(txParamsWithError);
+        };
+        newTxParamsWithExtraData = () => {
+            return _.cloneDeep(txParamsWithExtraData);
+        };
+        newTxParamsTokenTransfer = () => {
+            return _.cloneDeep(txParamsTokenTransfer);
+        };
+    });
+    it('should instantiate the coin', async function () {
+        let localBasecoin = bitgo.coin('tsol');
+        localBasecoin.should.be.an.instanceof(src_1.Tsol);
+        localBasecoin = bitgo.coin('sol');
+        localBasecoin.should.be.an.instanceof(src_1.Sol);
+    });
+    it('should retun the right info', function () {
+        basecoin.getChain().should.equal('tsol');
+        basecoin.getFamily().should.equal('sol');
+        basecoin.getFullName().should.equal('Testnet Solana');
+        basecoin.getBaseFactor().should.equal(1000000000);
+    });
+    describe('verify transactions', () => {
+        const walletData = {
+            id: '5b34252f1bf349930e34020a00000000',
+            coin: 'tsol',
+            keys: [
+                '5b3424f91bf349930e34017500000000',
+                '5b3424f91bf349930e34017600000000',
+                '5b3424f91bf349930e34017700000000',
+            ],
+            coinSpecific: {
+                rootAddress: wallet.pub,
+            },
+            multisigType: 'tss',
+        };
+        const walletObj = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+        it('should verify transactions', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                durableNonce,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should verify consolidate transaction', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.consolidateId = 'consolidateId';
+            const walletData = {
+                id: '5b34252f1bf349930e34020a00000000',
+                coin: 'tsol',
+                keys: [
+                    '5b3424f91bf349930e34017500000000',
+                    '5b3424f91bf349930e34017600000000',
+                    '5b3424f91bf349930e34017700000000',
+                ],
+                coinSpecific: {
+                    rootAddress: stakeAccount.pub,
+                },
+                multisigType: 'tss',
+            };
+            const walletWithDifferentAddress = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                durableNonce,
+                wallet: walletWithDifferentAddress,
+            });
+            validTransaction.should.be.true();
+        });
+        it('should handle txBase64 and txHex interchangeably', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txHex = txPrebuild.txBase64;
+            txPrebuild.txBase64 = undefined;
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                durableNonce,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should convert serialized hex string to base64', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txBase64 = Buffer.from(txPrebuild.txBase64, 'base64').toString('hex');
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                durableNonce,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        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,
+                memo,
+                durableNonce,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should fail verify transactions when have different memo', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            await basecoin
+                .verifyTransaction({ txParams, txPrebuild, memo: errorMemo, wallet: walletObj })
+                .should.be.rejectedWith('Tx memo does not match with expected txParams recipient memo');
+        });
+        it('should pass if we pass PDA address', async function () {
+            const walletData = {
+                id: '67f8ddff4c9b8b57a2e16acffac9a3b5',
+                coin: 'tsol',
+                keys: [
+                    '5b3424f91bf349930e34017500000000',
+                    '5b3424f91bf349930e34017600000000',
+                    '5b3424f91bf349930e34017700000000',
+                ],
+                coinSpecific: {
+                    rootAddress: '8zbsJA5c8HPR7BPjZkrSVrus2uMuXqCfzksGwB3Uscjb',
+                },
+                multisigType: 'tss',
+            };
+            const walletObj = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+            const txPrebuild = {
+                recipients: [
+                    {
+                        address: '11111111111111111111111111111112',
+                        amount: '1000000000',
+                        tokenName: 'tsol:usdc',
+                    },
+                ],
+                txBase64: '02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006ec1adcc89bb564f1f8225821140a9723efa80e8d506765770b7e201d66d8200d4f690e9a8163291b69f8c3827aad96cfd2105eee3aae76cbca38fcad2bf7f0a0201070c76c356cb069b66c2b35a8638b4d4afca75b303f29f0deeb4bff8528299a9c9d21c96172044f1217c3784e8f02f49e2c8fc3591e81294ab54394f9d22fd7b7a8f60129e6ecb20309c27dcba5fc6c441438d33a1568004a1860e22c16f071976a7d2e2008bd34b53a08aa9c8ec04eb2196745fc6029224447417e2fb0fced601240cabba4ce534c02fc154ba559ed2a02ac971e3385acb426ff63bb1040e2c2435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018c97258f4e2489f1bb3d1029148e0d830b5a1399daff1084048e7bd8dbe9f859d10389fbcee528f208611dccc734b31092540cb2b8d58d100f2eaa2cedb4da5e06a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea940000006a7d517192c5c51218cc94c3d4af17f58daee089ba1fd44e3dbd98a0000000006ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9e680634533882f880a3e7dfa999dfb864b88968d242a0c9a90b5df149e42da050305030209010404000000070700030608050b0a000b04040803000a0c00ca9a3b0000000009',
+                txInfo: {
+                    feePayer: '8zbsJA5c8HPR7BPjZkrSVrus2uMuXqCfzksGwB3Uscjb',
+                    nonce: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',
+                },
+                txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',
+                isVotingTransaction: false,
+                coin: 'tsol',
+            };
+            const txParams = {
+                txPrebuild,
+                recipients: [
+                    {
+                        address: '11111111111111111111111111111112',
+                        amount: '1000000000',
+                        tokenName: 'tsol:usdc',
+                    },
+                ],
+            };
+            const memo = {
+                value: undefined,
+            };
+            const verifyTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo: memo,
+                wallet: walletObj,
+            });
+            verifyTransaction.should.equal(true);
+        });
+        it('should fail verify transactions when have different durableNonce', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            await basecoin
+                .verifyTransaction({ txParams, txPrebuild, memo, durableNonce: errorDurableNonce, wallet: walletObj })
+                .should.be.rejectedWith('Tx durableNonce does not match with param durableNonce');
+        });
+        it('should fail verify transactions when have different feePayer', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            const walletData = {
+                id: '5b34252f1bf349930e34020a00000000',
+                coin: 'tsol',
+                keys: [
+                    '5b3424f91bf349930e34017500000000',
+                    '5b3424f91bf349930e34017600000000',
+                    '5b3424f91bf349930e34017700000000',
+                ],
+                coinSpecific: {
+                    rootAddress: stakeAccount.pub,
+                },
+                multisigType: 'tss',
+            };
+            const walletWithDifferentAddress = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+            await basecoin
+                .verifyTransaction({ txParams, txPrebuild, memo, wallet: walletWithDifferentAddress })
+                .should.be.rejectedWith('Tx fee payer is not the wallet root address');
+        });
+        it('should fail verify transactions when have different recipients', async function () {
+            const txParams = newTxParamsWithError();
+            const txPrebuild = newTxPrebuild();
+            await basecoin
+                .verifyTransaction({ txParams, txPrebuild, memo, errorFeePayer, wallet: walletObj })
+                .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');
+        });
+        it('should succeed to verify token transaction with native address recipient', async function () {
+            const txParams = newTxParamsTokenTransfer();
+            const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg'; // Native SOL address
+            txParams.recipients = [{ address, amount: '1', tokenName: 'tsol:usdc' }];
+            const txPrebuild = newTxPrebuildTokenTransfer();
+            const feePayerWalletData = {
+                id: '5b34252f1bf349930e34020a00000000',
+                coin: 'tsol',
+                keys: [
+                    '5b3424f91bf349930e34017500000000',
+                    '5b3424f91bf349930e34017600000000',
+                    '5b3424f91bf349930e34017700000000',
+                ],
+                coinSpecific: {
+                    rootAddress: '4DujymUFbQ8GBKtAwAZrQ6QqpvtBEivL48h4ta2oJGd2',
+                },
+                multisigType: 'tss',
+            };
+            const feePayerWallet = new sdk_core_1.Wallet(bitgo, basecoin, feePayerWalletData);
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                wallet: feePayerWallet,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should succeed to verify token transaction with leading zero recipient amount', async function () {
+            const txParams = newTxParamsTokenTransfer();
+            const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg'; // Native SOL address
+            txParams.recipients = [{ address, amount: '0001', tokenName: 'tsol:usdc' }];
+            const txPrebuild = newTxPrebuildTokenTransfer();
+            const feePayerWalletData = {
+                id: '5b34252f1bf349930e34020a00000000',
+                coin: 'tsol',
+                keys: [
+                    '5b3424f91bf349930e34017500000000',
+                    '5b3424f91bf349930e34017600000000',
+                    '5b3424f91bf349930e34017700000000',
+                ],
+                coinSpecific: {
+                    rootAddress: '4DujymUFbQ8GBKtAwAZrQ6QqpvtBEivL48h4ta2oJGd2',
+                },
+                multisigType: 'tss',
+            };
+            const feePayerWallet = new sdk_core_1.Wallet(bitgo, basecoin, feePayerWalletData);
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                wallet: feePayerWallet,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should fail to verify token transaction with different recipient tokenName', async function () {
+            const txParams = newTxParamsTokenTransfer();
+            const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg'; // Native SOL address
+            txParams.recipients = [{ address, amount: '1', tokenName: 'tsol:usdt' }]; // Different tokenName, should fail to verify tx
+            const txPrebuild = newTxPrebuildTokenTransfer();
+            await basecoin
+                .verifyTransaction({
+                txParams,
+                txPrebuild,
+                wallet: walletObj,
+            })
+                .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');
+        });
+        it('should fail to verify token transaction with different recipient amounts', async function () {
+            const txParams = newTxParamsTokenTransfer();
+            const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg'; // Native SOL address
+            txParams.recipients = [{ address, amount: '2', tokenName: 'tsol:usdt' }];
+            const txPrebuild = newTxPrebuildTokenTransfer();
+            await basecoin
+                .verifyTransaction({
+                txParams,
+                txPrebuild,
+                wallet: walletObj,
+            })
+                .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');
+        });
+        it('should fail to verify token transaction with different native address', async function () {
+            const txParams = newTxParamsTokenTransfer();
+            const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvX'; // Native SOL address, different than tx recipients
+            txParams.recipients = [{ address, amount: '1', tokenName: 'tsol:usdc' }];
+            const txPrebuild = newTxPrebuildTokenTransfer();
+            await basecoin
+                .verifyTransaction({
+                txParams,
+                txPrebuild,
+                wallet: walletObj,
+            })
+                .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');
+        });
+        it('should succeed to verify transactions when recipients has extra data', async function () {
+            const txParams = newTxParamsWithExtraData();
+            const txPrebuild = newTxPrebuild();
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                durableNonce,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should verify activate staking transaction', async function () {
+            const tx = await factory
+                .getStakingActivateBuilder()
+                .stakingAddress(stakeAccount.pub)
+                .sender(wallet.pub)
+                .nonce(blockHash)
+                .amount(amount)
+                .validator(validator.pub)
+                .memo('test memo')
+                .fee({ amount: 5000 })
+                .build();
+            const txToBroadcastFormat = tx.toBroadcastFormat();
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txBase64 = txToBroadcastFormat;
+            txPrebuild.txInfo.nonce = '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen';
+            txParams.recipients = [
+                {
+                    address: '7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za',
+                    amount: amount,
+                },
+            ];
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should verify withdraw staking transaction', async function () {
+            const tx = await factory
+                .getStakingWithdrawBuilder()
+                .stakingAddress(stakeAccount.pub)
+                .sender(wallet.pub)
+                .nonce(blockHash)
+                .amount(amount)
+                .memo('test memo')
+                .fee({ amount: 5000 })
+                .build();
+            const txToBroadcastFormat = tx.toBroadcastFormat();
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txBase64 = txToBroadcastFormat;
+            txPrebuild.txInfo.nonce = '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen';
+            txParams.recipients = [
+                {
+                    address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                    amount: amount,
+                },
+            ];
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should verify deactivate staking transaction', async function () {
+            const tx = await factory
+                .getStakingDeactivateBuilder()
+                .stakingAddress(stakeAccount.pub)
+                .sender(wallet.pub)
+                .nonce(blockHash)
+                .memo('test memo')
+                .fee({ amount: 5000 })
+                .build();
+            const txToBroadcastFormat = tx.toBroadcastFormat();
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txBase64 = txToBroadcastFormat;
+            txPrebuild.txInfo.nonce = '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen';
+            txParams.recipients = [];
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should verify create associated token account transaction', async function () {
+            const tx = await factory
+                .getAtaInitializationBuilder()
+                .mint('tsol:usdc')
+                .sender(wallet.pub)
+                .nonce(blockHash)
+                .memo('test memo')
+                .fee({ amount: 5000 })
+                .build();
+            const txToBroadcastFormat = tx.toBroadcastFormat();
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txBase64 = txToBroadcastFormat;
+            txPrebuild.txInfo.nonce = blockHash;
+            txParams.recipients = [];
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+    });
+    describe('getAmountBasedOnEndianness', () => {
+        let originalArch;
+        beforeEach(() => {
+            originalArch = process.arch;
+        });
+        afterEach(() => {
+            Object.defineProperty(process, 'arch', {
+                value: originalArch,
+                writable: true,
+                configurable: true,
+            });
+        });
+        it('should return amount unchanged on non-s390x architectures', function () {
+            Object.defineProperty(process, 'arch', {
+                value: 'x64',
+                writable: true,
+                configurable: true,
+            });
+            (0, src_1.getAmountBasedOnEndianness)('300000').should.equal('300000');
+            (0, src_1.getAmountBasedOnEndianness)('10000').should.equal('10000');
+            (0, src_1.getAmountBasedOnEndianness)('504403158265495552').should.equal('504403158265495552');
+        });
+        it('should byte-swap small amounts on s390x (small becomes huge)', function () {
+            Object.defineProperty(process, 'arch', {
+                value: 's390x',
+                writable: true,
+                configurable: true,
+            });
+            // Small amount 10,000 (0x2710) swaps to 1,163,899,028,698,562,560
+            (0, src_1.getAmountBasedOnEndianness)('10000').should.equal('1163899028698562560');
+        });
+        it('should byte-swap large amounts on s390x (large becomes tiny)', function () {
+            Object.defineProperty(process, 'arch', {
+                value: 's390x',
+                writable: true,
+                configurable: true,
+            });
+            // Large amount 504,403,158,265,495,552 (0x0700000000000000) swaps to 7
+            (0, src_1.getAmountBasedOnEndianness)('504403158265495552').should.equal('7');
+        });
+        it('should handle numeric input', function () {
+            Object.defineProperty(process, 'arch', {
+                value: 's390x',
+                writable: true,
+                configurable: true,
+            });
+            // Should work with numbers, not just strings
+            (0, src_1.getAmountBasedOnEndianness)(10000).should.equal('1163899028698562560');
+        });
+        it('should handle standard transaction amounts on s390x', function () {
+            Object.defineProperty(process, 'arch', {
+                value: 's390x',
+                writable: true,
+                configurable: true,
+            });
+            // Standard amount 300,000 (0x493E0) swaps to large value
+            const result = (0, src_1.getAmountBasedOnEndianness)('300000');
+            // Verify it's different (swapped)
+            result.should.not.equal('300000');
+            // Verify swapping back gives original
+            (0, src_1.getAmountBasedOnEndianness)(result).should.equal('300000');
+        });
+        it('should handle invalid input gracefully', function () {
+            Object.defineProperty(process, 'arch', {
+                value: 's390x',
+                writable: true,
+                configurable: true,
+            });
+            // Invalid BigInt input should return original string
+            (0, src_1.getAmountBasedOnEndianness)('not-a-number').should.equal('not-a-number');
+        });
+    });
+    it('should accept valid address', function () {
+        goodAddresses.forEach((addr) => {
+            basecoin.isValidAddress(addr).should.equal(true);
+        });
+    });
+    it('should reject invalid address', function () {
+        badAddresses.forEach((addr) => {
+            basecoin.isValidAddress(addr).should.equal(false);
+        });
+    });
+    it('should check valid pub keys', function () {
+        keyPair.should.have.property('pub');
+        basecoin.isValidPub(keyPair.pub).should.equal(true);
+    });
+    it('should check an invalid pub keys', function () {
+        const badPubKey = keyPair.pub.slice(0, keyPair.pub.length - 1) + '-';
+        basecoin.isValidPub(badPubKey).should.equal(false);
+    });
+    it('should check valid prv keys', function () {
+        keyPair.should.have.property('prv');
+        basecoin.isValidPrv(keyPair.prv).should.equal(true);
+    });
+    it('should check an invalid prv keys', function () {
+        const badPrvKey = keyPair.prv ? keyPair.prv.slice(0, keyPair.prv.length - 1) + '-' : undefined;
+        basecoin.isValidPrv(badPrvKey).should.equal(false);
+    });
+    describe('Parse Transactions:', () => {
+        it('should parse an unsigned transfer transaction', async function () {
+            const parsedTransaction = await basecoin.parseTransaction({
+                txBase64: testData.rawTransactions.transfer.unsigned,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            parsedTransaction.should.deepEqual({
+                inputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: 305000,
+                    },
+                ],
+                outputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: '300000',
+                    },
+                ],
+            });
+        });
+        it('should parse a signed transfer transaction', async function () {
+            const parsedTransaction = await basecoin.parseTransaction({
+                txBase64: testData.rawTransactions.transfer.signed,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            parsedTransaction.should.deepEqual({
+                inputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: 305000,
+                    },
+                ],
+                outputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: '300000',
+                    },
+                ],
+            });
+        });
+        it('should parse an unsigned wallet init transaction', async function () {
+            const parsedTransaction = await basecoin.parseTransaction({
+                txBase64: testData.rawTransactions.walletInit.unsigned,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            parsedTransaction.should.deepEqual({
+                inputs: [
+                    {
+                        address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                        amount: 310000,
+                    },
+                ],
+                outputs: [
+                    {
+                        address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                        amount: '300000',
+                    },
+                ],
+            });
+        });
+        it('should parse a signed wallet init transaction', async function () {
+            const parsedTransaction = await basecoin.parseTransaction({
+                txBase64: testData.rawTransactions.walletInit.signed,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            parsedTransaction.should.deepEqual({
+                inputs: [
+                    {
+                        address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                        amount: 310000,
+                    },
+                ],
+                outputs: [
+                    {
+                        address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                        amount: '300000',
+                    },
+                ],
+            });
+        });
+        it('should parse an unsigned transfer token transaction', async function () {
+            const parsedTransaction = await basecoin.parseTransaction({
+                txBase64: testData.rawTransactions.transferToken.unsigned,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            parsedTransaction.should.deepEqual({
+                inputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: 5000,
+                    },
+                ],
+                outputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: '300000',
+                        tokenName: 'tsol:usdc',
+                    },
+                ],
+            });
+        });
+        it('should parse a signed transfer token transaction', async function () {
+            const parsedTransaction = await basecoin.parseTransaction({
+                txBase64: testData.rawTransactions.transferToken.signed,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            parsedTransaction.should.deepEqual({
+                inputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: 5000,
+                    },
+                ],
+                outputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: '300000',
+                        tokenName: 'tsol:usdc',
+                    },
+                ],
+            });
+        });
+    });
+    describe('Explain Transactions:', () => {
+        it('should explain an unsigned transfer transaction', async function () {
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: testData.rawTransactions.transfer.unsigned,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: 'UNAVAILABLE',
+                type: 'Send',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '300000',
+                outputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: '300000',
+                    },
+                ],
+                inputs: [
+                    {
+                        address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                        value: '300000',
+                    },
+                ],
+                feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                fee: {
+                    fee: '5000',
+                    feeRate: 5000,
+                },
+                memo: 'test memo',
+                blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',
+                durableNonce: {
+                    authWalletAddress: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                    walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                },
+                tokenEnablements: [],
+                ataOwnerMap: {},
+            });
+        });
+        it('should explain a signed transfer transaction', async function () {
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: testData.rawTransactions.transfer.signed,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: '2XFxGfXddKWnqGaMAsfNL8HgXqDvjBL2Ae28KWrRvg9bQBmCrpHYVDacuZFeAUyYwjXG6ey2jTARX5VQCnj7SF4L',
+                type: 'Send',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '300000',
+                outputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: '300000',
+                    },
+                ],
+                inputs: [
+                    {
+                        address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                        value: '300000',
+                    },
+                ],
+                feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                fee: {
+                    fee: '5000',
+                    feeRate: 5000,
+                },
+                memo: 'test memo',
+                blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',
+                durableNonce: {
+                    authWalletAddress: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                    walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                },
+                tokenEnablements: [],
+                ataOwnerMap: {},
+            });
+        });
+        it('should explain an unsigned wallet init transaction', async function () {
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: testData.rawTransactions.walletInit.unsigned,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: 'UNAVAILABLE',
+                type: 'WalletInitialization',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '300000',
+                outputs: [
+                    {
+                        address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                        amount: '300000',
+                    },
+                ],
+                inputs: [
+                    {
+                        address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                        value: '300000',
+                    },
+                ],
+                feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                fee: {
+                    fee: '10000',
+                    feeRate: 5000,
+                },
+                blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',
+                durableNonce: undefined,
+                memo: undefined,
+                tokenEnablements: [],
+                ataOwnerMap: {},
+            });
+        });
+        it('should explain a signed wallet init transaction', async function () {
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: testData.rawTransactions.walletInit.signed,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: '7TkU8wLgXDeLFbVydtg6mqMsp9GatsetitSngysgjxFhofKSUcLPBoKPHciLeGEfJFMsqezpZmGRSFQTBy7ZDsg',
+                type: 'WalletInitialization',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '300000',
+                outputs: [
+                    {
+                        address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                        amount: '300000',
+                    },
+                ],
+                inputs: [
+                    {
+                        address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                        value: '300000',
+                    },
+                ],
+                feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                fee: {
+                    fee: '10000',
+                    feeRate: 5000,
+                },
+                blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',
+                durableNonce: undefined,
+                memo: undefined,
+                tokenEnablements: [],
+                ataOwnerMap: {},
+            });
+        });
+        it('should explain an unsigned token transfer transaction', async function () {
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: testData.rawTransactions.transferToken.unsigned,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: 'UNAVAILABLE',
+                type: 'Send',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '0',
+                outputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: '300000',
+                        tokenName: 'tsol:usdc',
+                    },
+                ],
+                inputs: [
+                    {
+                        address: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',
+                        value: '300000',
+                    },
+                ],
+                feePayer: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',
+                fee: {
+                    fee: '5000',
+                    feeRate: 5000,
+                },
+                memo: 'test memo',
+                blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',
+                durableNonce: {
+                    authWalletAddress: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',
+                    walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                },
+                tokenEnablements: [],
+                ataOwnerMap: {},
+            });
+        });
+        it('should explain a signed token transfer transaction', async function () {
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: testData.rawTransactions.transferToken.signed,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: '2ticU4ZkEqdTHULr6LobTgWBhim6E7wSscDhM4gzyuGUmQyUwLYhoqaifuvwmNzzEf1T5aefVcgMQkSHdJ5nsrfZ',
+                type: 'Send',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '0',
+                outputs: [
+                    {
+                        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',
+                        amount: '300000',
+                        tokenName: 'tsol:usdc',
+                    },
+                ],
+                inputs: [
+                    {
+                        address: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',
+                        value: '300000',
+                    },
+                ],
+                feePayer: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',
+                fee: {
+                    fee: '5000',
+                    feeRate: 5000,
+                },
+                memo: 'test memo',
+                blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',
+                durableNonce: {
+                    authWalletAddress: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',
+                    walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                },
+                tokenEnablements: [],
+                ataOwnerMap: {},
+            });
+        });
+        it('should explain activate staking transaction', async function () {
+            const tx = await factory
+                .getStakingActivateBuilder()
+                .stakingAddress(stakeAccount.pub)
+                .sender(wallet.pub)
+                .nonce(blockHash)
+                .amount(amount)
+                .validator(validator.pub)
+                .memo('test memo')
+                .fee({ amount: 5000 })
+                .build();
+            const txToBroadcastFormat = tx.toBroadcastFormat();
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: txToBroadcastFormat,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: 'UNAVAILABLE',
+                type: 'StakingActivate',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '10000',
+                outputs: [
+                    {
+                        address: '7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za',
+                        amount: '10000',
+                    },
+                ],
+                inputs: [
+                    {
+                        address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                        value: '10000',
+                    },
+                ],
+                feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                fee: {
+                    fee: '10000',
+                    feeRate: 5000,
+                },
+                memo: 'test memo',
+                blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',
+                durableNonce: undefined,
+                tokenEnablements: [],
+                ataOwnerMap: {},
+            });
+        });
+        it('should explain deactivate staking transaction', async function () {
+            const tx = await factory
+                .getStakingDeactivateBuilder()
+                .stakingAddress(stakeAccount.pub)
+                .sender(wallet.pub)
+                .nonce(blockHash)
+                .memo('test memo')
+                .fee({ amount: 5000 })
+                .build();
+            const txToBroadcastFormat = tx.toBroadcastFormat();
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: txToBroadcastFormat,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: 'UNAVAILABLE',
+                type: 'StakingDeactivate',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '0',
+                outputs: [],
+                inputs: [],
+                feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                fee: {
+                    fee: '5000',
+                    feeRate: 5000,
+                },
+                memo: 'test memo',
+                blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',
+                durableNonce: undefined,
+                tokenEnablements: [],
+                ataOwnerMap: {},
+            });
+        });
+        it('should explain withdraw staking transaction', async function () {
+            const tx = await factory
+                .getStakingWithdrawBuilder()
+                .stakingAddress(stakeAccount.pub)
+                .sender(wallet.pub)
+                .nonce(blockHash)
+                .amount(amount)
+                .memo('test memo')
+                .fee({ amount: 5000 })
+                .build();
+            const txToBroadcastFormat = tx.toBroadcastFormat();
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: txToBroadcastFormat,
+                feeInfo: {
+                    fee: '5000',
+                },
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: 'UNAVAILABLE',
+                type: 'StakingWithdraw',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '10000',
+                outputs: [
+                    {
+                        address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                        amount: '10000',
+                    },
+                ],
+                inputs: [
+                    {
+                        address: '7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za',
+                        value: '10000',
+                    },
+                ],
+                feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                fee: {
+                    fee: '5000',
+                    feeRate: 5000,
+                },
+                memo: 'test memo',
+                blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',
+                durableNonce: undefined,
+                tokenEnablements: [],
+                ataOwnerMap: {},
+            });
+        });
+        it('should explain create ATA transaction', async function () {
+            const tokenName = 'tsol:usdc';
+            const rentExemptAmount = '3000000';
+            const tx = await factory
+                .getAtaInitializationBuilder()
+                .sender(wallet.pub)
+                .nonce(blockHash)
+                .mint(tokenName)
+                .rentExemptAmount(rentExemptAmount)
+                .memo('test memo')
+                .fee({ amount: 5000 })
+                .build();
+            const txToBroadcastFormat = tx.toBroadcastFormat();
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: txToBroadcastFormat,
+                feeInfo: {
+                    fee: '5000',
+                },
+                tokenAccountRentExemptAmount: rentExemptAmount,
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: 'UNAVAILABLE',
+                type: 'AssociatedTokenAccountInitialization',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '0',
+                outputs: [],
+                inputs: [],
+                feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                fee: {
+                    fee: '3005000',
+                    feeRate: 5000,
+                },
+                memo: 'test memo',
+                blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',
+                durableNonce: undefined,
+                tokenEnablements: [
+                    {
+                        address: '141BFNem3pknc8CzPVLv1Ri3btgKdCsafYP5nXwmXfxU',
+                        tokenAddress: 'F4uLeXJoFz3hw13MposuwaQbMcZbCjqvEGPPeRRB1Byf',
+                        tokenName: 'tsol:usdc',
+                    },
+                ],
+                ataOwnerMap: {
+                    '141BFNem3pknc8CzPVLv1Ri3btgKdCsafYP5nXwmXfxU': '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                },
+            });
+        });
+        it('should explain create multi ATA transaction', async function () {
+            const recipients = [
+                {
+                    ownerAddress: wallet.pub,
+                    tokenName: 'tsol:usdc',
+                },
+                {
+                    ownerAddress: durableNonce.walletNonceAddress,
+                    tokenName: 'tsol:ray',
+                },
+            ];
+            const rentExemptAmount = '3000000';
+            const tx = await factory
+                .getAtaInitializationBuilder()
+                .sender(wallet.pub)
+                .nonce(blockHash)
+                .enableToken(recipients[0])
+                .enableToken(recipients[1])
+                .rentExemptAmount(rentExemptAmount)
+                .memo('test memo')
+                .fee({ amount: 5000 })
+                .build();
+            const txToBroadcastFormat = tx.toBroadcastFormat();
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: txToBroadcastFormat,
+                feeInfo: {
+                    fee: '5000',
+                },
+                tokenAccountRentExemptAmount: rentExemptAmount,
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: 'UNAVAILABLE',
+                type: 'AssociatedTokenAccountInitialization',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '0',
+                outputs: [],
+                inputs: [],
+                feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                fee: {
+                    fee: '6005000',
+                    feeRate: 5000,
+                },
+                memo: 'test memo',
+                blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',
+                durableNonce: undefined,
+                tokenEnablements: [
+                    {
+                        address: '141BFNem3pknc8CzPVLv1Ri3btgKdCsafYP5nXwmXfxU',
+                        tokenAddress: 'F4uLeXJoFz3hw13MposuwaQbMcZbCjqvEGPPeRRB1Byf',
+                        tokenName: 'tsol:usdc',
+                    },
+                    {
+                        address: '9KaLinZFNW5chL4J8UoKnTECppWVMz3ewgx4FAkxUDcf',
+                        tokenAddress: '9kLJoGbMgSteptkhKKuh7ken4JEvHrT83157ezEGrZ7R',
+                        tokenName: 'tsol:ray',
+                    },
+                ],
+                ataOwnerMap: {
+                    '141BFNem3pknc8CzPVLv1Ri3btgKdCsafYP5nXwmXfxU': '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',
+                    '9KaLinZFNW5chL4J8UoKnTECppWVMz3ewgx4FAkxUDcf': '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',
+                },
+            });
+        });
+        it('should explain an unsigned token transfer with ATA creation transaction', async function () {
+            const explainedTransaction = await basecoin.explainTransaction({
+                txBase64: testData.rawTransactions.tokenTransferWithAtaCreation.unsigned,
+                feeInfo: {
+                    fee: '5000',
+                },
+                tokenAccountRentExemptAmount: '3000000',
+            });
+            explainedTransaction.should.deepEqual({
+                displayOrder: [
+                    'id',
+                    'type',
+                    'blockhash',
+                    'durableNonce',
+                    'outputAmount',
+                    'changeAmount',
+                    'outputs',
+                    'changeOutputs',
+                    'tokenEnablements',
+                    'fee',
+                    'memo',
+                ],
+                id: 'UNAVAILABLE',
+                type: 'Send',
+                changeOutputs: [],
+                changeAmount: '0',
+                outputAmount: '0',
+                outputs: [
+                    {
+                        address: '2eKjVtzV3oPTXFdtRSDj3Em9k1MV7k8WjKkBszQUwizS',
+                        amount: '10000',
+                        tokenName: 'tsol:usdc',
+                    },
+                ],
+                inputs: [
+                    {
+                        address: '5U3bH5b6XtG99aVWLqwVzYPVpQiFHytBD68Rz2eFPZd7',
+                        value: '10000',
+                    },
+                ],
+                feePayer: '5U3bH5b6XtG99aVWLqwVzYPVpQiFHytBD68Rz2eFPZd7',
+                fee: { fee: '3005000', feeRate: 5000 },
+                memo: undefined,
+                blockhash: '27E3MXFvXMUNYeMJeX1pAbERGsJfUbkaZTfgMgpmNN5g',
+                durableNonce: undefined,
+                tokenEnablements: [
+                    {
+                        address: '2eKjVtzV3oPTXFdtRSDj3Em9k1MV7k8WjKkBszQUwizS',
+                        tokenAddress: 'F4uLeXJoFz3hw13MposuwaQbMcZbCjqvEGPPeRRB1Byf',
+                        tokenName: 'tsol:usdc',
+                    },
+                ],
+                ataOwnerMap: {
+                    '2eKjVtzV3oPTXFdtRSDj3Em9k1MV7k8WjKkBszQUwizS': 'C4zCqCaDm4D78zgaH3CeBEEBEAoMNhzSCj23qE92ndiP',
+                },
+            });
+        });
+    });
+    describe('Keypair:', () => {
+        it('should generate a keypair from random seed', function () {
+            should.throws(() => basecoin.generateKeyPair('placeholder'), 'generateKeyPair method not implemented');
+        });
+        it('should generate a keypair from a seed', function () {
+            should.throws(() => basecoin.generateKeyPair('placeholder'), 'generateKeyPair method not implemented');
+        });
+    });
+    describe('Sign transaction:', () => {
+        it('should sign transaction', async function () {
+            const signed = await basecoin.signTransaction({
+                txPrebuild: {
+                    txBase64: resources.RAW_TX_UNSIGNED,
+                    keys: [resources.accountWithSeed.publicKey.toString()],
+                },
+                prv: resources.accountWithSeed.privateKey.base58,
+            });
+            signed.txHex.should.equal(resources.RAW_TX_SIGNED);
+        });
+        it('should handle txHex and txBase64 interchangeably', async function () {
+            const signed = await basecoin.signTransaction({
+                txPrebuild: {
+                    txHex: resources.RAW_TX_UNSIGNED,
+                    keys: [resources.accountWithSeed.publicKey.toString()],
+                },
+                prv: resources.accountWithSeed.privateKey.base58,
+            });
+            signed.txHex.should.equal(resources.RAW_TX_SIGNED);
+        });
+        it('should throw invalid transaction when sign with public key', async function () {
+            await basecoin
+                .signTransaction({
+                txPrebuild: {
+                    txBase64: resources.RAW_TX_UNSIGNED,
+                    keys: [resources.accountWithSeed.publicKey.toString()],
+                },
+                prv: resources.accountWithSeed.publicKey,
+            })
+                .should.be.rejectedWith('Invalid key');
+        });
+    });
+    describe('Sign message', () => {
+        it('should sign message', async function () {
+            const signed = await basecoin.signMessage(keypair, 'signed message');
+            signed
+                .toString('base64')
+                .should.equal('s+7d/8aW/twfM/0wLSKOGxd9+LhDIiz/g0FfJ39ylJhQIkjK0RYPm/Y+gdeJ5DIy6K6h6gCXXESDomlv12DBBQ==');
+        });
+        it('shouldnt sign message when message is undefined', async function () {
+            await basecoin
+                .signMessage(keypair, undefined)
+                .should.be.rejectedWith('The first argument must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object. Received undefined');
+        });
+    });
+    describe('Get Signing Payload', () => {
+        it('should return a valid signing payload', async function () {
+            const factory = (0, getBuilderFactory_1.getBuilderFactory)(basecoin.getChain());
+            const rebuiltSignablePayload = (await factory.from(resources.TRANSFER_UNSIGNED_TX_WITH_MEMO).build())
+                .signablePayload;
+            const signingPayload = await basecoin.getSignablePayload(resources.TRANSFER_UNSIGNED_TX_WITH_MEMO);
+            signingPayload.should.be.deepEqual(rebuiltSignablePayload);
+        });
+        it('should build CloseAssociatedTokenAccount txn builder from raw txn', async function () {
+            const factory = (0, getBuilderFactory_1.getBuilderFactory)(basecoin.getChain());
+            const txnBuilder = factory.from(resources.TRANSFER_UNSIGNED_TX_CLOSE_ATA);
+            assert_1.default.ok(txnBuilder);
+        });
+    });
+    describe('Presign transaction', () => {
+        const txRequestId = 'txRequestId';
+        let sandbox;
+        beforeEach(() => {
+            sandbox = sinon.createSandbox();
+        });
+        afterEach(() => {
+            sandbox.verifyAndRestore();
+        });
+        it('should rebuild tx request for hot wallets', async () => {
+            const rebuiltTx = {
+                txRequestId,
+                unsignedTxs: [
+                    {
+                        serializedTxHex: 'deadbeef',
+                        signableHex: 'serializedTxHex',
+                        derivationPath: 'm/0',
+                    },
+                ],
+                transactions: [],
+                date: new Date().toISOString(),
+                intent: {
+                    intentType: 'payment',
+                },
+                latest: true,
+                state: 'pendingUserSignature',
+                walletType: 'hot',
+                walletId: 'walletId',
+                policiesChecked: true,
+                version: 1,
+                userId: 'userId',
+            };
+            const stubTssUtils = sandbox.createStubInstance(sdk_core_1.TssUtils);
+            stubTssUtils.deleteSignatureShares.resolves([]);
+            stubTssUtils.getTxRequest.resolves(rebuiltTx);
+            const hotWallet = {
+                type: 'hot',
+            };
+            const presignedTransaction = await basecoin.presignTransaction({
+                walletData: hotWallet,
+                tssUtils: stubTssUtils,
+                txPrebuild: {
+                    txRequestId,
+                },
+            });
+            presignedTransaction.walletData.should.deepEqual(hotWallet);
+            presignedTransaction.txPrebuild.should.deepEqual(rebuiltTx);
+            presignedTransaction.txHex.should.equal(rebuiltTx.unsignedTxs[0].serializedTxHex);
+        });
+        it('should do nothing for non-hot wallets', async () => {
+            const coldWallet = {
+                type: 'cold',
+            };
+            const presignedTransaction = await basecoin.presignTransaction({
+                walletData: coldWallet,
+            });
+            presignedTransaction.should.deepEqual({
+                walletData: coldWallet,
+            });
+        });
+        it('should error if txRequestId is missing', async () => {
+            const hotWallet = {
+                type: 'hot',
+            };
+            await basecoin
+                .presignTransaction({
+                walletData: hotWallet,
+                txPrebuild: {},
+            })
+                .should.rejectedWith('Missing txRequestId');
+        });
+    });
+    describe('API Key parameter:', () => {
+        // Test the getPublicNodeUrl method directly
+        it('should append apiKey to node URL when provided', function () {
+            // Access the protected method using type casting
+            const url = basecoin.getPublicNodeUrl('test-api-key-123');
+            url.should.equal(`${sdk_core_1.Environments.test.solAlchemyNodeUrl}/test-api-key-123`);
+        });
+        it('should use regular node URL when apiKey is not provided', function () {
+            // Access the protected method using type casting
+            const url = basecoin.getPublicNodeUrl();
+            url.should.equal(sdk_core_1.Environments.test.solNodeUrl);
+        });
+    });
+    describe('Recover Transactions:', () => {
+        const sandBox = sinon.createSandbox();
+        const coin = statics_1.coins.get('tsol');
+        const usdtMintAddress = '9cgpBeNZ2HnLda7NWaaU1i3NyTstk2c4zCMUcoAGsi9C';
+        const t22mintAddress = '5NR1bQwLWqjbkhbQ1hx72HKJybbuvwkDnUZNoAZ2VhW6';
+        let callBack;
+        beforeEach(() => {
+            callBack = sandBox.stub(src_1.Sol.prototype, 'getDataFromNode');
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getLatestBlockhash',
+                    params: [
+                        {
+                            commitment: 'finalized',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getBlockhashResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getFeeForMessage',
+                    params: [
+                        sinon.match.string,
+                        {
+                            commitment: 'finalized',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getFeesForMessageResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getMinimumBalanceForRentExemption',
+                    params: [165],
+                },
+            })
+                .resolves(testData.SolResponses.getMinimumBalanceForRentExemptionResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.accountInfo.bs58EncodedPublicKey],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.accountInfo.bs58EncodedPublicKeyNoFunds],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponseNoFunds);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.accountInfo.bs58EncodedPublicKeyM1Derivation],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponseM1Derivation);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.accountInfo.bs58EncodedPublicKeyM2Derivation],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponseM2Derivation);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.accountInfo.bs58EncodedPublicKeyWithManyTokens],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponseM2Derivation);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.closeATAkeys.closeAtaAddress],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponseM2Derivation);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.closeATAkeys.bs58EncodedPublicKey],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponseM2Derivation);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getAccountInfo',
+                    params: [
+                        testData.closeATAkeys.closeAtaAddress,
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenInfoResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getAccountInfo',
+                    params: [
+                        testData.keys.durableNoncePubKey,
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountInfoResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.keys.destinationPubKey,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.accountInfo.bs58EncodedPublicKey,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.keys.destinationPubKey2,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.keys.destinationPubKey2,
+                        {
+                            programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerForSol2022Response2);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.wrwUser.walletAddress0,
+                        {
+                            programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerForSol2022Response);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.wrwUser.walletAddress0,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse2);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.wrwUser.walletAddress4,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse3);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.wrwUser.walletAddress0],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.keys.destinationPubKey,
+                        {
+                            programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'sendTransaction',
+                    params: sinon.match.array,
+                },
+            })
+                .onCall(0)
+                .resolves(testData.SolResponses.broadcastTransactionResponse)
+                .onCall(1)
+                .resolves(testData.SolResponses.broadcastTransactionResponse1);
+        });
+        afterEach(() => {
+            sandBox.restore();
+        });
+        it('should take OVC output and generate a signed sweep transaction', async function () {
+            const params = testData.ovcResponse;
+            const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);
+            recoveryTxn.transactions[0].serializedTx.should.equal('AvR+L909kzRq6NuaUe9F6Jt97MOiFs7jpW8MuOrwz4EbKF40d31dci/bgLTq4gpk/Hh3s5cA8FtbLkDQr15PqAE7yd8LOXvsLtO2REqMM/OCZ8wItfsqfTfia2xIfibRW3wHgw63jiaojbXeSqaYajJ/Ca7YwBUz5blydI3fYLgPAgECBsLVtfT7mpvNii8wPk0G942N7TAHE/RW2iq/8LPqAYWqBRo0vIrNQ4djl2+Wh2EVBQ9zgoVTVm0RHXrIv/6/WHxPX1mHv+JqpmAT79ltNjYPK0M2yR+ZMln7VgUTBWFNQvLqE/j/nXlY2/JpxuNr/fXLXEPeS04dPvt9qz1dAoYEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAADpiH20cxLj7KnOaoI5ANNoPxYjs472FdjDeMPft3kXdAgQDAgUBBAQAAAAEAgADDAIAAADwopo7AAAAAA==');
+            (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(0);
+            (recoveryTxn.lastScanIndex ?? 0).should.equal(0);
+        });
+        it('should take sol 2022 token OVC output and generate a signed sweep transaction', async function () {
+            const params = testData.ovcResponse;
+            const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);
+            recoveryTxn.transactions[0].serializedTx.should.equal('AvR+L909kzRq6NuaUe9F6Jt97MOiFs7jpW8MuOrwz4EbKF40d31dci/bgLTq4gpk/Hh3s5cA8FtbLkDQr15PqAE7yd8LOXvsLtO2REqMM/OCZ8wItfsqfTfia2xIfibRW3wHgw63jiaojbXeSqaYajJ/Ca7YwBUz5blydI3fYLgPAgECBsLVtfT7mpvNii8wPk0G942N7TAHE/RW2iq/8LPqAYWqBRo0vIrNQ4djl2+Wh2EVBQ9zgoVTVm0RHXrIv/6/WHxPX1mHv+JqpmAT79ltNjYPK0M2yR+ZMln7VgUTBWFNQvLqE/j/nXlY2/JpxuNr/fXLXEPeS04dPvt9qz1dAoYEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAADpiH20cxLj7KnOaoI5ANNoPxYjs472FdjDeMPft3kXdAgQDAgUBBAQAAAAEAgADDAIAAADwopo7AAAAAA==');
+            (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(0);
+            (recoveryTxn.lastScanIndex ?? 0).should.equal(0);
+        });
+        it('should take consolidation OVC output and generate multiple signed sweep transactions', async function () {
+            const params = testData.ovcResponse2;
+            const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);
+            recoveryTxn.transactions[0].serializedTx.should.equal('AtQPLzOmLuKwHY6N5XoJIZK/T7W10uYWm/MRte3GFUdl+w3gHLjSa9H66WSfFNubQxIPckxJDyltkP7ksLDf9QgBNJM2UWbBUH5wT0JJHILlhCs33HX8DeE/8Tdsw6tGfZoMhCnSKv6TPWtBxy7Sb6sW8ksCUPnAWuHGGKmgjEMBAgECBmLrqxJrY2kbN/tcrQw3P8P15OljFGabFJAKBrUO1grNBRo0vIrNQ4djl2+Wh2EVBQ9zgoVTVm0RHXrIv/6/WHxPX1mHv+JqpmAT79ltNjYPK0M2yR+ZMln7VgUTBWFNQsLVtfT7mpvNii8wPk0G942N7TAHE/RW2iq/8LPqAYWqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAIZQniiS73D6mwfpnfhVMC4lyYJtRSrmoZpF7yIlUdIDAgQDAgUBBAQAAAAEAgADDAIAAADwPc0dAAAAAA==');
+            (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(1);
+            recoveryTxn.transactions[1].serializedTx.should.equal('AuLhOA5zmOBZR85lo+nKdTopVwJAMrMp6NW+8UnGNsSBSpBkqfWZQqSg9s+7aTlXezm5vxol+Pl6t7PpVNTOHwLcp9xJp3TFHdivEbhwJKldR4Ny+pasoFx+Bgk8q6g1iNiq7XSi1Ov3bs7euMkTj7nDRFqP8lv7xLTcvrBm9OQJAgECBp14ImBCdmVROlw0UveYS1MvG/ljCRI3MJTFmsxuXEoWBRo0vIrNQ4djl2+Wh2EVBQ9zgoVTVm0RHXrIv/6/WHw0hyxvpVwtIx9/zeX2O16eTrY+aKIh1mdKg4MMg0eyxMLVtfT7mpvNii8wPk0G942N7TAHE/RW2iq/8LPqAYWqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAC7ws1XFslinwgtpISUViVWIVTHyD2Q0qj24YjKmrAmXAgQDAgUBBAQAAAAEAgADDAIAAADwPc0dAAAAAA==');
+            (recoveryTxn.transactions[1].scanIndex ?? 0).should.equal(2);
+            (recoveryTxn.lastScanIndex ?? 0).should.equal(20);
+        });
+        it('should recover a txn for non-bitgo recoveries (latest blockhash)', async function () {
+            // Latest Blockhash Recovery (BitGo-less)
+            const latestBlockHashTxn = await basecoin.recover({
+                userKey: testData.keys.userKey,
+                backupKey: testData.keys.backupKey,
+                bitgoKey: testData.keys.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey,
+                walletPassphrase: testData.keys.walletPassword,
+            });
+            latestBlockHashTxn.should.not.be.empty();
+            latestBlockHashTxn.should.hasOwnProperty('serializedTx');
+            latestBlockHashTxn.should.hasOwnProperty('scanIndex');
+            should.equal(latestBlockHashTxn.scanIndex, 0);
+            const latestBlockhashTxnDeserialize = new lib_1.Transaction(coin);
+            latestBlockhashTxnDeserialize.fromRawTransaction(latestBlockHashTxn.serializedTx);
+            const latestBlockhashTxnJson = latestBlockhashTxnDeserialize.toJson();
+            should.equal(latestBlockhashTxnJson.nonce, testData.SolInputData.blockhash);
+            should.equal(latestBlockhashTxnJson.feePayer, testData.accountInfo.bs58EncodedPublicKey);
+            should.equal(latestBlockhashTxnJson.numSignatures, testData.SolInputData.latestBlockhashSignatures);
+            const solCoin = basecoin;
+            sandBox.assert.callCount(solCoin.getDataFromNode, 3);
+        });
+        it('should recover a txn for non-bitgo recoveries (durable nonce)', async function () {
+            // Durable Nonce Recovery (BitGo-less)
+            const durableNonceTxn = await basecoin.recover({
+                userKey: testData.keys.userKey,
+                backupKey: testData.keys.backupKey,
+                bitgoKey: testData.keys.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey,
+                walletPassphrase: testData.keys.walletPassword,
+                durableNonce: {
+                    publicKey: testData.keys.durableNoncePubKey,
+                    secretKey: testData.keys.durableNoncePrivKey,
+                },
+            });
+            durableNonceTxn.should.not.be.empty();
+            durableNonceTxn.should.hasOwnProperty('serializedTx');
+            durableNonceTxn.should.hasOwnProperty('scanIndex');
+            should.equal(durableNonceTxn.scanIndex, 0);
+            const durableNonceTxnDeserialize = new lib_1.Transaction(coin);
+            durableNonceTxnDeserialize.fromRawTransaction(durableNonceTxn.serializedTx);
+            const durableNonceTxnJson = durableNonceTxnDeserialize.toJson();
+            should.equal(durableNonceTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);
+            should.equal(durableNonceTxnJson.feePayer, testData.accountInfo.bs58EncodedPublicKey);
+            should.equal(durableNonceTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);
+            const solCoin = basecoin;
+            sandBox.assert.callCount(solCoin.getDataFromNode, 4);
+        });
+        it('should recover a txn for unsigned sweep recoveries', async function () {
+            // Unsigned Sweep Recovery
+            const unsignedSweepTxn = (await basecoin.recover({
+                bitgoKey: testData.keys.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey,
+                durableNonce: {
+                    publicKey: testData.keys.durableNoncePubKey,
+                    secretKey: testData.keys.durableNoncePrivKey,
+                },
+            }));
+            unsignedSweepTxn.should.not.be.empty();
+            unsignedSweepTxn.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');
+            unsignedSweepTxn.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('scanIndex');
+            should.equal(unsignedSweepTxn.txRequests[0].transactions[0].unsignedTx.scanIndex, 0);
+            const unsignedSweepTxnDeserialize = new lib_1.Transaction(coin);
+            unsignedSweepTxnDeserialize.fromRawTransaction(unsignedSweepTxn.txRequests[0].transactions[0].unsignedTx.serializedTx);
+            const unsignedSweepTxnJson = unsignedSweepTxnDeserialize.toJson();
+            should.equal(unsignedSweepTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);
+            should.equal(unsignedSweepTxnJson.feePayer, testData.accountInfo.bs58EncodedPublicKey);
+            should.equal(unsignedSweepTxnJson.numSignatures, testData.SolInputData.unsignedSweepSignatures);
+            const solCoin = basecoin;
+            sandBox.assert.callCount(solCoin.getDataFromNode, 4);
+        });
+        it('should handle error in recover function if a required field is missing/incorrect', async function () {
+            // missing userkey
+            await basecoin
+                .recover({
+                backupKey: testData.keys.backupKey,
+                bitgoKey: testData.keys.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey,
+                walletPassphrase: testData.keys.walletPassword,
+            })
+                .should.rejectedWith('missing userKey');
+            // missing backupkey
+            await basecoin
+                .recover({
+                userKey: testData.keys.userKey,
+                bitgoKey: testData.keys.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey,
+                walletPassphrase: testData.keys.walletPassword,
+            })
+                .should.rejectedWith('missing backupKey');
+            // incorrect wallet passphrase, user key, backup key combination
+            await basecoin
+                .recover({
+                userKey: testData.keys.userKey,
+                backupKey: testData.keys.backupKey,
+                bitgoKey: testData.keys.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey,
+                walletPassphrase: testData.keys.walletPassword + 'incorrect',
+            })
+                .should.rejectedWith("Error decrypting user keychain: password error - ccm: tag doesn't match");
+            // no wallet with sufficient funds
+            await basecoin
+                .recover({
+                userKey: testData.keys.userKey,
+                backupKey: testData.keys.backupKey,
+                bitgoKey: testData.keys.bitgoKeyNoFunds,
+                recoveryDestination: testData.keys.destinationPubKey,
+                walletPassphrase: testData.keys.walletPassword,
+            })
+                .should.rejectedWith('Did not find address with funds to recover');
+        });
+        it('should recover sol tokens to recovery destination with no existing token accounts', async function () {
+            const tokenTxn = await basecoin.recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey,
+                tokenContractAddress: usdtMintAddress,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                durableNonce: {
+                    publicKey: testData.keys.durableNoncePubKey,
+                    secretKey: testData.keys.durableNoncePrivKey,
+                },
+            });
+            tokenTxn.should.not.be.empty();
+            tokenTxn.should.hasOwnProperty('serializedTx');
+            tokenTxn.should.hasOwnProperty('scanIndex');
+            should.equal(tokenTxn.scanIndex, 0);
+            const tokenTxnDeserialize = new lib_1.Transaction(coin);
+            tokenTxnDeserialize.fromRawTransaction(tokenTxn.serializedTx);
+            const tokenTxnJson = tokenTxnDeserialize.toJson();
+            should.equal(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);
+            should.equal(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);
+            should.equal(tokenTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);
+            const instructionsData = tokenTxnJson.instructionsData;
+            should.equal(instructionsData.length, 3);
+            should.equal(instructionsData[0].type, 'NonceAdvance');
+            const destinationUSDTTokenAccount = await (0, utils_1.getAssociatedTokenAccountAddress)(usdtMintAddress, testData.keys.destinationPubKey);
+            should.equal(instructionsData[1].type, 'CreateAssociatedTokenAccount');
+            should.equal(instructionsData[1].params.mintAddress, usdtMintAddress);
+            should.equal(instructionsData[1].params.ataAddress, destinationUSDTTokenAccount);
+            should.equal(instructionsData[1].params.ownerAddress, testData.keys.destinationPubKey);
+            should.equal(instructionsData[1].params.tokenName, 'tsol:usdt');
+            should.equal(instructionsData[1].params.payerAddress, testData.wrwUser.walletAddress0);
+            const sourceUSDTTokenAccount = await (0, utils_1.getAssociatedTokenAccountAddress)(usdtMintAddress, testData.wrwUser.walletAddress0);
+            should.equal(instructionsData[2].type, 'TokenTransfer');
+            should.equal(instructionsData[2].params.fromAddress, testData.wrwUser.walletAddress0);
+            should.equal(instructionsData[2].params.toAddress, destinationUSDTTokenAccount);
+            should.equal(instructionsData[2].params.amount, '2000000000');
+            should.equal(instructionsData[2].params.tokenName, 'tsol:usdt');
+            should.equal(instructionsData[2].params.sourceAddress, sourceUSDTTokenAccount);
+            const solCoin = basecoin;
+            sandBox.assert.callCount(solCoin.getDataFromNode, 7);
+        });
+        it('should recover sol 2022 tokens to recovery destination with no existing token accounts', async function () {
+            const tokenTxn = await basecoin.recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey,
+                tokenContractAddress: t22mintAddress,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                durableNonce: {
+                    publicKey: testData.keys.durableNoncePubKey,
+                    secretKey: testData.keys.durableNoncePrivKey,
+                },
+                programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+            });
+            tokenTxn.should.not.be.empty();
+            tokenTxn.should.hasOwnProperty('serializedTx');
+            tokenTxn.should.hasOwnProperty('scanIndex');
+            should.equal(tokenTxn.scanIndex, 0);
+            const tokenTxnDeserialize = new lib_1.Transaction(coin);
+            tokenTxnDeserialize.fromRawTransaction(tokenTxn.serializedTx);
+            const tokenTxnJson = tokenTxnDeserialize.toJson();
+            should.equal(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);
+            should.equal(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);
+            should.equal(tokenTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);
+            const instructionsData = tokenTxnJson.instructionsData;
+            should.equal(instructionsData.length, 3);
+            should.equal(instructionsData[0].type, 'NonceAdvance');
+            const destinationTokenAccount = await (0, utils_1.getAssociatedTokenAccountAddress)(t22mintAddress, testData.keys.destinationPubKey);
+            should.equal(instructionsData[1].type, 'CreateAssociatedTokenAccount');
+            should.equal(instructionsData[1].params.mintAddress, t22mintAddress);
+            should.equal(instructionsData[1].params.ataAddress, destinationTokenAccount);
+            should.equal(instructionsData[1].params.ownerAddress, testData.keys.destinationPubKey);
+            should.equal(instructionsData[1].params.tokenName, 'tsol:t22mint');
+            should.equal(instructionsData[1].params.payerAddress, testData.wrwUser.walletAddress0);
+            const sourceTokenAccount = await (0, utils_1.getAssociatedTokenAccountAddress)(t22mintAddress, testData.wrwUser.walletAddress0);
+            should.equal(instructionsData[2].type, 'TokenTransfer');
+            should.equal(instructionsData[2].params.fromAddress, testData.wrwUser.walletAddress0);
+            should.equal(instructionsData[2].params.toAddress, destinationTokenAccount);
+            should.equal(instructionsData[2].params.amount, '2000000000');
+            should.equal(instructionsData[2].params.tokenName, 'tsol:t22mint');
+            should.equal(instructionsData[2].params.sourceAddress, sourceTokenAccount);
+            should.equal(instructionsData[2].params.programId, 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
+            const solCoin = basecoin;
+            sandBox.assert.callCount(solCoin.getDataFromNode, 7);
+        });
+        it('should recover sol tokens to recovery destination with existing token accounts', async function () {
+            const tokenTxn = await basecoin.recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey2,
+                tokenContractAddress: usdtMintAddress,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                durableNonce: {
+                    publicKey: testData.keys.durableNoncePubKey,
+                    secretKey: testData.keys.durableNoncePrivKey,
+                },
+            });
+            tokenTxn.should.not.be.empty();
+            tokenTxn.should.hasOwnProperty('serializedTx');
+            tokenTxn.should.hasOwnProperty('scanIndex');
+            should.equal(tokenTxn.scanIndex, 0);
+            const tokenTxnDeserialize = new lib_1.Transaction(coin);
+            tokenTxnDeserialize.fromRawTransaction(tokenTxn.serializedTx);
+            const tokenTxnJson = tokenTxnDeserialize.toJson();
+            should.equal(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);
+            should.equal(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);
+            should.equal(tokenTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);
+            const instructionsData = tokenTxnJson.instructionsData;
+            should.equal(instructionsData.length, 2);
+            should.equal(instructionsData[0].type, 'NonceAdvance');
+            const sourceUSDTTokenAccount = await (0, utils_1.getAssociatedTokenAccountAddress)(usdtMintAddress, testData.wrwUser.walletAddress0);
+            const destinationUSDTTokenAccount = await (0, utils_1.getAssociatedTokenAccountAddress)(usdtMintAddress, testData.keys.destinationPubKey2);
+            should.equal(instructionsData[1].type, 'TokenTransfer');
+            should.equal(instructionsData[1].params.fromAddress, testData.wrwUser.walletAddress0);
+            should.equal(instructionsData[1].params.toAddress, destinationUSDTTokenAccount);
+            should.equal(instructionsData[1].params.amount, '2000000000');
+            should.equal(instructionsData[1].params.tokenName, 'tsol:usdt');
+            should.equal(instructionsData[1].params.sourceAddress, sourceUSDTTokenAccount);
+            const solCoin = basecoin;
+            sandBox.assert.callCount(solCoin.getDataFromNode, 7);
+        });
+        it('should recover sol 2022 tokens to recovery destination with existing token accounts', async function () {
+            const tokenTxn = await basecoin.recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey2,
+                tokenContractAddress: t22mintAddress,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                durableNonce: {
+                    publicKey: testData.keys.durableNoncePubKey,
+                    secretKey: testData.keys.durableNoncePrivKey,
+                },
+                programId: spl_token_1.TOKEN_2022_PROGRAM_ID.toString(),
+            });
+            tokenTxn.should.not.be.empty();
+            tokenTxn.should.hasOwnProperty('serializedTx');
+            tokenTxn.should.hasOwnProperty('scanIndex');
+            should.equal(tokenTxn.scanIndex, 0);
+            const tokenTxnDeserialize = new lib_1.Transaction(coin);
+            tokenTxnDeserialize.fromRawTransaction(tokenTxn.serializedTx);
+            const tokenTxnJson = tokenTxnDeserialize.toJson();
+            console.log(tokenTxnJson);
+            should.equal(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);
+            should.equal(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);
+            should.equal(tokenTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);
+            const instructionsData = tokenTxnJson.instructionsData;
+            should.equal(instructionsData.length, 2);
+            should.equal(instructionsData[0].type, 'NonceAdvance');
+            const source2022TokenAccount = await (0, utils_1.getAssociatedTokenAccountAddress)(t22mintAddress, testData.wrwUser.walletAddress0, false, spl_token_1.TOKEN_2022_PROGRAM_ID.toString());
+            const destination2022TokenAccount = await (0, utils_1.getAssociatedTokenAccountAddress)(t22mintAddress, testData.keys.destinationPubKey2, false, spl_token_1.TOKEN_2022_PROGRAM_ID.toString());
+            should.equal(instructionsData[1].type, 'TokenTransfer');
+            should.equal(instructionsData[1].params.fromAddress, testData.wrwUser.walletAddress0);
+            should.equal(instructionsData[1].params.toAddress, destination2022TokenAccount);
+            should.equal(instructionsData[1].params.amount, '2000000000');
+            should.equal(instructionsData[1].params.tokenName, 'tsol:t22mint');
+            should.equal(instructionsData[1].params.sourceAddress, source2022TokenAccount);
+            const solCoin = basecoin;
+            sandBox.assert.callCount(solCoin.getDataFromNode, 7);
+        });
+        it('should recover sol tokens to recovery destination with existing token accounts for unsigned sweep recoveries', async function () {
+            const feeResponse = testData.SolResponses.getFeesForMessageResponse;
+            feeResponse.body.result.value = 10000;
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getFeeForMessage',
+                    params: [
+                        sinon.match.string,
+                        {
+                            commitment: 'finalized',
+                        },
+                    ],
+                },
+            })
+                .resolves(feeResponse);
+            const tokenTxn = (await basecoin.recover({
+                bitgoKey: testData.wrwUser.bitgoKey,
+                recoveryDestination: testData.keys.destinationPubKey2,
+                durableNonce: {
+                    publicKey: testData.keys.durableNoncePubKey,
+                    secretKey: testData.keys.durableNoncePrivKey,
+                },
+                tokenContractAddress: testData.tokenAddress.TestUSDC,
+            }));
+            // 2 signatures and no rent exemption fee since the destination already has token accounts
+            const expectedFee = 5000 + 5000;
+            const { serializedTx, scanIndex, feeInfo, parsedTx } = tokenTxn.txRequests[0].transactions[0].unsignedTx;
+            assert_1.default.ok(serializedTx);
+            assert_1.default.strictEqual(scanIndex, 0);
+            assert_1.default.ok(feeInfo);
+            assert_1.default.strictEqual(feeInfo.feeString, expectedFee.toString());
+            assert_1.default.strictEqual(feeInfo.fee, expectedFee);
+            assert_1.default.ok(parsedTx);
+            assert_1.default.ok(parsedTx.inputs instanceof Array && parsedTx.inputs.length === 1);
+            assert_1.default.ok(parsedTx.outputs instanceof Array && parsedTx.outputs.length === 1);
+            const tokenTxnDeserialize = new lib_1.Transaction(coin);
+            tokenTxnDeserialize.fromRawTransaction(tokenTxn.txRequests[0].transactions[0].unsignedTx.serializedTx);
+            const tokenTxnJson = tokenTxnDeserialize.toJson();
+            assert_1.default.strictEqual(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);
+            assert_1.default.strictEqual(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);
+            assert_1.default.strictEqual(tokenTxnJson.numSignatures, testData.SolInputData.unsignedSweepSignatures);
+            const solCoin = basecoin;
+            sandBox.assert.callCount(solCoin.getDataFromNode, 7);
+        });
+        it('should recover sol funds from ATA address for non-bitgo recoveries', async function () {
+            // close ATA address instruction type txn
+            const closeATATxns = await basecoin.recoverCloseATA({
+                userKey: testData.closeATAkeys.userKey,
+                backupKey: testData.closeATAkeys.backupKey,
+                bitgoKey: testData.closeATAkeys.bitgoKey,
+                recoveryDestination: testData.closeATAkeys.destinationPubKey,
+                walletPassphrase: testData.closeATAkeys.walletPassword,
+                closeAtaAddress: testData.closeATAkeys.closeAtaAddress,
+                recoveryDestinationAtaAddress: testData.closeATAkeys.recoveryDestinationAtaAddress,
+            });
+            closeATATxns.should.not.be.empty();
+            should.equal(closeATATxns[0].txId, '2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb');
+            should.equal(closeATATxns[1].txId, '5oUBgXX4enGmFEspG64goy3PRysjfrekZGg3rZNkBHUCQFd482vrVWbfDcRYMBEJt65JXymfEPm8M6d89X4xV79n');
+        });
+        it('should recover tokens from a nested ATA (ATA whose owner is another ATA)', async function () {
+            const result = await basecoin.recoverNestedAta({
+                userKey: testData.closeATAkeys.userKey,
+                backupKey: testData.closeATAkeys.backupKey,
+                bitgoKey: testData.closeATAkeys.bitgoKey,
+                recoveryDestination: testData.closeATAkeys.destinationPubKey,
+                walletPassphrase: testData.closeATAkeys.walletPassword,
+                nestedAtaAddress: 'FGuZSBhtreqSUsE86xokyjKz2i8VBtJzy6uMXXKyGHug',
+                ownerAtaAddress: 'Zfm98ZpVafydhFTYcsY6bHgubhB4cFgWFvbdEJxYhTA',
+                tokenMintAddress: 'ZBCNpuD7YMXzTHB2fhGkGi78MNsHGLRXUhRewNRm9RU',
+            });
+            result.should.not.be.empty();
+            should.equal(result.txId, '2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb');
+        });
+        it('should throw when nestedAtaAddress is missing for recoverNestedAta', async function () {
+            await basecoin
+                .recoverNestedAta({
+                userKey: testData.closeATAkeys.userKey,
+                backupKey: testData.closeATAkeys.backupKey,
+                bitgoKey: testData.closeATAkeys.bitgoKey,
+                recoveryDestination: testData.closeATAkeys.destinationPubKey,
+                walletPassphrase: testData.closeATAkeys.walletPassword,
+                ownerAtaAddress: 'Zfm98ZpVafydhFTYcsY6bHgubhB4cFgWFvbdEJxYhTA',
+                tokenMintAddress: 'ZBCNpuD7YMXzTHB2fhGkGi78MNsHGLRXUhRewNRm9RU',
+            })
+                .should.be.rejectedWith('invalid nestedAtaAddress');
+        });
+        it('should throw when ownerAtaAddress is missing for recoverNestedAta', async function () {
+            await basecoin
+                .recoverNestedAta({
+                userKey: testData.closeATAkeys.userKey,
+                backupKey: testData.closeATAkeys.backupKey,
+                bitgoKey: testData.closeATAkeys.bitgoKey,
+                recoveryDestination: testData.closeATAkeys.destinationPubKey,
+                walletPassphrase: testData.closeATAkeys.walletPassword,
+                nestedAtaAddress: 'FGuZSBhtreqSUsE86xokyjKz2i8VBtJzy6uMXXKyGHug',
+                tokenMintAddress: 'ZBCNpuD7YMXzTHB2fhGkGi78MNsHGLRXUhRewNRm9RU',
+            })
+                .should.be.rejectedWith('invalid ownerAtaAddress');
+        });
+        it('should throw when tokenMintAddress is missing for recoverNestedAta', async function () {
+            await basecoin
+                .recoverNestedAta({
+                userKey: testData.closeATAkeys.userKey,
+                backupKey: testData.closeATAkeys.backupKey,
+                bitgoKey: testData.closeATAkeys.bitgoKey,
+                recoveryDestination: testData.closeATAkeys.destinationPubKey,
+                walletPassphrase: testData.closeATAkeys.walletPassword,
+                nestedAtaAddress: 'FGuZSBhtreqSUsE86xokyjKz2i8VBtJzy6uMXXKyGHug',
+                ownerAtaAddress: 'Zfm98ZpVafydhFTYcsY6bHgubhB4cFgWFvbdEJxYhTA',
+            })
+                .should.be.rejectedWith('invalid tokenMintAddress');
+        });
+    });
+    describe('Build Consolidation Recoveries:', () => {
+        const sandBox = sinon.createSandbox();
+        const coin = statics_1.coins.get('tsol');
+        const usdtMintAddress = '9cgpBeNZ2HnLda7NWaaU1i3NyTstk2c4zCMUcoAGsi9C';
+        const durableNonces = {
+            publicKeys: [
+                testData.keys.durableNoncePubKey,
+                testData.keys.durableNoncePubKey2,
+                testData.keys.durableNoncePubKey3,
+            ],
+            secretKey: testData.keys.durableNoncePrivKey,
+        };
+        beforeEach(() => {
+            const callBack = sandBox.stub(src_1.Sol.prototype, 'getDataFromNode');
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getLatestBlockhash',
+                    params: [
+                        {
+                            commitment: 'finalized',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getBlockhashResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getFeeForMessage',
+                    params: [
+                        sinon.match.string,
+                        {
+                            commitment: 'finalized',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getFeesForMessageResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.wrwUser.walletAddress1],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponseNoFunds);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.wrwUser.walletAddress2],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.wrwUser.walletAddress3],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getBalance',
+                    params: [testData.wrwUser.walletAddress5],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountBalanceResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getMinimumBalanceForRentExemption',
+                    params: [165],
+                },
+            })
+                .resolves(testData.SolResponses.getMinimumBalanceForRentExemptionResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getAccountInfo',
+                    params: [
+                        testData.keys.durableNoncePubKey,
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountInfoResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getAccountInfo',
+                    params: [
+                        testData.keys.durableNoncePubKey2,
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getAccountInfoResponse2);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.wrwUser.walletAddress1,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.wrwUser.walletAddress2,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.wrwUser.walletAddress3,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.wrwUser.walletAddress5,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse);
+            callBack
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getTokenAccountsByOwner',
+                    params: [
+                        testData.wrwUser.walletAddress0,
+                        {
+                            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+                        },
+                        {
+                            encoding: 'jsonParsed',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse);
+        });
+        afterEach(() => {
+            sandBox.restore();
+        });
+        it('should build signed consolidation recoveries', async function () {
+            const res = (await basecoin.recoverConsolidations({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+                durableNonces: durableNonces,
+            }));
+            res.should.not.be.empty();
+            res.transactions.length.should.equal(2);
+            (res.lastScanIndex ?? 0).should.equal(3);
+            const txn1 = res.transactions[0];
+            const latestBlockhashTxnDeserialize1 = new lib_1.Transaction(coin);
+            latestBlockhashTxnDeserialize1.fromRawTransaction(txn1.serializedTx);
+            const latestBlockhashTxnJson1 = latestBlockhashTxnDeserialize1.toJson();
+            const nonce1 = testData.SolResponses.getAccountInfoResponse.body.result.value.data.parsed.info.blockhash;
+            should.equal(latestBlockhashTxnJson1.nonce, nonce1);
+            should.equal(latestBlockhashTxnJson1.feePayer, testData.wrwUser.walletAddress2);
+            should.equal(latestBlockhashTxnJson1.numSignatures, testData.SolInputData.durableNonceSignatures);
+            const txn2 = res.transactions[1];
+            const latestBlockhashTxnDeserialize2 = new lib_1.Transaction(coin);
+            latestBlockhashTxnDeserialize2.fromRawTransaction(txn2.serializedTx);
+            const latestBlockhashTxnJson2 = latestBlockhashTxnDeserialize2.toJson();
+            const nonce2 = testData.SolResponses.getAccountInfoResponse2.body.result.value.data.parsed.info.blockhash;
+            should.equal(latestBlockhashTxnJson2.nonce, nonce2);
+            should.equal(latestBlockhashTxnJson2.feePayer, testData.wrwUser.walletAddress3);
+            should.equal(latestBlockhashTxnJson2.numSignatures, testData.SolInputData.durableNonceSignatures);
+        });
+        it('should build unsigned consolidation recoveries', async function () {
+            const res = (await basecoin.recoverConsolidations({
+                bitgoKey: testData.wrwUser.bitgoKey,
+                startingScanIndex: 1,
+                endingScanIndex: 4,
+                durableNonces: durableNonces,
+            }));
+            res.should.not.be.empty();
+            res.txRequests.length.should.equal(2);
+            const txn1 = res.txRequests[0].transactions[0].unsignedTx;
+            txn1.should.hasOwnProperty('serializedTx');
+            txn1.should.hasOwnProperty('signableHex');
+            txn1.should.hasOwnProperty('scanIndex');
+            (txn1.scanIndex ?? 0).should.equal(2);
+            txn1.should.hasOwnProperty('coin');
+            txn1.coin?.should.equal('tsol');
+            txn1.should.hasOwnProperty('derivationPath');
+            txn1.derivationPath?.should.equal('m/2');
+            txn1.should.hasOwnProperty('coinSpecific');
+            const coinSpecific1 = txn1.coinSpecific;
+            coinSpecific1?.should.hasOwnProperty('commonKeychain');
+            const latestBlockhashTxnDeserialize1 = new lib_1.Transaction(coin);
+            latestBlockhashTxnDeserialize1.fromRawTransaction(txn1.serializedTx);
+            const latestBlockhashTxnJson1 = latestBlockhashTxnDeserialize1.toJson();
+            const nonce1 = testData.SolResponses.getAccountInfoResponse.body.result.value.data.parsed.info.blockhash;
+            should.equal(latestBlockhashTxnJson1.nonce, nonce1);
+            should.equal(latestBlockhashTxnJson1.feePayer, testData.wrwUser.walletAddress2);
+            should.equal(latestBlockhashTxnJson1.numSignatures, testData.SolInputData.unsignedSweepSignatures);
+            const txn2 = res.txRequests[1].transactions[0].unsignedTx;
+            txn2.should.hasOwnProperty('serializedTx');
+            txn2.should.hasOwnProperty('signableHex');
+            txn2.should.hasOwnProperty('scanIndex');
+            (txn2.scanIndex ?? 0).should.equal(3);
+            txn2.should.hasOwnProperty('coin');
+            txn2.coin?.should.equal('tsol');
+            txn2.should.hasOwnProperty('derivationPath');
+            txn2.derivationPath?.should.equal('m/3');
+            txn2.should.hasOwnProperty('coinSpecific');
+            const coinSpecific2 = txn2.coinSpecific;
+            coinSpecific2?.should.hasOwnProperty('commonKeychain');
+            coinSpecific2?.should.hasOwnProperty('lastScanIndex');
+            coinSpecific2?.lastScanIndex?.should.equal(3);
+            const latestBlockhashTxnDeserialize2 = new lib_1.Transaction(coin);
+            latestBlockhashTxnDeserialize2.fromRawTransaction(txn2.serializedTx);
+            const latestBlockhashTxnJson2 = latestBlockhashTxnDeserialize2.toJson();
+            const nonce2 = testData.SolResponses.getAccountInfoResponse2.body.result.value.data.parsed.info.blockhash;
+            should.equal(latestBlockhashTxnJson2.nonce, nonce2);
+            should.equal(latestBlockhashTxnJson2.feePayer, testData.wrwUser.walletAddress3);
+            should.equal(latestBlockhashTxnJson2.numSignatures, testData.SolInputData.unsignedSweepSignatures);
+        });
+        it('should build unsigned token consolidation recoveries', async function () {
+            const res = (await basecoin.recoverConsolidations({
+                bitgoKey: testData.wrwUser.bitgoKey,
+                startingScanIndex: 3,
+                endingScanIndex: 5,
+                tokenContractAddress: usdtMintAddress,
+                durableNonces: durableNonces,
+            }));
+            res.should.not.be.empty();
+            res.txRequests.length.should.equal(1);
+            const txn1 = res.txRequests[0].transactions[0].unsignedTx;
+            txn1.should.hasOwnProperty('serializedTx');
+            txn1.should.hasOwnProperty('signableHex');
+            txn1.should.hasOwnProperty('scanIndex');
+            (txn1.scanIndex ?? 0).should.equal(4);
+            txn1.should.hasOwnProperty('coin');
+            txn1.coin?.should.equal('tsol');
+            txn1.should.hasOwnProperty('derivationPath');
+            txn1.derivationPath?.should.equal('m/4');
+            txn1.should.hasOwnProperty('coinSpecific');
+            const coinSpecific1 = txn1.coinSpecific;
+            coinSpecific1?.should.hasOwnProperty('commonKeychain');
+            const latestBlockhashTxnDeserialize1 = new lib_1.Transaction(coin);
+            latestBlockhashTxnDeserialize1.fromRawTransaction(txn1.serializedTx);
+            const latestBlockhashTxnJson1 = latestBlockhashTxnDeserialize1.toJson();
+            const nonce1 = testData.SolResponses.getAccountInfoResponse.body.result.value.data.parsed.info.blockhash;
+            should.equal(latestBlockhashTxnJson1.nonce, nonce1);
+            should.equal(latestBlockhashTxnJson1.feePayer, testData.wrwUser.walletAddress5);
+            should.equal(latestBlockhashTxnJson1.numSignatures, testData.SolInputData.unsignedSweepSignatures);
+        });
+        it('should skip building consolidate transaction if balance is equal to zero', async function () {
+            await basecoin
+                .recoverConsolidations({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                startingScanIndex: 1,
+                endingScanIndex: 2,
+                durableNonces: durableNonces,
+            })
+                .should.rejectedWith('Did not find an address with funds to recover');
+        });
+        it('should throw if startingScanIndex is not ge to 1', async () => {
+            await basecoin
+                .recoverConsolidations({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                startingScanIndex: -1,
+                durableNonces: durableNonces,
+            })
+                .should.be.rejectedWith('Invalid starting or ending index to scan for addresses. startingScanIndex: -1, endingScanIndex: 19.');
+        });
+        it('should throw if scan factor is too high', async () => {
+            await basecoin
+                .recoverConsolidations({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                startingScanIndex: 1,
+                endingScanIndex: 300,
+                durableNonces: durableNonces,
+            })
+                .should.be.rejectedWith('Invalid starting or ending index to scan for addresses. startingScanIndex: 1, endingScanIndex: 300.');
+        });
+    });
+    describe('broadcastTransaction', function () {
+        const sandBox = sinon.createSandbox();
+        afterEach(() => {
+            sandBox.restore();
+        });
+        it('should broadcast a transaction succesfully', async function () {
+            const serializedSignedTransaction = testData.rawTransactions.transfer.signed;
+            const broadcastStub = sandBox
+                .stub(src_1.Sol.prototype, 'getDataFromNode')
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'sendTransaction',
+                    params: [
+                        serializedSignedTransaction,
+                        {
+                            encoding: 'base64',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.broadcastTransactionResponse);
+            const broadcastTxn = await basecoin.broadcastTransaction({ serializedSignedTransaction });
+            assert_1.default.ok(broadcastTxn);
+            assert_1.default.ok(broadcastTxn.txId);
+            assert_1.default.strictEqual(broadcastTxn.txId, '2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb');
+            assert_1.default.strictEqual(broadcastStub.callCount, 1);
+        });
+        it('should throw if got an error from the node', async function () {
+            const serializedSignedTransaction = testData.rawTransactions.transfer.signed;
+            const broadcastStub = sandBox
+                .stub(src_1.Sol.prototype, 'getDataFromNode')
+                .withArgs({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'sendTransaction',
+                    params: [
+                        serializedSignedTransaction,
+                        {
+                            encoding: 'base64',
+                        },
+                    ],
+                },
+            })
+                .resolves(testData.SolResponses.broadcastTransactionResponseError);
+            await assert_1.default.rejects(async () => {
+                await basecoin.broadcastTransaction({ serializedSignedTransaction });
+            }, { message: 'Error broadcasting transaction: Transaction simulation failed: Blockhash not found' });
+            assert_1.default.strictEqual(broadcastStub.callCount, 1);
+        });
+        it('should throw if is not a valid transaction', async function () {
+            const serializedSignedTransaction = 'randomstring';
+            await assert_1.default.rejects(async () => {
+                await basecoin.broadcastTransaction({ serializedSignedTransaction });
+            }, { message: 'Invalid raw transaction' });
+        });
+        it('should throw if is not a signed transaction', async function () {
+            const serializedSignedTransaction = testData.rawTransactions.transfer.unsigned;
+            await assert_1.default.rejects(async () => {
+                await basecoin.broadcastTransaction({ serializedSignedTransaction });
+            }, { message: 'Invalid raw transaction' });
+        });
+    });
+    describe('AuditKey', () => {
+        const { key: keyString, commonKeychain } = solBackupKey_1.solBackupKey;
+        const key = keyString.replace(/\s/g, '');
+        const walletPassphrase = 'kAm[EFQ6o=SxlcLFDw%,';
+        const multiSigType = 'tss';
+        it('should return for valid inputs', () => {
+            basecoin.assertIsValidKey({
+                encryptedPrv: key,
+                publicKey: commonKeychain,
+                walletPassphrase,
+                multiSigType,
+            });
+        });
+        it('should throw error if the commonKeychain is invalid', () => {
+            const alteredCommonKeychain = (0, sdk_core_1.generateRandomPassword)(10);
+            assert_1.default.throws(() => basecoin.assertIsValidKey({
+                encryptedPrv: key,
+                publicKey: alteredCommonKeychain,
+                walletPassphrase,
+                multiSigType,
+            }), {
+                message: 'Invalid common keychain',
+            });
+        });
+        it('should throw error if the walletPassphrase is incorrect', () => {
+            const incorrectPassphrase = 'foo';
+            assert_1.default.throws(() => basecoin.assertIsValidKey({
+                encryptedPrv: key,
+                publicKey: commonKeychain,
+                walletPassphrase: incorrectPassphrase,
+                multiSigType,
+            }), {
+                message: "failed to decrypt prv: ccm: tag doesn't match",
+            });
+        });
+        it('should throw error if the key is altered', () => {
+            const alteredKey = key.replace(/[0-9]/g, '0');
+            assert_1.default.throws(() => basecoin.assertIsValidKey({
+                encryptedPrv: alteredKey,
+                publicKey: commonKeychain,
+                walletPassphrase,
+                multiSigType,
+            }), {
+                message: 'failed to decrypt prv: json decrypt: invalid parameters',
+            });
+        });
+        it('should verify consolidation transaction', async function () {
+            // Set up wallet data
+            const walletData = {
+                id: '5b34252f1bf349930e34020a00000000',
+                coin: 'tsol',
+                keys: [
+                    '5b3424f91bf349930e34017500000000',
+                    '5b3424f91bf349930e34017600000000',
+                    '5b3424f91bf349930e34017700000000',
+                ],
+                coinSpecific: {
+                    rootAddress: wallet.pub,
+                },
+                multisigType: 'tss',
+            };
+            const fakePrv = (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/tsol/key/5b3424f91bf349930e34017500000000')
+                .reply(200, [
+                {
+                    encryptedPrv: fakePrv,
+                },
+            ]);
+            // Mock the API response for buildAccountConsolidations
+            (0, nock_1.default)(bgUrl)
+                .post('/api/v2/tsol/wallet/5b34252f1bf349930e34020a00000000/consolidateAccount/build')
+                .reply(200, [
+                {
+                    txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',
+                    walletId: '63068ed4efa63a000877f02fd4b0fa6d',
+                    txHex: '02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006f50130abf8d0d8943c5b9a51a574886a7d7b3d8db18f0ddb4ab8b6d3ec27e3c2f36f3339bb92d4296af6ae4d3abfbb07877f77d0033c883de08fa4a2eea670d0201020674a9df2b94aa4b4ada1202dc2891be366501d0acb4a01ca3e02e7fd6c1f505a71c96172044f1217c3784e8f02f49e2c8fc3591e81294ab54394f9d22fd7b7a8f8401c3f67cfa52518b34a09b08f4ea77e1c4fb9d89bfaccdc33cf8b8a9cf8d7bf0e04c89c50428e4eda5cbb759427c370f0a29a50bb0d1407e57924b0cc5b36f000000000000000000000000000000000000000000000000000000000000000006a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea940000040c9568195d67eb6b396fdbe97ba2e276622ef0023af09f23e6e0292abb678d90204030305010404000000040200020c020000000100000000000000',
+                    feeInfo: {
+                        fee: 10000,
+                        feeString: '10000',
+                    },
+                    txInfo: {
+                        minerFee: '10000',
+                        spendAmount: '1547864',
+                        spendAmounts: [
+                            {
+                                coinName: 'tsol',
+                                amountString: '1547864',
+                            },
+                        ],
+                        payGoFee: '0',
+                        outputs: [
+                            {
+                                address: '8rQXeVEMrKvtWCEJirEM6cKYnbZuTqVTbqRPiMMAJ8R4',
+                                value: 1547864,
+                                wallet: '63068ed4efa63a000877f02f',
+                                wallets: ['63068ed4efa63a000877f02f'],
+                                enterprise: '62d71a6b86068f0008f029fd',
+                                enterprises: ['62d71a6b86068f0008f029fd'],
+                                valueString: '1547864',
+                                coinName: 'tsol',
+                                walletType: 'hot',
+                                walletTypes: ['hot'],
+                            },
+                        ],
+                        inputs: [
+                            {
+                                value: 1547864,
+                                address: 'CmYsN3f8bcm4BDkFJWNsvYgjRxMTLH6vbJWNfYdmH7GU',
+                                valueString: '1547864',
+                            },
+                            {
+                                value: 10000,
+                                address: 'CmYsN3f8bcm4BDkFJWNsvYgjRxMTLH6vbJWNfYdmH7GU',
+                                valueString: '10000',
+                            },
+                        ],
+                        type: 'Send',
+                    },
+                    consolidateId: '68a7d5d0c66e74e216b97173bd558c6d',
+                    coin: 'tsol',
+                },
+            ]);
+            // 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',
+            });
+        });
+        it('should verify valid a consolidation transaction', async () => {
+            const consolidationTx = {
+                txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',
+                walletId: '63068ed4efa63a000877f02fd4b0fa6d',
+                txHex: '02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002010206aeda253a331de489838246df93879440af8c62ac4967658edc2bb5d52b9759d91c96172044f1217c3784e8f02f49e2c8fc3591e81294ab54394f9d22fd7b7a8f74a9df2b94aa4b4ada1202dc2891be366501d0acb4a01ca3e02e7fd6c1f505a7d2734f3952f3eb4aefcf6c7a6092e979dd3fe5563ccfaca1cc92652a15ddd393000000000000000000000000000000000000000000000000000000000000000006a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea9400000428dad41bbedeb38018379e4ceeb7e80757d74dd00ae8c47c38d597477339ad80204030305010404000000040200020c02000000589e170000000000',
+                feeInfo: {
+                    fee: 10000,
+                    feeString: '10000',
+                },
+                txInfo: {
+                    minerFee: '10000',
+                    spendAmount: '1547864',
+                    spendAmounts: [
+                        {
+                            coinName: 'tsol',
+                            amountString: '1547864',
+                        },
+                    ],
+                    payGoFee: '0',
+                    outputs: [
+                        {
+                            address: '8rQXeVEMrKvtWCEJirEM6cKYnbZuTqVTbqRPiMMAJ8R4',
+                            value: 1547864,
+                            wallet: '63068ed4efa63a000877f02f',
+                            wallets: ['63068ed4efa63a000877f02f'],
+                            enterprise: '62d71a6b86068f0008f029fd',
+                            enterprises: ['62d71a6b86068f0008f029fd'],
+                            valueString: '1547864',
+                            coinName: 'tsol',
+                            walletType: 'hot',
+                            walletTypes: ['hot'],
+                        },
+                    ],
+                    inputs: [
+                        {
+                            value: 1547864,
+                            address: 'CmYsN3f8bcm4BDkFJWNsvYgjRxMTLH6vbJWNfYdmH7GU',
+                            valueString: '1547864',
+                        },
+                        {
+                            value: 10000,
+                            address: 'CmYsN3f8bcm4BDkFJWNsvYgjRxMTLH6vbJWNfYdmH7GU',
+                            valueString: '10000',
+                        },
+                    ],
+                    type: 'Send',
+                },
+                consolidateId: '68a7d5d0c66e74e216b97173bd558c6d',
+                coin: 'tsol',
+            };
+            const mockedWallet = {
+                coinSpecific: () => {
+                    const cs = {
+                        rootAddress: '8rQXeVEMrKvtWCEJirEM6cKYnbZuTqVTbqRPiMMAJ8R4',
+                    };
+                    return cs;
+                },
+            };
+            try {
+                if (!(await basecoin.verifyTransaction({
+                    blockhash: '',
+                    feePayer: '',
+                    txParams: {},
+                    txPrebuild: consolidationTx,
+                    walletType: 'tss',
+                    wallet: mockedWallet,
+                    verification: {
+                        consolidationToBaseAddress: true,
+                    },
+                }))) {
+                    assert_1.default.fail('Transaction should pass verification');
+                }
+            }
+            catch (e) {
+                assert_1.default.fail('Transaction should pass verification');
+            }
+        });
+        it('should verify a token consolidation transaction', async () => {
+            const consolidationTx = {
+                txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',
+                walletId: '63068ed4efa63a000877f02fd4b0fa6d',
+                txHex: '02b7c2c7829eded4e8f947c90ed3b9afce71f616eb47dfcfbf4b765778149060013acb33b9f67fdd9c2512f48fac4e4c049eab93829b69404f3bd166fe3242c90700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020104096da690bd558fd8634ac14f1645d8095afd0caea5953578c596e3c0dea38305ee7298bfac55101f177735659d42ed6be890ef3a1d204d9e33f32e24c5635327ca66d1fe00826e5a4f759f87b279c1aee19cce5301af4ed66ae17db48b201ed6c2a0e8a28bf565627f1ab8a34b1a95ee1b0a2a39084f1f0e2acb1c394b20185d8e0b22657c8d9c4ce5f6495efb6410c199011530f90e3ab9d8d1e4206f9ae0ffeb0000000000000000000000000000000000000000000000000000000000000000c5f9fb32f49111ab20c33f2598fc836c113e291881ac21ee29169394011244e406a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea940000006ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9de13c74d2b4d948e1608ea6eebdafe75bc2f995aad11b21d1e2c94f2a2d12f6802050303070004040000000804020604010a0ce0076bb20400000006',
+                feeInfo: {
+                    fee: 10000,
+                    feeString: '10000',
+                },
+                txInfo: {
+                    inputs: [
+                        {
+                            address: '8iLa26KSbdpBUzNK7uYq8FvyuyA5h4k4erDHsDcPbHus',
+                            value: 2.0173228e10,
+                            valueString: '20173228000',
+                        },
+                        {
+                            address: '8P2kX7Tyh9eS3RKdaBhqbEtQGAX58DXzL7mhDQABGX2d',
+                            value: 10000,
+                            valueString: '10000',
+                        },
+                    ],
+                    minerFee: '10000',
+                    outputs: [
+                        {
+                            address: 'HBxZShcE86UMmF93KUM8eWJKqeEXi5cqWCLYLMMhqMYm',
+                            coinName: 'sol:wif',
+                            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: 'sol:wif',
+                        },
+                    ],
+                    type: 'Send',
+                },
+                consolidateId: '6712d7fda6de4906d658c04aebbf8f9b',
+                coin: 'tsol',
+            };
+            const mockedWallet = {
+                coinSpecific: () => {
+                    const cs = {
+                        rootAddress: 'HBxZShcE86UMmF93KUM8eWJKqeEXi5cqWCLYLMMhqMYm',
+                    };
+                    return cs;
+                },
+            };
+            try {
+                if (!(await basecoin.verifyTransaction({
+                    blockhash: '',
+                    feePayer: '',
+                    txParams: {},
+                    txPrebuild: consolidationTx,
+                    walletType: 'tss',
+                    wallet: mockedWallet,
+                    verification: {
+                        consolidationToBaseAddress: true,
+                    },
+                }))) {
+                    assert_1.default.fail('Transaction should pass verification');
+                }
+            }
+            catch (e) {
+                assert_1.default.fail('Transaction should pass verification');
+            }
+        });
+        it('should verify a spoofed token consolidation transaction', async () => {
+            const consolidationTx = {
+                txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',
+                walletId: '63068ed4efa63a000877f02fd4b0fa6d',
+                txHex: '02b7c2c7829eded4e8f947c90ed3b9afce71f616eb47dfcfbf4b765778149060013acb33b9f67fdd9c2512f48fac4e4c049eab93829b69404f3bd166fe3242c90700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020104096da690bd558fd8634ac14f1645d8095afd0caea5953578c596e3c0dea38305ee7298bfac55101f177735659d42ed6be890ef3a1d204d9e33f32e24c5635327ca66d1fe00826e5a4f759f87b279c1aee19cce5301af4ed66ae17db48b201ed6c2a0e8a28bf565627f1ab8a34b1a95ee1b0a2a39084f1f0e2acb1c394b20185d8e0b22657c8d9c4ce5f6495efb6410c199011530f90e3ab9d8d1e4206f9ae0ffeb0000000000000000000000000000000000000000000000000000000000000000c5f9fb32f49111ab20c33f2598fc836c113e291881ac21ee29169394011244e406a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea940000006ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9de13c74d2b4d948e1608ea6eebdafe75bc2f995aad11b21d1e2c94f2a2d12f6802050303070004040000000804020604010a0ce0076bb20400000006',
+                feeInfo: {
+                    fee: 10000,
+                    feeString: '10000',
+                },
+                txInfo: {
+                    inputs: [
+                        {
+                            address: '8iLa26KSbdpBUzNK7uYq8FvyuyA5h4k4erDHsDcPbHus',
+                            value: 2.0173228e10,
+                            valueString: '20173228000',
+                        },
+                        {
+                            address: '8P2kX7Tyh9eS3RKdaBhqbEtQGAX58DXzL7mhDQABGX2d',
+                            value: 10000,
+                            valueString: '10000',
+                        },
+                    ],
+                    minerFee: '10000',
+                    outputs: [
+                        {
+                            address: 'HBxZShcE86UMmF93KUM8eWJKqeEXi5cqWCLYLMMhqMYm',
+                            coinName: 'sol:wif',
+                            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: 'sol:wif',
+                        },
+                    ],
+                    type: 'Send',
+                },
+                consolidateId: '6712d7fda6de4906d658c04aebbf8f9b',
+                coin: 'tsol',
+            };
+            const mockedWallet = {
+                coinSpecific: () => {
+                    const cs = {
+                        rootAddress: '8rQXeVEMrKvtWCEJirEM6cKYnbZuTqVTbqRPiMMAJ8R4',
+                    };
+                    return cs;
+                },
+            };
+            await assert_1.default.rejects(async () => basecoin.verifyTransaction({
+                blockhash: '',
+                feePayer: '',
+                txParams: {},
+                txPrebuild: consolidationTx,
+                walletType: 'tss',
+                wallet: mockedWallet,
+                verification: {
+                    consolidationToBaseAddress: true,
+                },
+            }), {
+                message: 'tx outputs does not match with expected address',
+            });
+        });
+    });
+    describe('blind signing token enablement protection', () => {
+        it('should verify as valid the enabletoken intent when prebuild tx matchs user intent ', async function () {
+            const { txParams, txPrebuildRaw, walletData } = testData.enableTokenFixtures;
+            const wallet = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+            const sameIntentTx = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild: txPrebuildRaw,
+                wallet,
+                verification: { verifyTokenEnablement: true },
+            });
+            sameIntentTx.should.equal(true);
+        });
+        it('should thrown an error when tampered prebuild tx type ', async function () {
+            const { txParams, txPrebuildRaw, sendTxHex, walletData } = testData.enableTokenFixtures;
+            const tamperedTxPrebuild = { ...txPrebuildRaw, txHex: sendTxHex };
+            const wallet = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+            await assert_1.default.rejects(async () => await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild: tamperedTxPrebuild,
+                wallet,
+                verification: { verifyTokenEnablement: true },
+            }), {
+                message: 'Invalid transaction type on token enablement: expected "AssociatedTokenAccountInitialization", got "Send".',
+            });
+        });
+        it('should verify that tokenName matches between user intent and hex', async function () {
+            const { txParams, txPrebuildRaw, wrongTokenNameTxHex, walletData } = testData.enableTokenFixtures;
+            const tamperedTxPrebuild = { ...txPrebuildRaw, txHex: wrongTokenNameTxHex };
+            const wallet = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+            await assert_1.default.rejects(async () => basecoin.verifyTransaction({
+                txParams,
+                txPrebuild: tamperedTxPrebuild,
+                wallet,
+                verification: { verifyTokenEnablement: true },
+            }), { message: 'Invalid token name: expected tsol:ray, got tsol:t22mint on token enablement tx' });
+        });
+        it('should verify that tokenAddr matches between user intent and hex', async function () {
+            const { txParams, txPrebuildRaw, wrongAddrTxHex, walletData } = testData.enableTokenFixtures;
+            const tamperedTxPrebuild = { ...txPrebuildRaw, txHex: wrongAddrTxHex };
+            const wallet = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+            await assert_1.default.rejects(async () => basecoin.verifyTransaction({
+                txParams,
+                txPrebuild: tamperedTxPrebuild,
+                wallet,
+                verification: { verifyTokenEnablement: true },
+            }), {
+                message: 'Invalid token address: expected 4bTYvvv2Hk4v2kQW8HZFFS4SzYPztQshw9Gm1suXmaBj, got G1LEgANAwKo7b8NfxTsMzrbBYDkXqi5REVJY8thrMRQm on token enablement tx',
+            });
+        });
+        it('should fail sendTokenEnablement call on spoofed data', async function () {
+            const { sendTokenEnablementPayload, walletData, wrongTokenNameTxHex } = testData.enableTokenFixtures;
+            const wallet = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+            (0, nock_1.default)('https://bitgo.fakeurl').get('/api/v2/tsol/key/68bafed588671cf94ed8a5dbba882ad3').reply(200, {});
+            await assert_1.default.rejects(async () => wallet.sendTokenEnablement({
+                verification: { verifyTokenEnablement: true },
+                ...sendTokenEnablementPayload,
+                prebuildTx: { ...sendTokenEnablementPayload.prebuildTx, txHex: wrongTokenNameTxHex },
+            }), {
+                message: 'Invalid token name: expected tsol:ray, got tsol:t22mint on token enablement tx',
+            });
+        });
+    });
+    describe('isWalletAddress', () => {
+        it('should verify valid wallet address with correct keychain and index', async function () {
+            const address = '7YAesfwPk41VChUgr65bm8FEep7ymWqLSW5rpYB5zZPY';
+            const commonKeychain = '8ea32ecacfc83effbd2e2790ee44fa7c59b4d86c29a12f09fb613d8195f93f4e21875cad3b98adada40c040c54c3569467df41a020881a6184096378701862bd';
+            const index = '1';
+            const keychains = [{ id: '1', type: 'tss', commonKeychain }];
+            const result = await basecoin.isWalletAddress({ keychains, address, index });
+            result.should.equal(true);
+        });
+        it('should throw error for address with incorrect keychain', async function () {
+            const address = '7YAesfwPk41VChUgr65bm8FEep7ymWqLSW5rpYB5zZPY';
+            const wrongKeychain = '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';
+            const index = '1';
+            const keychains = [{ id: '1', type: 'tss', commonKeychain: wrongKeychain }];
+            await assert_1.default.rejects(async () => await basecoin.isWalletAddress({ keychains, address, index }), {
+                message: `address validation failure: ${address} is not a wallet address`,
+            });
+        });
+        it('should throw error for address with incorrect index', async function () {
+            const address = '7YAesfwPk41VChUgr65bm8FEep7ymWqLSW5rpYB5zZPY';
+            const commonKeychain = '8ea32ecacfc83effbd2e2790ee44fa7c59b4d86c29a12f09fb613d8195f93f4e21875cad3b98adada40c040c54c3569467df41a020881a6184096378701862bd';
+            const wrongIndex = '999';
+            const keychains = [{ id: '1', type: 'tss', commonKeychain }];
+            await assert_1.default.rejects(async () => await basecoin.isWalletAddress({ keychains, address, index: wrongIndex }), {
+                message: `address validation failure: ${address} is not a wallet address`,
+            });
+        });
+        it('should throw error for invalid address', async function () {
+            const invalidAddress = 'invalidaddress';
+            const commonKeychain = '8ea32ecacfc83effbd2e2790ee44fa7c59b4d86c29a12f09fb613d8195f93f4e21875cad3b98adada40c040c54c3569467df41a020881a6184096378701862bd';
+            const index = '1';
+            const keychains = [{ id: '1', type: 'tss', commonKeychain }];
+            await assert_1.default.rejects(async () => await basecoin.isWalletAddress({ keychains, address: invalidAddress, index }), {
+                message: `invalid address: ${invalidAddress}`,
+            });
+        });
+        it('should verify address with derivation prefix for SMC wallets', async function () {
+            // Address derived with derivation prefix m/999999/148242355/239336845/1
+            const address = 'CC715Q92C8vuEFT5xujE55Do6BkWRdpDvr7Vh8iUNUBw';
+            const commonKeychain = '8ea32ecacfc83effbd2e2790ee44fa7c59b4d86c29a12f09fb613d8195f93f4e21875cad3b98adada40c040c54c3569467df41a020881a6184096378701862bd';
+            const index = '1';
+            const derivedFromParentWithSeed = 'smc-test-seed-123';
+            const keychains = [{ id: '1', type: 'tss', commonKeychain }];
+            // This test verifies that derivedFromParentWithSeed is accepted as a parameter
+            // and the verification function correctly computes the derivation prefix internally
+            const result = await basecoin.isWalletAddress({ keychains, address, index, derivedFromParentWithSeed });
+            result.should.equal(true);
+        });
+    });
+    describe('getAddressFromPublicKey', () => {
+        it('should convert public key to base58 address', function () {
+            const publicKey = '61220a9394802b1d1df37b35f7a3197970f48081092cee011fc98f7b71b2bd43';
+            const expectedAddress = '7YAesfwPk41VChUgr65bm8FEep7ymWqLSW5rpYB5zZPY';
+            const address = basecoin.getAddressFromPublicKey(publicKey);
+            address.should.equal(expectedAddress);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sol.js","sourceRoot":"","sources":["../../../../test/unit/sol.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport * as _ from 'lodash';\nimport nock from 'nock';\nimport * as should from 'should';\nimport * as sinon from 'sinon';\n\nimport { TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';\n\nimport { BitGoAPI, encrypt } from '@bitgo-beta/sdk-api';\nimport {\n  common,\n  Environments,\n  generateRandomPassword,\n  IWallet,\n  MPCSweepTxs,\n  MPCTx,\n  MPCTxs,\n  PrebuildAndSignTransactionOptions,\n  TransactionPrebuild,\n  TssUtils,\n  TxRequest,\n  Wallet,\n  WalletCoinSpecific,\n} from '@bitgo-beta/sdk-core';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { coins } from '@bitgo-beta/statics';\nimport { getAmountBasedOnEndianness, KeyPair, Sol, SolVerifyTransactionOptions, Tsol } from '../../src';\nimport { Transaction } from '../../src/lib';\nimport { AtaInit, InstructionParams, TokenTransfer } from '../../src/lib/iface';\nimport { getAssociatedTokenAccountAddress } from '../../src/lib/utils';\nimport * as testData from '../fixtures/sol';\nimport * as resources from '../resources/sol';\nimport { solBackupKey } from './fixtures/solBackupKey';\nimport { getBuilderFactory } from './getBuilderFactory';\n\ndescribe('SOL:', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin: Sol;\n  let keyPair;\n  let newTxPrebuild;\n  let newTxPrebuildTokenTransfer;\n  let newTxParams;\n  let newTxParamsWithError;\n  let newTxParamsWithExtraData;\n  let newTxParamsTokenTransfer;\n  const badAddresses = resources.addresses.invalidAddresses;\n  const goodAddresses = resources.addresses.validAddresses;\n\n  const keypair = {\n    pub: resources.accountWithSeed.publicKey,\n    prv: resources.accountWithSeed.privateKey.base58,\n  };\n  const txPrebuild = {\n    recipients: [\n      {\n        address: 'lionteste212',\n        amount: '1000',\n      },\n    ],\n    txBase64: resources.TRANSFER_UNSIGNED_TX_WITH_MEMO_AND_DURABLE_NONCE,\n    txInfo: {\n      feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n      nonce: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',\n    },\n    txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',\n    isVotingTransaction: false,\n    coin: 'tsol',\n  };\n  const txParams = {\n    txPrebuild,\n    recipients: [\n      {\n        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n        amount: '300000',\n      },\n    ],\n  };\n  const memo = { value: 'test memo' };\n  const durableNonce = {\n    walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n    authWalletAddress: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n  };\n  const errorDurableNonce = {\n    walletNonceAddress: '8YM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n    authWalletAddress: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n  };\n  const txParamsWithError = {\n    txPrebuild,\n    recipients: [\n      {\n        address: 'CP5Dpaa42mMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n        amount: '300000',\n      },\n    ],\n  };\n  const txParamsWithExtraData = {\n    txPrebuild,\n    recipients: [\n      {\n        address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n        amount: '300000',\n        data: undefined,\n      },\n    ],\n  };\n  const txPrebuildTokenTransfer = {\n    recipients: [\n      {\n        address: 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg',\n        amount: '1',\n      },\n    ],\n    txHex: resources.TOKEN_TRANSFER_TO_NATIVE_UNSIGNED_TX_HEX,\n    txInfo: {\n      feePayer: '4DujymUFbQ8GBKtAwAZrQ6QqpvtBEivL48h4ta2oJGd2',\n      nonce: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',\n    },\n    txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',\n    isVotingTransaction: false,\n    coin: 'tsol',\n  };\n  const txParamsTokenTransfer = {\n    txPrebuild,\n    recipients: [\n      {\n        address: 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg',\n        amount: '1',\n      },\n    ],\n  };\n  const errorMemo = { value: 'different memo' };\n  const errorFeePayer = '5hr5fisPi6DXCuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe';\n  const factory = getBuilderFactory('tsol');\n  const wallet = new KeyPair(resources.authAccount).getKeys();\n  const stakeAccount = new KeyPair(resources.stakeAccount).getKeys();\n  const blockHash = resources.blockHashes.validBlockHashes[0];\n  const amount = '10000';\n  const validator = resources.validator;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('sol', Tsol.createInstance);\n    bitgo.safeRegister('tsol', Tsol.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('tsol') as Tsol;\n    keyPair = basecoin.generateKeyPair(resources.accountWithSeed.seed);\n    newTxPrebuild = () => {\n      return _.cloneDeep(txPrebuild);\n    };\n    newTxPrebuildTokenTransfer = () => {\n      return _.cloneDeep(txPrebuildTokenTransfer);\n    };\n    newTxParams = () => {\n      return _.cloneDeep(txParams);\n    };\n    newTxParamsWithError = () => {\n      return _.cloneDeep(txParamsWithError);\n    };\n    newTxParamsWithExtraData = () => {\n      return _.cloneDeep(txParamsWithExtraData);\n    };\n    newTxParamsTokenTransfer = () => {\n      return _.cloneDeep(txParamsTokenTransfer);\n    };\n  });\n\n  it('should instantiate the coin', async function () {\n    let localBasecoin = bitgo.coin('tsol');\n    localBasecoin.should.be.an.instanceof(Tsol);\n\n    localBasecoin = bitgo.coin('sol');\n    localBasecoin.should.be.an.instanceof(Sol);\n  });\n\n  it('should retun the right info', function () {\n    basecoin.getChain().should.equal('tsol');\n    basecoin.getFamily().should.equal('sol');\n    basecoin.getFullName().should.equal('Testnet Solana');\n    basecoin.getBaseFactor().should.equal(1000000000);\n  });\n  describe('verify transactions', () => {\n    const walletData = {\n      id: '5b34252f1bf349930e34020a00000000',\n      coin: 'tsol',\n      keys: [\n        '5b3424f91bf349930e34017500000000',\n        '5b3424f91bf349930e34017600000000',\n        '5b3424f91bf349930e34017700000000',\n      ],\n      coinSpecific: {\n        rootAddress: wallet.pub,\n      },\n      multisigType: 'tss',\n    };\n    const walletObj = new Wallet(bitgo, basecoin, walletData);\n\n    it('should verify transactions', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        durableNonce,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should verify consolidate transaction', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.consolidateId = 'consolidateId';\n\n      const walletData = {\n        id: '5b34252f1bf349930e34020a00000000',\n        coin: 'tsol',\n        keys: [\n          '5b3424f91bf349930e34017500000000',\n          '5b3424f91bf349930e34017600000000',\n          '5b3424f91bf349930e34017700000000',\n        ],\n        coinSpecific: {\n          rootAddress: stakeAccount.pub,\n        },\n        multisigType: 'tss',\n      };\n      const walletWithDifferentAddress = new Wallet(bitgo, basecoin, walletData);\n\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        durableNonce,\n        wallet: walletWithDifferentAddress,\n      } as any);\n      validTransaction.should.be.true();\n    });\n\n    it('should handle txBase64 and txHex interchangeably', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txHex = txPrebuild.txBase64;\n      txPrebuild.txBase64 = undefined;\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        durableNonce,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should convert serialized hex string to base64', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txBase64 = Buffer.from(txPrebuild.txBase64, 'base64').toString('hex');\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        durableNonce,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\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({\n        txParams,\n        txPrebuild,\n        memo,\n        durableNonce,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should fail verify transactions when have different memo', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      await basecoin\n        .verifyTransaction({ txParams, txPrebuild, memo: errorMemo, wallet: walletObj } as any)\n        .should.be.rejectedWith('Tx memo does not match with expected txParams recipient memo');\n    });\n\n    it('should pass if we pass PDA address', async function () {\n      const walletData = {\n        id: '67f8ddff4c9b8b57a2e16acffac9a3b5',\n        coin: 'tsol',\n        keys: [\n          '5b3424f91bf349930e34017500000000',\n          '5b3424f91bf349930e34017600000000',\n          '5b3424f91bf349930e34017700000000',\n        ],\n        coinSpecific: {\n          rootAddress: '8zbsJA5c8HPR7BPjZkrSVrus2uMuXqCfzksGwB3Uscjb',\n        },\n        multisigType: 'tss',\n      };\n      const walletObj = new Wallet(bitgo, basecoin, walletData);\n      const txPrebuild = {\n        recipients: [\n          {\n            address: '11111111111111111111111111111112',\n            amount: '1000000000',\n            tokenName: 'tsol:usdc',\n          },\n        ],\n        txBase64:\n          '02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006ec1adcc89bb564f1f8225821140a9723efa80e8d506765770b7e201d66d8200d4f690e9a8163291b69f8c3827aad96cfd2105eee3aae76cbca38fcad2bf7f0a0201070c76c356cb069b66c2b35a8638b4d4afca75b303f29f0deeb4bff8528299a9c9d21c96172044f1217c3784e8f02f49e2c8fc3591e81294ab54394f9d22fd7b7a8f60129e6ecb20309c27dcba5fc6c441438d33a1568004a1860e22c16f071976a7d2e2008bd34b53a08aa9c8ec04eb2196745fc6029224447417e2fb0fced601240cabba4ce534c02fc154ba559ed2a02ac971e3385acb426ff63bb1040e2c2435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018c97258f4e2489f1bb3d1029148e0d830b5a1399daff1084048e7bd8dbe9f859d10389fbcee528f208611dccc734b31092540cb2b8d58d100f2eaa2cedb4da5e06a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea940000006a7d517192c5c51218cc94c3d4af17f58daee089ba1fd44e3dbd98a0000000006ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9e680634533882f880a3e7dfa999dfb864b88968d242a0c9a90b5df149e42da050305030209010404000000070700030608050b0a000b04040803000a0c00ca9a3b0000000009',\n        txInfo: {\n          feePayer: '8zbsJA5c8HPR7BPjZkrSVrus2uMuXqCfzksGwB3Uscjb',\n          nonce: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',\n        },\n        txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',\n        isVotingTransaction: false,\n        coin: 'tsol',\n      };\n      const txParams = {\n        txPrebuild,\n        recipients: [\n          {\n            address: '11111111111111111111111111111112',\n            amount: '1000000000',\n            tokenName: 'tsol:usdc',\n          },\n        ],\n      };\n      const memo = {\n        value: undefined,\n      };\n      const verifyTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo: memo,\n        wallet: walletObj,\n      } as any);\n      verifyTransaction.should.equal(true);\n    });\n\n    it('should fail verify transactions when have different durableNonce', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      await basecoin\n        .verifyTransaction({ txParams, txPrebuild, memo, durableNonce: errorDurableNonce, wallet: walletObj } as any)\n        .should.be.rejectedWith('Tx durableNonce does not match with param durableNonce');\n    });\n\n    it('should fail verify transactions when have different feePayer', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      const walletData = {\n        id: '5b34252f1bf349930e34020a00000000',\n        coin: 'tsol',\n        keys: [\n          '5b3424f91bf349930e34017500000000',\n          '5b3424f91bf349930e34017600000000',\n          '5b3424f91bf349930e34017700000000',\n        ],\n        coinSpecific: {\n          rootAddress: stakeAccount.pub,\n        },\n        multisigType: 'tss',\n      };\n      const walletWithDifferentAddress = new Wallet(bitgo, basecoin, walletData);\n\n      await basecoin\n        .verifyTransaction({ txParams, txPrebuild, memo, wallet: walletWithDifferentAddress } as any)\n        .should.be.rejectedWith('Tx fee payer is not the wallet root address');\n    });\n\n    it('should fail verify transactions when have different recipients', async function () {\n      const txParams = newTxParamsWithError();\n      const txPrebuild = newTxPrebuild();\n      await basecoin\n        .verifyTransaction({ txParams, txPrebuild, memo, errorFeePayer, wallet: walletObj } as any)\n        .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');\n    });\n\n    it('should succeed to verify token transaction with native address recipient', async function () {\n      const txParams = newTxParamsTokenTransfer();\n      const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg'; // Native SOL address\n      txParams.recipients = [{ address, amount: '1', tokenName: 'tsol:usdc' }];\n      const txPrebuild = newTxPrebuildTokenTransfer();\n      const feePayerWalletData = {\n        id: '5b34252f1bf349930e34020a00000000',\n        coin: 'tsol',\n        keys: [\n          '5b3424f91bf349930e34017500000000',\n          '5b3424f91bf349930e34017600000000',\n          '5b3424f91bf349930e34017700000000',\n        ],\n        coinSpecific: {\n          rootAddress: '4DujymUFbQ8GBKtAwAZrQ6QqpvtBEivL48h4ta2oJGd2',\n        },\n        multisigType: 'tss',\n      };\n      const feePayerWallet = new Wallet(bitgo, basecoin, feePayerWalletData);\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        wallet: feePayerWallet,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should succeed to verify token transaction with leading zero recipient amount', async function () {\n      const txParams = newTxParamsTokenTransfer();\n      const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg'; // Native SOL address\n      txParams.recipients = [{ address, amount: '0001', tokenName: 'tsol:usdc' }];\n      const txPrebuild = newTxPrebuildTokenTransfer();\n      const feePayerWalletData = {\n        id: '5b34252f1bf349930e34020a00000000',\n        coin: 'tsol',\n        keys: [\n          '5b3424f91bf349930e34017500000000',\n          '5b3424f91bf349930e34017600000000',\n          '5b3424f91bf349930e34017700000000',\n        ],\n        coinSpecific: {\n          rootAddress: '4DujymUFbQ8GBKtAwAZrQ6QqpvtBEivL48h4ta2oJGd2',\n        },\n        multisigType: 'tss',\n      };\n      const feePayerWallet = new Wallet(bitgo, basecoin, feePayerWalletData);\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        wallet: feePayerWallet,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should fail to verify token transaction with different recipient tokenName', async function () {\n      const txParams = newTxParamsTokenTransfer();\n      const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg'; // Native SOL address\n      txParams.recipients = [{ address, amount: '1', tokenName: 'tsol:usdt' }]; // Different tokenName, should fail to verify tx\n      const txPrebuild = newTxPrebuildTokenTransfer();\n      await basecoin\n        .verifyTransaction({\n          txParams,\n          txPrebuild,\n          wallet: walletObj,\n        } as any)\n        .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');\n    });\n\n    it('should fail to verify token transaction with different recipient amounts', async function () {\n      const txParams = newTxParamsTokenTransfer();\n      const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvg'; // Native SOL address\n      txParams.recipients = [{ address, amount: '2', tokenName: 'tsol:usdt' }];\n      const txPrebuild = newTxPrebuildTokenTransfer();\n      await basecoin\n        .verifyTransaction({\n          txParams,\n          txPrebuild,\n          wallet: walletObj,\n        } as any)\n        .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');\n    });\n\n    it('should fail to verify token transaction with different native address', async function () {\n      const txParams = newTxParamsTokenTransfer();\n      const address = 'AF5H6vBkFnJuVqChRPgPQ4JRcQ5Gk25HBFhQQkyojmvX'; // Native SOL address, different than tx recipients\n      txParams.recipients = [{ address, amount: '1', tokenName: 'tsol:usdc' }];\n      const txPrebuild = newTxPrebuildTokenTransfer();\n      await basecoin\n        .verifyTransaction({\n          txParams,\n          txPrebuild,\n          wallet: walletObj,\n        } as any)\n        .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');\n    });\n\n    it('should succeed to verify transactions when recipients has extra data', async function () {\n      const txParams = newTxParamsWithExtraData();\n      const txPrebuild = newTxPrebuild();\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        durableNonce,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should verify activate staking transaction', async function () {\n      const tx = await factory\n        .getStakingActivateBuilder()\n        .stakingAddress(stakeAccount.pub)\n        .sender(wallet.pub)\n        .nonce(blockHash)\n        .amount(amount)\n        .validator(validator.pub)\n        .memo('test memo')\n        .fee({ amount: 5000 })\n        .build();\n      const txToBroadcastFormat = tx.toBroadcastFormat();\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txBase64 = txToBroadcastFormat;\n      txPrebuild.txInfo.nonce = '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen';\n      txParams.recipients = [\n        {\n          address: '7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za',\n          amount: amount,\n        },\n      ];\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should verify withdraw staking transaction', async function () {\n      const tx = await factory\n        .getStakingWithdrawBuilder()\n        .stakingAddress(stakeAccount.pub)\n        .sender(wallet.pub)\n        .nonce(blockHash)\n        .amount(amount)\n        .memo('test memo')\n        .fee({ amount: 5000 })\n        .build();\n      const txToBroadcastFormat = tx.toBroadcastFormat();\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txBase64 = txToBroadcastFormat;\n      txPrebuild.txInfo.nonce = '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen';\n      txParams.recipients = [\n        {\n          address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n          amount: amount,\n        },\n      ];\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should verify deactivate staking transaction', async function () {\n      const tx = await factory\n        .getStakingDeactivateBuilder()\n        .stakingAddress(stakeAccount.pub)\n        .sender(wallet.pub)\n        .nonce(blockHash)\n        .memo('test memo')\n        .fee({ amount: 5000 })\n        .build();\n      const txToBroadcastFormat = tx.toBroadcastFormat();\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txBase64 = txToBroadcastFormat;\n      txPrebuild.txInfo.nonce = '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen';\n      txParams.recipients = [];\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should verify create associated token account transaction', async function () {\n      const tx = await factory\n        .getAtaInitializationBuilder()\n        .mint('tsol:usdc')\n        .sender(wallet.pub)\n        .nonce(blockHash)\n        .memo('test memo')\n        .fee({ amount: 5000 })\n        .build();\n      const txToBroadcastFormat = tx.toBroadcastFormat();\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txBase64 = txToBroadcastFormat;\n      txPrebuild.txInfo.nonce = blockHash;\n      txParams.recipients = [];\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n  });\n\n  describe('getAmountBasedOnEndianness', () => {\n    let originalArch: string;\n\n    beforeEach(() => {\n      originalArch = process.arch;\n    });\n\n    afterEach(() => {\n      Object.defineProperty(process, 'arch', {\n        value: originalArch,\n        writable: true,\n        configurable: true,\n      });\n    });\n\n    it('should return amount unchanged on non-s390x architectures', function () {\n      Object.defineProperty(process, 'arch', {\n        value: 'x64',\n        writable: true,\n        configurable: true,\n      });\n\n      getAmountBasedOnEndianness('300000').should.equal('300000');\n      getAmountBasedOnEndianness('10000').should.equal('10000');\n      getAmountBasedOnEndianness('504403158265495552').should.equal('504403158265495552');\n    });\n\n    it('should byte-swap small amounts on s390x (small becomes huge)', function () {\n      Object.defineProperty(process, 'arch', {\n        value: 's390x',\n        writable: true,\n        configurable: true,\n      });\n\n      // Small amount 10,000 (0x2710) swaps to 1,163,899,028,698,562,560\n      getAmountBasedOnEndianness('10000').should.equal('1163899028698562560');\n    });\n\n    it('should byte-swap large amounts on s390x (large becomes tiny)', function () {\n      Object.defineProperty(process, 'arch', {\n        value: 's390x',\n        writable: true,\n        configurable: true,\n      });\n\n      // Large amount 504,403,158,265,495,552 (0x0700000000000000) swaps to 7\n      getAmountBasedOnEndianness('504403158265495552').should.equal('7');\n    });\n\n    it('should handle numeric input', function () {\n      Object.defineProperty(process, 'arch', {\n        value: 's390x',\n        writable: true,\n        configurable: true,\n      });\n\n      // Should work with numbers, not just strings\n      getAmountBasedOnEndianness(10000).should.equal('1163899028698562560');\n    });\n\n    it('should handle standard transaction amounts on s390x', function () {\n      Object.defineProperty(process, 'arch', {\n        value: 's390x',\n        writable: true,\n        configurable: true,\n      });\n\n      // Standard amount 300,000 (0x493E0) swaps to large value\n      const result = getAmountBasedOnEndianness('300000');\n      // Verify it's different (swapped)\n      result.should.not.equal('300000');\n      // Verify swapping back gives original\n      getAmountBasedOnEndianness(result).should.equal('300000');\n    });\n\n    it('should handle invalid input gracefully', function () {\n      Object.defineProperty(process, 'arch', {\n        value: 's390x',\n        writable: true,\n        configurable: true,\n      });\n\n      // Invalid BigInt input should return original string\n      getAmountBasedOnEndianness('not-a-number').should.equal('not-a-number');\n    });\n  });\n\n  it('should accept valid address', function () {\n    goodAddresses.forEach((addr) => {\n      basecoin.isValidAddress(addr).should.equal(true);\n    });\n  });\n\n  it('should reject invalid address', function () {\n    badAddresses.forEach((addr) => {\n      basecoin.isValidAddress(addr).should.equal(false);\n    });\n  });\n\n  it('should check valid pub keys', function () {\n    keyPair.should.have.property('pub');\n    basecoin.isValidPub(keyPair.pub).should.equal(true);\n  });\n\n  it('should check an invalid pub keys', function () {\n    const badPubKey = keyPair.pub.slice(0, keyPair.pub.length - 1) + '-';\n    basecoin.isValidPub(badPubKey).should.equal(false);\n  });\n\n  it('should check valid prv keys', function () {\n    keyPair.should.have.property('prv');\n    basecoin.isValidPrv(keyPair.prv).should.equal(true);\n  });\n\n  it('should check an invalid prv keys', function () {\n    const badPrvKey = keyPair.prv ? keyPair.prv.slice(0, keyPair.prv.length - 1) + '-' : undefined;\n    basecoin.isValidPrv(badPrvKey as string).should.equal(false);\n  });\n\n  describe('Parse Transactions:', () => {\n    it('should parse an unsigned transfer transaction', async function () {\n      const parsedTransaction = await basecoin.parseTransaction({\n        txBase64: testData.rawTransactions.transfer.unsigned,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n\n      parsedTransaction.should.deepEqual({\n        inputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: 305000,\n          },\n        ],\n        outputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: '300000',\n          },\n        ],\n      });\n    });\n\n    it('should parse a signed transfer transaction', async function () {\n      const parsedTransaction = await basecoin.parseTransaction({\n        txBase64: testData.rawTransactions.transfer.signed,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n\n      parsedTransaction.should.deepEqual({\n        inputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: 305000,\n          },\n        ],\n        outputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: '300000',\n          },\n        ],\n      });\n    });\n\n    it('should parse an unsigned wallet init transaction', async function () {\n      const parsedTransaction = await basecoin.parseTransaction({\n        txBase64: testData.rawTransactions.walletInit.unsigned,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n\n      parsedTransaction.should.deepEqual({\n        inputs: [\n          {\n            address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n            amount: 310000,\n          },\n        ],\n        outputs: [\n          {\n            address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n            amount: '300000',\n          },\n        ],\n      });\n    });\n\n    it('should parse a signed wallet init transaction', async function () {\n      const parsedTransaction = await basecoin.parseTransaction({\n        txBase64: testData.rawTransactions.walletInit.signed,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n\n      parsedTransaction.should.deepEqual({\n        inputs: [\n          {\n            address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n            amount: 310000,\n          },\n        ],\n        outputs: [\n          {\n            address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n            amount: '300000',\n          },\n        ],\n      });\n    });\n\n    it('should parse an unsigned transfer token transaction', async function () {\n      const parsedTransaction = await basecoin.parseTransaction({\n        txBase64: testData.rawTransactions.transferToken.unsigned,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n\n      parsedTransaction.should.deepEqual({\n        inputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: 5000,\n          },\n        ],\n        outputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: '300000',\n            tokenName: 'tsol:usdc',\n          },\n        ],\n      });\n    });\n\n    it('should parse a signed transfer token transaction', async function () {\n      const parsedTransaction = await basecoin.parseTransaction({\n        txBase64: testData.rawTransactions.transferToken.signed,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n\n      parsedTransaction.should.deepEqual({\n        inputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: 5000,\n          },\n        ],\n        outputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: '300000',\n            tokenName: 'tsol:usdc',\n          },\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        txBase64: testData.rawTransactions.transfer.unsigned,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: 'UNAVAILABLE',\n        type: 'Send',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '300000',\n        outputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: '300000',\n          },\n        ],\n        inputs: [\n          {\n            address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n            value: '300000',\n          },\n        ],\n        feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        fee: {\n          fee: '5000',\n          feeRate: 5000,\n        },\n        memo: 'test memo',\n        blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',\n        durableNonce: {\n          authWalletAddress: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n          walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n        },\n        tokenEnablements: [],\n        ataOwnerMap: {},\n      });\n    });\n\n    it('should explain a signed transfer transaction', async function () {\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: testData.rawTransactions.transfer.signed,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: '2XFxGfXddKWnqGaMAsfNL8HgXqDvjBL2Ae28KWrRvg9bQBmCrpHYVDacuZFeAUyYwjXG6ey2jTARX5VQCnj7SF4L',\n        type: 'Send',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '300000',\n        outputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: '300000',\n          },\n        ],\n        inputs: [\n          {\n            address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n            value: '300000',\n          },\n        ],\n        feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        fee: {\n          fee: '5000',\n          feeRate: 5000,\n        },\n        memo: 'test memo',\n        blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',\n        durableNonce: {\n          authWalletAddress: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n          walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n        },\n        tokenEnablements: [],\n        ataOwnerMap: {},\n      });\n    });\n\n    it('should explain an unsigned wallet init transaction', async function () {\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: testData.rawTransactions.walletInit.unsigned,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: 'UNAVAILABLE',\n        type: 'WalletInitialization',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '300000',\n        outputs: [\n          {\n            address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n            amount: '300000',\n          },\n        ],\n        inputs: [\n          {\n            address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n            value: '300000',\n          },\n        ],\n        feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        fee: {\n          fee: '10000',\n          feeRate: 5000,\n        },\n        blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',\n        durableNonce: undefined,\n        memo: undefined,\n        tokenEnablements: [],\n        ataOwnerMap: {},\n      });\n    });\n\n    it('should explain a signed wallet init transaction', async function () {\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: testData.rawTransactions.walletInit.signed,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: '7TkU8wLgXDeLFbVydtg6mqMsp9GatsetitSngysgjxFhofKSUcLPBoKPHciLeGEfJFMsqezpZmGRSFQTBy7ZDsg',\n        type: 'WalletInitialization',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '300000',\n        outputs: [\n          {\n            address: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n            amount: '300000',\n          },\n        ],\n        inputs: [\n          {\n            address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n            value: '300000',\n          },\n        ],\n        feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        fee: {\n          fee: '10000',\n          feeRate: 5000,\n        },\n        blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',\n        durableNonce: undefined,\n        memo: undefined,\n        tokenEnablements: [],\n        ataOwnerMap: {},\n      });\n    });\n\n    it('should explain an unsigned token transfer transaction', async function () {\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: testData.rawTransactions.transferToken.unsigned,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: 'UNAVAILABLE',\n        type: 'Send',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '0',\n        outputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: '300000',\n            tokenName: 'tsol:usdc',\n          },\n        ],\n        inputs: [\n          {\n            address: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',\n            value: '300000',\n          },\n        ],\n        feePayer: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',\n        fee: {\n          fee: '5000',\n          feeRate: 5000,\n        },\n        memo: 'test memo',\n        blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',\n        durableNonce: {\n          authWalletAddress: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',\n          walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n        },\n        tokenEnablements: [],\n        ataOwnerMap: {},\n      });\n    });\n\n    it('should explain a signed token transfer transaction', async function () {\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: testData.rawTransactions.transferToken.signed,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: '2ticU4ZkEqdTHULr6LobTgWBhim6E7wSscDhM4gzyuGUmQyUwLYhoqaifuvwmNzzEf1T5aefVcgMQkSHdJ5nsrfZ',\n        type: 'Send',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '0',\n        outputs: [\n          {\n            address: 'CP5Dpaa42RtJmMuKqCQsLwma5Yh3knuvKsYDFX85F41S',\n            amount: '300000',\n            tokenName: 'tsol:usdc',\n          },\n        ],\n        inputs: [\n          {\n            address: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',\n            value: '300000',\n          },\n        ],\n        feePayer: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',\n        fee: {\n          fee: '5000',\n          feeRate: 5000,\n        },\n        memo: 'test memo',\n        blockhash: 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi',\n        durableNonce: {\n          authWalletAddress: '12f6D3WubGVeQoH2m8kTvvcrasWdXWwtVzUCyRNDZxA2',\n          walletNonceAddress: '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n        },\n        tokenEnablements: [],\n        ataOwnerMap: {},\n      });\n    });\n\n    it('should explain activate staking transaction', async function () {\n      const tx = await factory\n        .getStakingActivateBuilder()\n        .stakingAddress(stakeAccount.pub)\n        .sender(wallet.pub)\n        .nonce(blockHash)\n        .amount(amount)\n        .validator(validator.pub)\n        .memo('test memo')\n        .fee({ amount: 5000 })\n        .build();\n      const txToBroadcastFormat = tx.toBroadcastFormat();\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: txToBroadcastFormat,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: 'UNAVAILABLE',\n        type: 'StakingActivate',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '10000',\n        outputs: [\n          {\n            address: '7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za',\n            amount: '10000',\n          },\n        ],\n        inputs: [\n          {\n            address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n            value: '10000',\n          },\n        ],\n        feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        fee: {\n          fee: '10000',\n          feeRate: 5000,\n        },\n        memo: 'test memo',\n        blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',\n        durableNonce: undefined,\n        tokenEnablements: [],\n        ataOwnerMap: {},\n      });\n    });\n\n    it('should explain deactivate staking transaction', async function () {\n      const tx = await factory\n        .getStakingDeactivateBuilder()\n        .stakingAddress(stakeAccount.pub)\n        .sender(wallet.pub)\n        .nonce(blockHash)\n        .memo('test memo')\n        .fee({ amount: 5000 })\n        .build();\n      const txToBroadcastFormat = tx.toBroadcastFormat();\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: txToBroadcastFormat,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: 'UNAVAILABLE',\n        type: 'StakingDeactivate',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '0',\n        outputs: [],\n        inputs: [],\n        feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        fee: {\n          fee: '5000',\n          feeRate: 5000,\n        },\n        memo: 'test memo',\n        blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',\n        durableNonce: undefined,\n        tokenEnablements: [],\n        ataOwnerMap: {},\n      });\n    });\n\n    it('should explain withdraw staking transaction', async function () {\n      const tx = await factory\n        .getStakingWithdrawBuilder()\n        .stakingAddress(stakeAccount.pub)\n        .sender(wallet.pub)\n        .nonce(blockHash)\n        .amount(amount)\n        .memo('test memo')\n        .fee({ amount: 5000 })\n        .build();\n      const txToBroadcastFormat = tx.toBroadcastFormat();\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: txToBroadcastFormat,\n        feeInfo: {\n          fee: '5000',\n        },\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: 'UNAVAILABLE',\n        type: 'StakingWithdraw',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '10000',\n        outputs: [\n          {\n            address: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n            amount: '10000',\n          },\n        ],\n        inputs: [\n          {\n            address: '7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za',\n            value: '10000',\n          },\n        ],\n        feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        fee: {\n          fee: '5000',\n          feeRate: 5000,\n        },\n        memo: 'test memo',\n        blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',\n        durableNonce: undefined,\n        tokenEnablements: [],\n        ataOwnerMap: {},\n      });\n    });\n\n    it('should explain create ATA transaction', async function () {\n      const tokenName = 'tsol:usdc';\n      const rentExemptAmount = '3000000';\n      const tx = await factory\n        .getAtaInitializationBuilder()\n        .sender(wallet.pub)\n        .nonce(blockHash)\n        .mint(tokenName)\n        .rentExemptAmount(rentExemptAmount)\n        .memo('test memo')\n        .fee({ amount: 5000 })\n        .build();\n      const txToBroadcastFormat = tx.toBroadcastFormat();\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: txToBroadcastFormat,\n        feeInfo: {\n          fee: '5000',\n        },\n        tokenAccountRentExemptAmount: rentExemptAmount,\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: 'UNAVAILABLE',\n        type: 'AssociatedTokenAccountInitialization',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '0',\n        outputs: [],\n        inputs: [],\n        feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        fee: {\n          fee: '3005000',\n          feeRate: 5000,\n        },\n        memo: 'test memo',\n        blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',\n        durableNonce: undefined,\n        tokenEnablements: [\n          {\n            address: '141BFNem3pknc8CzPVLv1Ri3btgKdCsafYP5nXwmXfxU',\n            tokenAddress: 'F4uLeXJoFz3hw13MposuwaQbMcZbCjqvEGPPeRRB1Byf',\n            tokenName: 'tsol:usdc',\n          },\n        ],\n        ataOwnerMap: {\n          '141BFNem3pknc8CzPVLv1Ri3btgKdCsafYP5nXwmXfxU': '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        },\n      });\n    });\n\n    it('should explain create multi ATA transaction', async function () {\n      const recipients = [\n        {\n          ownerAddress: wallet.pub,\n          tokenName: 'tsol:usdc',\n        },\n        {\n          ownerAddress: durableNonce.walletNonceAddress,\n          tokenName: 'tsol:ray',\n        },\n      ];\n      const rentExemptAmount = '3000000';\n      const tx = await factory\n        .getAtaInitializationBuilder()\n        .sender(wallet.pub)\n        .nonce(blockHash)\n        .enableToken(recipients[0])\n        .enableToken(recipients[1])\n        .rentExemptAmount(rentExemptAmount)\n        .memo('test memo')\n        .fee({ amount: 5000 })\n        .build();\n      const txToBroadcastFormat = tx.toBroadcastFormat();\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: txToBroadcastFormat,\n        feeInfo: {\n          fee: '5000',\n        },\n        tokenAccountRentExemptAmount: rentExemptAmount,\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: 'UNAVAILABLE',\n        type: 'AssociatedTokenAccountInitialization',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '0',\n        outputs: [],\n        inputs: [],\n        feePayer: '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n        fee: {\n          fee: '6005000',\n          feeRate: 5000,\n        },\n        memo: 'test memo',\n        blockhash: '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',\n        durableNonce: undefined,\n        tokenEnablements: [\n          {\n            address: '141BFNem3pknc8CzPVLv1Ri3btgKdCsafYP5nXwmXfxU',\n            tokenAddress: 'F4uLeXJoFz3hw13MposuwaQbMcZbCjqvEGPPeRRB1Byf',\n            tokenName: 'tsol:usdc',\n          },\n          {\n            address: '9KaLinZFNW5chL4J8UoKnTECppWVMz3ewgx4FAkxUDcf',\n            tokenAddress: '9kLJoGbMgSteptkhKKuh7ken4JEvHrT83157ezEGrZ7R',\n            tokenName: 'tsol:ray',\n          },\n        ],\n        ataOwnerMap: {\n          '141BFNem3pknc8CzPVLv1Ri3btgKdCsafYP5nXwmXfxU': '5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe',\n          '9KaLinZFNW5chL4J8UoKnTECppWVMz3ewgx4FAkxUDcf': '8Y7RM6JfcX4ASSNBkrkrmSbRu431YVi9Y3oLFnzC2dCh',\n        },\n      });\n    });\n\n    it('should explain an unsigned token transfer with ATA creation transaction', async function () {\n      const explainedTransaction = await basecoin.explainTransaction({\n        txBase64: testData.rawTransactions.tokenTransferWithAtaCreation.unsigned,\n        feeInfo: {\n          fee: '5000',\n        },\n        tokenAccountRentExemptAmount: '3000000',\n      });\n      explainedTransaction.should.deepEqual({\n        displayOrder: [\n          'id',\n          'type',\n          'blockhash',\n          'durableNonce',\n          'outputAmount',\n          'changeAmount',\n          'outputs',\n          'changeOutputs',\n          'tokenEnablements',\n          'fee',\n          'memo',\n        ],\n        id: 'UNAVAILABLE',\n        type: 'Send',\n        changeOutputs: [],\n        changeAmount: '0',\n        outputAmount: '0',\n        outputs: [\n          {\n            address: '2eKjVtzV3oPTXFdtRSDj3Em9k1MV7k8WjKkBszQUwizS',\n            amount: '10000',\n            tokenName: 'tsol:usdc',\n          },\n        ],\n        inputs: [\n          {\n            address: '5U3bH5b6XtG99aVWLqwVzYPVpQiFHytBD68Rz2eFPZd7',\n            value: '10000',\n          },\n        ],\n        feePayer: '5U3bH5b6XtG99aVWLqwVzYPVpQiFHytBD68Rz2eFPZd7',\n        fee: { fee: '3005000', feeRate: 5000 },\n        memo: undefined,\n        blockhash: '27E3MXFvXMUNYeMJeX1pAbERGsJfUbkaZTfgMgpmNN5g',\n        durableNonce: undefined,\n        tokenEnablements: [\n          {\n            address: '2eKjVtzV3oPTXFdtRSDj3Em9k1MV7k8WjKkBszQUwizS',\n            tokenAddress: 'F4uLeXJoFz3hw13MposuwaQbMcZbCjqvEGPPeRRB1Byf',\n            tokenName: 'tsol:usdc',\n          },\n        ],\n        ataOwnerMap: {\n          '2eKjVtzV3oPTXFdtRSDj3Em9k1MV7k8WjKkBszQUwizS': 'C4zCqCaDm4D78zgaH3CeBEEBEAoMNhzSCj23qE92ndiP',\n        },\n      });\n    });\n  });\n\n  describe('Keypair:', () => {\n    it('should generate a keypair from random seed', function () {\n      should.throws(() => basecoin.generateKeyPair('placeholder' as any), 'generateKeyPair method not implemented');\n    });\n\n    it('should generate a keypair from a seed', function () {\n      should.throws(() => basecoin.generateKeyPair('placeholder' as any), 'generateKeyPair method not implemented');\n    });\n  });\n\n  describe('Sign transaction:', () => {\n    it('should sign transaction', async function () {\n      const signed: any = await basecoin.signTransaction({\n        txPrebuild: {\n          txBase64: resources.RAW_TX_UNSIGNED,\n          keys: [resources.accountWithSeed.publicKey.toString()],\n        },\n        prv: resources.accountWithSeed.privateKey.base58,\n      } as any);\n      signed.txHex.should.equal(resources.RAW_TX_SIGNED);\n    });\n\n    it('should handle txHex and txBase64 interchangeably', async function () {\n      const signed: any = await basecoin.signTransaction({\n        txPrebuild: {\n          txHex: resources.RAW_TX_UNSIGNED,\n          keys: [resources.accountWithSeed.publicKey.toString()],\n        },\n        prv: resources.accountWithSeed.privateKey.base58,\n      } as any);\n      signed.txHex.should.equal(resources.RAW_TX_SIGNED);\n    });\n\n    it('should throw invalid transaction when sign with public key', async function () {\n      await basecoin\n        .signTransaction({\n          txPrebuild: {\n            txBase64: resources.RAW_TX_UNSIGNED,\n            keys: [resources.accountWithSeed.publicKey.toString()],\n          },\n          prv: resources.accountWithSeed.publicKey,\n        } as any)\n        .should.be.rejectedWith('Invalid key');\n    });\n  });\n\n  describe('Sign message', () => {\n    it('should sign message', async function () {\n      const signed = await basecoin.signMessage(keypair, 'signed message');\n      signed\n        .toString('base64')\n        .should.equal('s+7d/8aW/twfM/0wLSKOGxd9+LhDIiz/g0FfJ39ylJhQIkjK0RYPm/Y+gdeJ5DIy6K6h6gCXXESDomlv12DBBQ==');\n    });\n    it('shouldnt sign message when message is undefined', async function () {\n      await basecoin\n        .signMessage(keypair, undefined as any)\n        .should.be.rejectedWith(\n          'The first argument must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object. Received undefined'\n        );\n    });\n  });\n\n  describe('Get Signing Payload', () => {\n    it('should return a valid signing payload', async function () {\n      const factory = getBuilderFactory(basecoin.getChain());\n      const rebuiltSignablePayload = (await factory.from(resources.TRANSFER_UNSIGNED_TX_WITH_MEMO).build())\n        .signablePayload;\n      const signingPayload = await basecoin.getSignablePayload(resources.TRANSFER_UNSIGNED_TX_WITH_MEMO);\n      signingPayload.should.be.deepEqual(rebuiltSignablePayload);\n    });\n\n    it('should build CloseAssociatedTokenAccount txn builder from raw txn', async function () {\n      const factory = getBuilderFactory(basecoin.getChain());\n      const txnBuilder = factory.from(resources.TRANSFER_UNSIGNED_TX_CLOSE_ATA);\n      assert.ok(txnBuilder);\n    });\n  });\n\n  describe('Presign transaction', () => {\n    const txRequestId = 'txRequestId';\n    let sandbox: sinon.SinonSandbox;\n\n    beforeEach(() => {\n      sandbox = sinon.createSandbox();\n    });\n\n    afterEach(() => {\n      sandbox.verifyAndRestore();\n    });\n\n    it('should rebuild tx request for hot wallets', async () => {\n      const rebuiltTx: TxRequest = {\n        txRequestId,\n        unsignedTxs: [\n          {\n            serializedTxHex: 'deadbeef',\n            signableHex: 'serializedTxHex',\n            derivationPath: 'm/0',\n          },\n        ],\n        transactions: [],\n        date: new Date().toISOString(),\n        intent: {\n          intentType: 'payment',\n        },\n        latest: true,\n        state: 'pendingUserSignature',\n        walletType: 'hot',\n        walletId: 'walletId',\n        policiesChecked: true,\n        version: 1,\n        userId: 'userId',\n      };\n\n      const stubTssUtils = sandbox.createStubInstance(TssUtils);\n      stubTssUtils.deleteSignatureShares.resolves([]);\n      stubTssUtils.getTxRequest.resolves(rebuiltTx);\n\n      const hotWallet = {\n        type: 'hot',\n      };\n      const presignedTransaction: any = await basecoin.presignTransaction({\n        walletData: hotWallet,\n        tssUtils: stubTssUtils,\n        txPrebuild: {\n          txRequestId,\n        },\n      } as any);\n\n      presignedTransaction.walletData.should.deepEqual(hotWallet);\n      presignedTransaction.txPrebuild.should.deepEqual(rebuiltTx);\n      presignedTransaction.txHex.should.equal(rebuiltTx.unsignedTxs[0].serializedTxHex);\n    });\n\n    it('should do nothing for non-hot wallets', async () => {\n      const coldWallet = {\n        type: 'cold',\n      };\n\n      const presignedTransaction = await basecoin.presignTransaction({\n        walletData: coldWallet,\n      } as any);\n      presignedTransaction.should.deepEqual({\n        walletData: coldWallet,\n      });\n    });\n\n    it('should error if txRequestId is missing', async () => {\n      const hotWallet = {\n        type: 'hot',\n      };\n      await basecoin\n        .presignTransaction({\n          walletData: hotWallet,\n          txPrebuild: {},\n        } as any)\n        .should.rejectedWith('Missing txRequestId');\n    });\n  });\n\n  describe('API Key parameter:', () => {\n    // Test the getPublicNodeUrl method directly\n    it('should append apiKey to node URL when provided', function () {\n      // Access the protected method using type casting\n      const url = (basecoin as any).getPublicNodeUrl('test-api-key-123');\n      url.should.equal(`${Environments.test.solAlchemyNodeUrl}/test-api-key-123`);\n    });\n\n    it('should use regular node URL when apiKey is not provided', function () {\n      // Access the protected method using type casting\n      const url = (basecoin as any).getPublicNodeUrl();\n      url.should.equal(Environments.test.solNodeUrl);\n    });\n  });\n\n  describe('Recover Transactions:', () => {\n    const sandBox = sinon.createSandbox();\n    const coin = coins.get('tsol');\n    const usdtMintAddress = '9cgpBeNZ2HnLda7NWaaU1i3NyTstk2c4zCMUcoAGsi9C';\n    const t22mintAddress = '5NR1bQwLWqjbkhbQ1hx72HKJybbuvwkDnUZNoAZ2VhW6';\n    let callBack: sinon.SinonStub;\n\n    beforeEach(() => {\n      callBack = sandBox.stub(Sol.prototype, 'getDataFromNode' as keyof Sol);\n\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getLatestBlockhash',\n            params: [\n              {\n                commitment: 'finalized',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getBlockhashResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getFeeForMessage',\n            params: [\n              sinon.match.string,\n              {\n                commitment: 'finalized',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getFeesForMessageResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getMinimumBalanceForRentExemption',\n            params: [165],\n          },\n        })\n        .resolves(testData.SolResponses.getMinimumBalanceForRentExemptionResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.accountInfo.bs58EncodedPublicKey],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.accountInfo.bs58EncodedPublicKeyNoFunds],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponseNoFunds);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.accountInfo.bs58EncodedPublicKeyM1Derivation],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponseM1Derivation);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.accountInfo.bs58EncodedPublicKeyM2Derivation],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponseM2Derivation);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.accountInfo.bs58EncodedPublicKeyWithManyTokens],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponseM2Derivation);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.closeATAkeys.closeAtaAddress],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponseM2Derivation);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.closeATAkeys.bs58EncodedPublicKey],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponseM2Derivation);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getAccountInfo',\n            params: [\n              testData.closeATAkeys.closeAtaAddress,\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenInfoResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getAccountInfo',\n            params: [\n              testData.keys.durableNoncePubKey,\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountInfoResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.keys.destinationPubKey,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.accountInfo.bs58EncodedPublicKey,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.keys.destinationPubKey2,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.keys.destinationPubKey2,\n              {\n                programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerForSol2022Response2);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.wrwUser.walletAddress0,\n              {\n                programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerForSol2022Response);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.wrwUser.walletAddress0,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse2);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.wrwUser.walletAddress4,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse3);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.wrwUser.walletAddress0],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.keys.destinationPubKey,\n              {\n                programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'sendTransaction',\n            params: sinon.match.array,\n          },\n        })\n        .onCall(0)\n        .resolves(testData.SolResponses.broadcastTransactionResponse)\n        .onCall(1)\n        .resolves(testData.SolResponses.broadcastTransactionResponse1);\n    });\n\n    afterEach(() => {\n      sandBox.restore();\n    });\n\n    it('should take OVC output and generate a signed sweep transaction', async function () {\n      const params = testData.ovcResponse;\n      const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);\n      recoveryTxn.transactions[0].serializedTx.should.equal(\n        'AvR+L909kzRq6NuaUe9F6Jt97MOiFs7jpW8MuOrwz4EbKF40d31dci/bgLTq4gpk/Hh3s5cA8FtbLkDQr15PqAE7yd8LOXvsLtO2REqMM/OCZ8wItfsqfTfia2xIfibRW3wHgw63jiaojbXeSqaYajJ/Ca7YwBUz5blydI3fYLgPAgECBsLVtfT7mpvNii8wPk0G942N7TAHE/RW2iq/8LPqAYWqBRo0vIrNQ4djl2+Wh2EVBQ9zgoVTVm0RHXrIv/6/WHxPX1mHv+JqpmAT79ltNjYPK0M2yR+ZMln7VgUTBWFNQvLqE/j/nXlY2/JpxuNr/fXLXEPeS04dPvt9qz1dAoYEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAADpiH20cxLj7KnOaoI5ANNoPxYjs472FdjDeMPft3kXdAgQDAgUBBAQAAAAEAgADDAIAAADwopo7AAAAAA=='\n      );\n      (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(0);\n      (recoveryTxn.lastScanIndex ?? 0).should.equal(0);\n    });\n\n    it('should take sol 2022 token OVC output and generate a signed sweep transaction', async function () {\n      const params = testData.ovcResponse;\n      const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);\n      recoveryTxn.transactions[0].serializedTx.should.equal(\n        'AvR+L909kzRq6NuaUe9F6Jt97MOiFs7jpW8MuOrwz4EbKF40d31dci/bgLTq4gpk/Hh3s5cA8FtbLkDQr15PqAE7yd8LOXvsLtO2REqMM/OCZ8wItfsqfTfia2xIfibRW3wHgw63jiaojbXeSqaYajJ/Ca7YwBUz5blydI3fYLgPAgECBsLVtfT7mpvNii8wPk0G942N7TAHE/RW2iq/8LPqAYWqBRo0vIrNQ4djl2+Wh2EVBQ9zgoVTVm0RHXrIv/6/WHxPX1mHv+JqpmAT79ltNjYPK0M2yR+ZMln7VgUTBWFNQvLqE/j/nXlY2/JpxuNr/fXLXEPeS04dPvt9qz1dAoYEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAADpiH20cxLj7KnOaoI5ANNoPxYjs472FdjDeMPft3kXdAgQDAgUBBAQAAAAEAgADDAIAAADwopo7AAAAAA=='\n      );\n      (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(0);\n      (recoveryTxn.lastScanIndex ?? 0).should.equal(0);\n    });\n\n    it('should take consolidation OVC output and generate multiple signed sweep transactions', async function () {\n      const params = testData.ovcResponse2;\n      const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);\n      recoveryTxn.transactions[0].serializedTx.should.equal(\n        'AtQPLzOmLuKwHY6N5XoJIZK/T7W10uYWm/MRte3GFUdl+w3gHLjSa9H66WSfFNubQxIPckxJDyltkP7ksLDf9QgBNJM2UWbBUH5wT0JJHILlhCs33HX8DeE/8Tdsw6tGfZoMhCnSKv6TPWtBxy7Sb6sW8ksCUPnAWuHGGKmgjEMBAgECBmLrqxJrY2kbN/tcrQw3P8P15OljFGabFJAKBrUO1grNBRo0vIrNQ4djl2+Wh2EVBQ9zgoVTVm0RHXrIv/6/WHxPX1mHv+JqpmAT79ltNjYPK0M2yR+ZMln7VgUTBWFNQsLVtfT7mpvNii8wPk0G942N7TAHE/RW2iq/8LPqAYWqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAIZQniiS73D6mwfpnfhVMC4lyYJtRSrmoZpF7yIlUdIDAgQDAgUBBAQAAAAEAgADDAIAAADwPc0dAAAAAA=='\n      );\n      (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(1);\n      recoveryTxn.transactions[1].serializedTx.should.equal(\n        'AuLhOA5zmOBZR85lo+nKdTopVwJAMrMp6NW+8UnGNsSBSpBkqfWZQqSg9s+7aTlXezm5vxol+Pl6t7PpVNTOHwLcp9xJp3TFHdivEbhwJKldR4Ny+pasoFx+Bgk8q6g1iNiq7XSi1Ov3bs7euMkTj7nDRFqP8lv7xLTcvrBm9OQJAgECBp14ImBCdmVROlw0UveYS1MvG/ljCRI3MJTFmsxuXEoWBRo0vIrNQ4djl2+Wh2EVBQ9zgoVTVm0RHXrIv/6/WHw0hyxvpVwtIx9/zeX2O16eTrY+aKIh1mdKg4MMg0eyxMLVtfT7mpvNii8wPk0G942N7TAHE/RW2iq/8LPqAYWqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAC7ws1XFslinwgtpISUViVWIVTHyD2Q0qj24YjKmrAmXAgQDAgUBBAQAAAAEAgADDAIAAADwPc0dAAAAAA=='\n      );\n      (recoveryTxn.transactions[1].scanIndex ?? 0).should.equal(2);\n      (recoveryTxn.lastScanIndex ?? 0).should.equal(20);\n    });\n\n    it('should recover a txn for non-bitgo recoveries (latest blockhash)', async function () {\n      // Latest Blockhash Recovery (BitGo-less)\n      const latestBlockHashTxn = await basecoin.recover({\n        userKey: testData.keys.userKey,\n        backupKey: testData.keys.backupKey,\n        bitgoKey: testData.keys.bitgoKey,\n        recoveryDestination: testData.keys.destinationPubKey,\n        walletPassphrase: testData.keys.walletPassword,\n      });\n      latestBlockHashTxn.should.not.be.empty();\n      latestBlockHashTxn.should.hasOwnProperty('serializedTx');\n      latestBlockHashTxn.should.hasOwnProperty('scanIndex');\n      should.equal((latestBlockHashTxn as MPCTx).scanIndex, 0);\n\n      const latestBlockhashTxnDeserialize = new Transaction(coin);\n      latestBlockhashTxnDeserialize.fromRawTransaction((latestBlockHashTxn as MPCTx).serializedTx);\n      const latestBlockhashTxnJson = latestBlockhashTxnDeserialize.toJson();\n\n      should.equal(latestBlockhashTxnJson.nonce, testData.SolInputData.blockhash);\n      should.equal(latestBlockhashTxnJson.feePayer, testData.accountInfo.bs58EncodedPublicKey);\n      should.equal(latestBlockhashTxnJson.numSignatures, testData.SolInputData.latestBlockhashSignatures);\n      const solCoin = basecoin as any;\n      sandBox.assert.callCount(solCoin.getDataFromNode, 3);\n    });\n\n    it('should recover a txn for non-bitgo recoveries (durable nonce)', async function () {\n      // Durable Nonce Recovery (BitGo-less)\n      const durableNonceTxn = await basecoin.recover({\n        userKey: testData.keys.userKey,\n        backupKey: testData.keys.backupKey,\n        bitgoKey: testData.keys.bitgoKey,\n        recoveryDestination: testData.keys.destinationPubKey,\n        walletPassphrase: testData.keys.walletPassword,\n        durableNonce: {\n          publicKey: testData.keys.durableNoncePubKey,\n          secretKey: testData.keys.durableNoncePrivKey,\n        },\n      });\n\n      durableNonceTxn.should.not.be.empty();\n      durableNonceTxn.should.hasOwnProperty('serializedTx');\n      durableNonceTxn.should.hasOwnProperty('scanIndex');\n      should.equal((durableNonceTxn as MPCTx).scanIndex, 0);\n\n      const durableNonceTxnDeserialize = new Transaction(coin);\n      durableNonceTxnDeserialize.fromRawTransaction((durableNonceTxn as MPCTx).serializedTx);\n      const durableNonceTxnJson = durableNonceTxnDeserialize.toJson();\n\n      should.equal(durableNonceTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);\n      should.equal(durableNonceTxnJson.feePayer, testData.accountInfo.bs58EncodedPublicKey);\n      should.equal(durableNonceTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);\n      const solCoin = basecoin as any;\n      sandBox.assert.callCount(solCoin.getDataFromNode, 4);\n    });\n\n    it('should recover a txn for unsigned sweep recoveries', async function () {\n      // Unsigned Sweep Recovery\n      const unsignedSweepTxn = (await basecoin.recover({\n        bitgoKey: testData.keys.bitgoKey,\n        recoveryDestination: testData.keys.destinationPubKey,\n        durableNonce: {\n          publicKey: testData.keys.durableNoncePubKey,\n          secretKey: testData.keys.durableNoncePrivKey,\n        },\n      })) as MPCSweepTxs;\n\n      unsignedSweepTxn.should.not.be.empty();\n      unsignedSweepTxn.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');\n      unsignedSweepTxn.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('scanIndex');\n      should.equal(unsignedSweepTxn.txRequests[0].transactions[0].unsignedTx.scanIndex, 0);\n\n      const unsignedSweepTxnDeserialize = new Transaction(coin);\n      unsignedSweepTxnDeserialize.fromRawTransaction(\n        unsignedSweepTxn.txRequests[0].transactions[0].unsignedTx.serializedTx\n      );\n      const unsignedSweepTxnJson = unsignedSweepTxnDeserialize.toJson();\n\n      should.equal(unsignedSweepTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);\n      should.equal(unsignedSweepTxnJson.feePayer, testData.accountInfo.bs58EncodedPublicKey);\n      should.equal(unsignedSweepTxnJson.numSignatures, testData.SolInputData.unsignedSweepSignatures);\n      const solCoin = basecoin as any;\n      sandBox.assert.callCount(solCoin.getDataFromNode, 4);\n    });\n\n    it('should handle error in recover function if a required field is missing/incorrect', async function () {\n      // missing userkey\n      await basecoin\n        .recover({\n          backupKey: testData.keys.backupKey,\n          bitgoKey: testData.keys.bitgoKey,\n          recoveryDestination: testData.keys.destinationPubKey,\n          walletPassphrase: testData.keys.walletPassword,\n        })\n        .should.rejectedWith('missing userKey');\n\n      // missing backupkey\n      await basecoin\n        .recover({\n          userKey: testData.keys.userKey,\n          bitgoKey: testData.keys.bitgoKey,\n          recoveryDestination: testData.keys.destinationPubKey,\n          walletPassphrase: testData.keys.walletPassword,\n        })\n        .should.rejectedWith('missing backupKey');\n\n      // incorrect wallet passphrase, user key, backup key combination\n      await basecoin\n        .recover({\n          userKey: testData.keys.userKey,\n          backupKey: testData.keys.backupKey,\n          bitgoKey: testData.keys.bitgoKey,\n          recoveryDestination: testData.keys.destinationPubKey,\n          walletPassphrase: testData.keys.walletPassword + 'incorrect',\n        })\n        .should.rejectedWith(\"Error decrypting user keychain: password error - ccm: tag doesn't match\");\n\n      // no wallet with sufficient funds\n      await basecoin\n        .recover({\n          userKey: testData.keys.userKey,\n          backupKey: testData.keys.backupKey,\n          bitgoKey: testData.keys.bitgoKeyNoFunds,\n          recoveryDestination: testData.keys.destinationPubKey,\n          walletPassphrase: testData.keys.walletPassword,\n        })\n        .should.rejectedWith('Did not find address with funds to recover');\n    });\n\n    it('should recover sol tokens to recovery destination with no existing token accounts', async function () {\n      const tokenTxn = await basecoin.recover({\n        userKey: testData.wrwUser.userKey,\n        backupKey: testData.wrwUser.backupKey,\n        bitgoKey: testData.wrwUser.bitgoKey,\n        recoveryDestination: testData.keys.destinationPubKey,\n        tokenContractAddress: usdtMintAddress,\n        walletPassphrase: testData.wrwUser.walletPassphrase,\n        durableNonce: {\n          publicKey: testData.keys.durableNoncePubKey,\n          secretKey: testData.keys.durableNoncePrivKey,\n        },\n      });\n\n      tokenTxn.should.not.be.empty();\n      tokenTxn.should.hasOwnProperty('serializedTx');\n      tokenTxn.should.hasOwnProperty('scanIndex');\n      should.equal((tokenTxn as MPCTx).scanIndex, 0);\n\n      const tokenTxnDeserialize = new Transaction(coin);\n      tokenTxnDeserialize.fromRawTransaction((tokenTxn as MPCTx).serializedTx);\n      const tokenTxnJson = tokenTxnDeserialize.toJson();\n\n      should.equal(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);\n      should.equal(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);\n      should.equal(tokenTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);\n\n      const instructionsData = tokenTxnJson.instructionsData as InstructionParams[];\n      should.equal(instructionsData.length, 3);\n      should.equal(instructionsData[0].type, 'NonceAdvance');\n\n      const destinationUSDTTokenAccount = await getAssociatedTokenAccountAddress(\n        usdtMintAddress,\n        testData.keys.destinationPubKey\n      );\n      should.equal(instructionsData[1].type, 'CreateAssociatedTokenAccount');\n      should.equal((instructionsData[1] as AtaInit).params.mintAddress, usdtMintAddress);\n      should.equal((instructionsData[1] as AtaInit).params.ataAddress, destinationUSDTTokenAccount);\n      should.equal((instructionsData[1] as AtaInit).params.ownerAddress, testData.keys.destinationPubKey);\n      should.equal((instructionsData[1] as AtaInit).params.tokenName, 'tsol:usdt');\n      should.equal((instructionsData[1] as AtaInit).params.payerAddress, testData.wrwUser.walletAddress0);\n\n      const sourceUSDTTokenAccount = await getAssociatedTokenAccountAddress(\n        usdtMintAddress,\n        testData.wrwUser.walletAddress0\n      );\n      should.equal(instructionsData[2].type, 'TokenTransfer');\n      should.equal((instructionsData[2] as TokenTransfer).params.fromAddress, testData.wrwUser.walletAddress0);\n      should.equal((instructionsData[2] as TokenTransfer).params.toAddress, destinationUSDTTokenAccount);\n      should.equal((instructionsData[2] as TokenTransfer).params.amount, '2000000000');\n      should.equal((instructionsData[2] as TokenTransfer).params.tokenName, 'tsol:usdt');\n      should.equal((instructionsData[2] as TokenTransfer).params.sourceAddress, sourceUSDTTokenAccount);\n\n      const solCoin = basecoin as any;\n      sandBox.assert.callCount(solCoin.getDataFromNode, 7);\n    });\n\n    it('should recover sol 2022 tokens to recovery destination with no existing token accounts', async function () {\n      const tokenTxn = await basecoin.recover({\n        userKey: testData.wrwUser.userKey,\n        backupKey: testData.wrwUser.backupKey,\n        bitgoKey: testData.wrwUser.bitgoKey,\n        recoveryDestination: testData.keys.destinationPubKey,\n        tokenContractAddress: t22mintAddress,\n        walletPassphrase: testData.wrwUser.walletPassphrase,\n        durableNonce: {\n          publicKey: testData.keys.durableNoncePubKey,\n          secretKey: testData.keys.durableNoncePrivKey,\n        },\n        programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',\n      });\n\n      tokenTxn.should.not.be.empty();\n      tokenTxn.should.hasOwnProperty('serializedTx');\n      tokenTxn.should.hasOwnProperty('scanIndex');\n      should.equal((tokenTxn as MPCTx).scanIndex, 0);\n\n      const tokenTxnDeserialize = new Transaction(coin);\n      tokenTxnDeserialize.fromRawTransaction((tokenTxn as MPCTx).serializedTx);\n      const tokenTxnJson = tokenTxnDeserialize.toJson();\n\n      should.equal(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);\n      should.equal(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);\n      should.equal(tokenTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);\n\n      const instructionsData = tokenTxnJson.instructionsData as InstructionParams[];\n      should.equal(instructionsData.length, 3);\n      should.equal(instructionsData[0].type, 'NonceAdvance');\n\n      const destinationTokenAccount = await getAssociatedTokenAccountAddress(\n        t22mintAddress,\n        testData.keys.destinationPubKey\n      );\n      should.equal(instructionsData[1].type, 'CreateAssociatedTokenAccount');\n      should.equal((instructionsData[1] as AtaInit).params.mintAddress, t22mintAddress);\n      should.equal((instructionsData[1] as AtaInit).params.ataAddress, destinationTokenAccount);\n      should.equal((instructionsData[1] as AtaInit).params.ownerAddress, testData.keys.destinationPubKey);\n      should.equal((instructionsData[1] as AtaInit).params.tokenName, 'tsol:t22mint');\n      should.equal((instructionsData[1] as AtaInit).params.payerAddress, testData.wrwUser.walletAddress0);\n\n      const sourceTokenAccount = await getAssociatedTokenAccountAddress(\n        t22mintAddress,\n        testData.wrwUser.walletAddress0\n      );\n      should.equal(instructionsData[2].type, 'TokenTransfer');\n      should.equal((instructionsData[2] as TokenTransfer).params.fromAddress, testData.wrwUser.walletAddress0);\n      should.equal((instructionsData[2] as TokenTransfer).params.toAddress, destinationTokenAccount);\n      should.equal((instructionsData[2] as TokenTransfer).params.amount, '2000000000');\n      should.equal((instructionsData[2] as TokenTransfer).params.tokenName, 'tsol:t22mint');\n      should.equal((instructionsData[2] as TokenTransfer).params.sourceAddress, sourceTokenAccount);\n      should.equal(\n        (instructionsData[2] as TokenTransfer).params.programId,\n        'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb'\n      );\n\n      const solCoin = basecoin as any;\n      sandBox.assert.callCount(solCoin.getDataFromNode, 7);\n    });\n\n    it('should recover sol tokens to recovery destination with existing token accounts', async function () {\n      const tokenTxn = await basecoin.recover({\n        userKey: testData.wrwUser.userKey,\n        backupKey: testData.wrwUser.backupKey,\n        bitgoKey: testData.wrwUser.bitgoKey,\n        recoveryDestination: testData.keys.destinationPubKey2,\n        tokenContractAddress: usdtMintAddress,\n        walletPassphrase: testData.wrwUser.walletPassphrase,\n        durableNonce: {\n          publicKey: testData.keys.durableNoncePubKey,\n          secretKey: testData.keys.durableNoncePrivKey,\n        },\n      });\n\n      tokenTxn.should.not.be.empty();\n      tokenTxn.should.hasOwnProperty('serializedTx');\n      tokenTxn.should.hasOwnProperty('scanIndex');\n      should.equal((tokenTxn as MPCTx).scanIndex, 0);\n\n      const tokenTxnDeserialize = new Transaction(coin);\n      tokenTxnDeserialize.fromRawTransaction((tokenTxn as MPCTx).serializedTx);\n      const tokenTxnJson = tokenTxnDeserialize.toJson();\n\n      should.equal(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);\n      should.equal(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);\n      should.equal(tokenTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);\n\n      const instructionsData = tokenTxnJson.instructionsData as TokenTransfer[];\n      should.equal(instructionsData.length, 2);\n      should.equal(instructionsData[0].type, 'NonceAdvance');\n\n      const sourceUSDTTokenAccount = await getAssociatedTokenAccountAddress(\n        usdtMintAddress,\n        testData.wrwUser.walletAddress0\n      );\n      const destinationUSDTTokenAccount = await getAssociatedTokenAccountAddress(\n        usdtMintAddress,\n        testData.keys.destinationPubKey2\n      );\n      should.equal(instructionsData[1].type, 'TokenTransfer');\n      should.equal(instructionsData[1].params.fromAddress, testData.wrwUser.walletAddress0);\n      should.equal(instructionsData[1].params.toAddress, destinationUSDTTokenAccount);\n      should.equal(instructionsData[1].params.amount, '2000000000');\n      should.equal(instructionsData[1].params.tokenName, 'tsol:usdt');\n      should.equal(instructionsData[1].params.sourceAddress, sourceUSDTTokenAccount);\n\n      const solCoin = basecoin as any;\n      sandBox.assert.callCount(solCoin.getDataFromNode, 7);\n    });\n\n    it('should recover sol 2022 tokens to recovery destination with existing token accounts', async function () {\n      const tokenTxn = await basecoin.recover({\n        userKey: testData.wrwUser.userKey,\n        backupKey: testData.wrwUser.backupKey,\n        bitgoKey: testData.wrwUser.bitgoKey,\n        recoveryDestination: testData.keys.destinationPubKey2,\n        tokenContractAddress: t22mintAddress,\n        walletPassphrase: testData.wrwUser.walletPassphrase,\n        durableNonce: {\n          publicKey: testData.keys.durableNoncePubKey,\n          secretKey: testData.keys.durableNoncePrivKey,\n        },\n        programId: TOKEN_2022_PROGRAM_ID.toString(),\n      });\n\n      tokenTxn.should.not.be.empty();\n      tokenTxn.should.hasOwnProperty('serializedTx');\n      tokenTxn.should.hasOwnProperty('scanIndex');\n      should.equal((tokenTxn as MPCTx).scanIndex, 0);\n\n      const tokenTxnDeserialize = new Transaction(coin);\n      tokenTxnDeserialize.fromRawTransaction((tokenTxn as MPCTx).serializedTx);\n      const tokenTxnJson = tokenTxnDeserialize.toJson();\n      console.log(tokenTxnJson);\n      should.equal(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);\n      should.equal(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);\n      should.equal(tokenTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);\n\n      const instructionsData = tokenTxnJson.instructionsData as TokenTransfer[];\n      should.equal(instructionsData.length, 2);\n      should.equal(instructionsData[0].type, 'NonceAdvance');\n\n      const source2022TokenAccount = await getAssociatedTokenAccountAddress(\n        t22mintAddress,\n        testData.wrwUser.walletAddress0,\n        false,\n        TOKEN_2022_PROGRAM_ID.toString()\n      );\n      const destination2022TokenAccount = await getAssociatedTokenAccountAddress(\n        t22mintAddress,\n        testData.keys.destinationPubKey2,\n        false,\n        TOKEN_2022_PROGRAM_ID.toString()\n      );\n      should.equal(instructionsData[1].type, 'TokenTransfer');\n      should.equal(instructionsData[1].params.fromAddress, testData.wrwUser.walletAddress0);\n      should.equal(instructionsData[1].params.toAddress, destination2022TokenAccount);\n      should.equal(instructionsData[1].params.amount, '2000000000');\n      should.equal(instructionsData[1].params.tokenName, 'tsol:t22mint');\n      should.equal(instructionsData[1].params.sourceAddress, source2022TokenAccount);\n      const solCoin = basecoin as any;\n      sandBox.assert.callCount(solCoin.getDataFromNode, 7);\n    });\n\n    it('should recover sol tokens to recovery destination with existing token accounts for unsigned sweep recoveries', async function () {\n      const feeResponse = testData.SolResponses.getFeesForMessageResponse;\n      feeResponse.body.result.value = 10000;\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getFeeForMessage',\n            params: [\n              sinon.match.string,\n              {\n                commitment: 'finalized',\n              },\n            ],\n          },\n        })\n        .resolves(feeResponse);\n\n      const tokenTxn = (await basecoin.recover({\n        bitgoKey: testData.wrwUser.bitgoKey,\n        recoveryDestination: testData.keys.destinationPubKey2,\n        durableNonce: {\n          publicKey: testData.keys.durableNoncePubKey,\n          secretKey: testData.keys.durableNoncePrivKey,\n        },\n        tokenContractAddress: testData.tokenAddress.TestUSDC,\n      })) as MPCSweepTxs;\n\n      // 2 signatures and no rent exemption fee since the destination already has token accounts\n      const expectedFee = 5000 + 5000;\n\n      const { serializedTx, scanIndex, feeInfo, parsedTx } = tokenTxn.txRequests[0].transactions[0].unsignedTx;\n      assert.ok(serializedTx);\n      assert.strictEqual(scanIndex, 0);\n      assert.ok(feeInfo);\n      assert.strictEqual(feeInfo.feeString, expectedFee.toString());\n      assert.strictEqual(feeInfo.fee, expectedFee);\n      assert.ok(parsedTx);\n      assert.ok(parsedTx.inputs instanceof Array && parsedTx.inputs.length === 1);\n      assert.ok(parsedTx.outputs instanceof Array && parsedTx.outputs.length === 1);\n\n      const tokenTxnDeserialize = new Transaction(coin);\n      tokenTxnDeserialize.fromRawTransaction(tokenTxn.txRequests[0].transactions[0].unsignedTx.serializedTx);\n      const tokenTxnJson = tokenTxnDeserialize.toJson();\n\n      assert.strictEqual(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);\n      assert.strictEqual(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);\n      assert.strictEqual(tokenTxnJson.numSignatures, testData.SolInputData.unsignedSweepSignatures);\n      const solCoin = basecoin as any;\n      sandBox.assert.callCount(solCoin.getDataFromNode, 7);\n    });\n\n    it('should recover sol funds from ATA address for non-bitgo recoveries', async function () {\n      // close ATA address instruction type txn\n      const closeATATxns = await basecoin.recoverCloseATA({\n        userKey: testData.closeATAkeys.userKey,\n        backupKey: testData.closeATAkeys.backupKey,\n        bitgoKey: testData.closeATAkeys.bitgoKey,\n        recoveryDestination: testData.closeATAkeys.destinationPubKey,\n        walletPassphrase: testData.closeATAkeys.walletPassword,\n        closeAtaAddress: testData.closeATAkeys.closeAtaAddress,\n        recoveryDestinationAtaAddress: testData.closeATAkeys.recoveryDestinationAtaAddress,\n      });\n      closeATATxns.should.not.be.empty();\n      should.equal(\n        closeATATxns[0].txId,\n        '2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb'\n      );\n      should.equal(\n        closeATATxns[1].txId,\n        '5oUBgXX4enGmFEspG64goy3PRysjfrekZGg3rZNkBHUCQFd482vrVWbfDcRYMBEJt65JXymfEPm8M6d89X4xV79n'\n      );\n    });\n\n    it('should recover tokens from a nested ATA (ATA whose owner is another ATA)', async function () {\n      const result = await basecoin.recoverNestedAta({\n        userKey: testData.closeATAkeys.userKey,\n        backupKey: testData.closeATAkeys.backupKey,\n        bitgoKey: testData.closeATAkeys.bitgoKey,\n        recoveryDestination: testData.closeATAkeys.destinationPubKey,\n        walletPassphrase: testData.closeATAkeys.walletPassword,\n        nestedAtaAddress: 'FGuZSBhtreqSUsE86xokyjKz2i8VBtJzy6uMXXKyGHug',\n        ownerAtaAddress: 'Zfm98ZpVafydhFTYcsY6bHgubhB4cFgWFvbdEJxYhTA',\n        tokenMintAddress: 'ZBCNpuD7YMXzTHB2fhGkGi78MNsHGLRXUhRewNRm9RU',\n      });\n\n      result.should.not.be.empty();\n      should.equal(\n        result.txId,\n        '2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb'\n      );\n    });\n\n    it('should throw when nestedAtaAddress is missing for recoverNestedAta', async function () {\n      await basecoin\n        .recoverNestedAta({\n          userKey: testData.closeATAkeys.userKey,\n          backupKey: testData.closeATAkeys.backupKey,\n          bitgoKey: testData.closeATAkeys.bitgoKey,\n          recoveryDestination: testData.closeATAkeys.destinationPubKey,\n          walletPassphrase: testData.closeATAkeys.walletPassword,\n          ownerAtaAddress: 'Zfm98ZpVafydhFTYcsY6bHgubhB4cFgWFvbdEJxYhTA',\n          tokenMintAddress: 'ZBCNpuD7YMXzTHB2fhGkGi78MNsHGLRXUhRewNRm9RU',\n        })\n        .should.be.rejectedWith('invalid nestedAtaAddress');\n    });\n\n    it('should throw when ownerAtaAddress is missing for recoverNestedAta', async function () {\n      await basecoin\n        .recoverNestedAta({\n          userKey: testData.closeATAkeys.userKey,\n          backupKey: testData.closeATAkeys.backupKey,\n          bitgoKey: testData.closeATAkeys.bitgoKey,\n          recoveryDestination: testData.closeATAkeys.destinationPubKey,\n          walletPassphrase: testData.closeATAkeys.walletPassword,\n          nestedAtaAddress: 'FGuZSBhtreqSUsE86xokyjKz2i8VBtJzy6uMXXKyGHug',\n          tokenMintAddress: 'ZBCNpuD7YMXzTHB2fhGkGi78MNsHGLRXUhRewNRm9RU',\n        })\n        .should.be.rejectedWith('invalid ownerAtaAddress');\n    });\n\n    it('should throw when tokenMintAddress is missing for recoverNestedAta', async function () {\n      await basecoin\n        .recoverNestedAta({\n          userKey: testData.closeATAkeys.userKey,\n          backupKey: testData.closeATAkeys.backupKey,\n          bitgoKey: testData.closeATAkeys.bitgoKey,\n          recoveryDestination: testData.closeATAkeys.destinationPubKey,\n          walletPassphrase: testData.closeATAkeys.walletPassword,\n          nestedAtaAddress: 'FGuZSBhtreqSUsE86xokyjKz2i8VBtJzy6uMXXKyGHug',\n          ownerAtaAddress: 'Zfm98ZpVafydhFTYcsY6bHgubhB4cFgWFvbdEJxYhTA',\n        })\n        .should.be.rejectedWith('invalid tokenMintAddress');\n    });\n  });\n\n  describe('Build Consolidation Recoveries:', () => {\n    const sandBox = sinon.createSandbox();\n    const coin = coins.get('tsol');\n    const usdtMintAddress = '9cgpBeNZ2HnLda7NWaaU1i3NyTstk2c4zCMUcoAGsi9C';\n    const durableNonces = {\n      publicKeys: [\n        testData.keys.durableNoncePubKey,\n        testData.keys.durableNoncePubKey2,\n        testData.keys.durableNoncePubKey3,\n      ],\n      secretKey: testData.keys.durableNoncePrivKey,\n    };\n\n    beforeEach(() => {\n      const callBack = sandBox.stub(Sol.prototype, 'getDataFromNode' as keyof Sol);\n\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getLatestBlockhash',\n            params: [\n              {\n                commitment: 'finalized',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getBlockhashResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getFeeForMessage',\n            params: [\n              sinon.match.string,\n              {\n                commitment: 'finalized',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getFeesForMessageResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.wrwUser.walletAddress1],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponseNoFunds);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.wrwUser.walletAddress2],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.wrwUser.walletAddress3],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getBalance',\n            params: [testData.wrwUser.walletAddress5],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountBalanceResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getMinimumBalanceForRentExemption',\n            params: [165],\n          },\n        })\n        .resolves(testData.SolResponses.getMinimumBalanceForRentExemptionResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getAccountInfo',\n            params: [\n              testData.keys.durableNoncePubKey,\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountInfoResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getAccountInfo',\n            params: [\n              testData.keys.durableNoncePubKey2,\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getAccountInfoResponse2);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.wrwUser.walletAddress1,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.wrwUser.walletAddress2,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.wrwUser.walletAddress3,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponseNoAccounts);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.wrwUser.walletAddress5,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse);\n      callBack\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getTokenAccountsByOwner',\n            params: [\n              testData.wrwUser.walletAddress0,\n              {\n                programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',\n              },\n              {\n                encoding: 'jsonParsed',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse);\n    });\n\n    afterEach(() => {\n      sandBox.restore();\n    });\n\n    it('should build signed consolidation recoveries', async function () {\n      const res = (await basecoin.recoverConsolidations({\n        userKey: testData.wrwUser.userKey,\n        backupKey: testData.wrwUser.backupKey,\n        bitgoKey: testData.wrwUser.bitgoKey,\n        walletPassphrase: testData.wrwUser.walletPassphrase,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n        durableNonces: durableNonces,\n      })) as MPCTxs;\n      res.should.not.be.empty();\n      res.transactions.length.should.equal(2);\n      (res.lastScanIndex ?? 0).should.equal(3);\n\n      const txn1 = res.transactions[0];\n      const latestBlockhashTxnDeserialize1 = new Transaction(coin);\n      latestBlockhashTxnDeserialize1.fromRawTransaction((txn1 as MPCTx).serializedTx);\n      const latestBlockhashTxnJson1 = latestBlockhashTxnDeserialize1.toJson();\n\n      const nonce1 = testData.SolResponses.getAccountInfoResponse.body.result.value.data.parsed.info.blockhash;\n      should.equal(latestBlockhashTxnJson1.nonce, nonce1);\n      should.equal(latestBlockhashTxnJson1.feePayer, testData.wrwUser.walletAddress2);\n      should.equal(latestBlockhashTxnJson1.numSignatures, testData.SolInputData.durableNonceSignatures);\n\n      const txn2 = res.transactions[1];\n      const latestBlockhashTxnDeserialize2 = new Transaction(coin);\n      latestBlockhashTxnDeserialize2.fromRawTransaction((txn2 as MPCTx).serializedTx);\n      const latestBlockhashTxnJson2 = latestBlockhashTxnDeserialize2.toJson();\n\n      const nonce2 = testData.SolResponses.getAccountInfoResponse2.body.result.value.data.parsed.info.blockhash;\n      should.equal(latestBlockhashTxnJson2.nonce, nonce2);\n      should.equal(latestBlockhashTxnJson2.feePayer, testData.wrwUser.walletAddress3);\n      should.equal(latestBlockhashTxnJson2.numSignatures, testData.SolInputData.durableNonceSignatures);\n    });\n\n    it('should build unsigned consolidation recoveries', async function () {\n      const res = (await basecoin.recoverConsolidations({\n        bitgoKey: testData.wrwUser.bitgoKey,\n        startingScanIndex: 1,\n        endingScanIndex: 4,\n        durableNonces: durableNonces,\n      })) as MPCSweepTxs;\n      res.should.not.be.empty();\n      res.txRequests.length.should.equal(2);\n\n      const txn1 = res.txRequests[0].transactions[0].unsignedTx;\n      txn1.should.hasOwnProperty('serializedTx');\n      txn1.should.hasOwnProperty('signableHex');\n      txn1.should.hasOwnProperty('scanIndex');\n      (txn1.scanIndex ?? 0).should.equal(2);\n      txn1.should.hasOwnProperty('coin');\n      txn1.coin?.should.equal('tsol');\n      txn1.should.hasOwnProperty('derivationPath');\n      txn1.derivationPath?.should.equal('m/2');\n\n      txn1.should.hasOwnProperty('coinSpecific');\n      const coinSpecific1 = txn1.coinSpecific;\n      coinSpecific1?.should.hasOwnProperty('commonKeychain');\n\n      const latestBlockhashTxnDeserialize1 = new Transaction(coin);\n      latestBlockhashTxnDeserialize1.fromRawTransaction((txn1 as MPCTx).serializedTx);\n      const latestBlockhashTxnJson1 = latestBlockhashTxnDeserialize1.toJson();\n\n      const nonce1 = testData.SolResponses.getAccountInfoResponse.body.result.value.data.parsed.info.blockhash;\n      should.equal(latestBlockhashTxnJson1.nonce, nonce1);\n      should.equal(latestBlockhashTxnJson1.feePayer, testData.wrwUser.walletAddress2);\n      should.equal(latestBlockhashTxnJson1.numSignatures, testData.SolInputData.unsignedSweepSignatures);\n\n      const txn2 = res.txRequests[1].transactions[0].unsignedTx;\n      txn2.should.hasOwnProperty('serializedTx');\n      txn2.should.hasOwnProperty('signableHex');\n      txn2.should.hasOwnProperty('scanIndex');\n      (txn2.scanIndex ?? 0).should.equal(3);\n      txn2.should.hasOwnProperty('coin');\n      txn2.coin?.should.equal('tsol');\n      txn2.should.hasOwnProperty('derivationPath');\n      txn2.derivationPath?.should.equal('m/3');\n\n      txn2.should.hasOwnProperty('coinSpecific');\n      const coinSpecific2 = txn2.coinSpecific;\n      coinSpecific2?.should.hasOwnProperty('commonKeychain');\n      coinSpecific2?.should.hasOwnProperty('lastScanIndex');\n      coinSpecific2?.lastScanIndex?.should.equal(3);\n\n      const latestBlockhashTxnDeserialize2 = new Transaction(coin);\n      latestBlockhashTxnDeserialize2.fromRawTransaction((txn2 as MPCTx).serializedTx);\n      const latestBlockhashTxnJson2 = latestBlockhashTxnDeserialize2.toJson();\n\n      const nonce2 = testData.SolResponses.getAccountInfoResponse2.body.result.value.data.parsed.info.blockhash;\n      should.equal(latestBlockhashTxnJson2.nonce, nonce2);\n      should.equal(latestBlockhashTxnJson2.feePayer, testData.wrwUser.walletAddress3);\n      should.equal(latestBlockhashTxnJson2.numSignatures, testData.SolInputData.unsignedSweepSignatures);\n    });\n\n    it('should build unsigned token consolidation recoveries', async function () {\n      const res = (await basecoin.recoverConsolidations({\n        bitgoKey: testData.wrwUser.bitgoKey,\n        startingScanIndex: 3,\n        endingScanIndex: 5,\n        tokenContractAddress: usdtMintAddress,\n        durableNonces: durableNonces,\n      })) as MPCSweepTxs;\n      res.should.not.be.empty();\n      res.txRequests.length.should.equal(1);\n\n      const txn1 = res.txRequests[0].transactions[0].unsignedTx;\n      txn1.should.hasOwnProperty('serializedTx');\n      txn1.should.hasOwnProperty('signableHex');\n      txn1.should.hasOwnProperty('scanIndex');\n      (txn1.scanIndex ?? 0).should.equal(4);\n      txn1.should.hasOwnProperty('coin');\n      txn1.coin?.should.equal('tsol');\n      txn1.should.hasOwnProperty('derivationPath');\n      txn1.derivationPath?.should.equal('m/4');\n\n      txn1.should.hasOwnProperty('coinSpecific');\n      const coinSpecific1 = txn1.coinSpecific;\n      coinSpecific1?.should.hasOwnProperty('commonKeychain');\n\n      const latestBlockhashTxnDeserialize1 = new Transaction(coin);\n      latestBlockhashTxnDeserialize1.fromRawTransaction((txn1 as MPCTx).serializedTx);\n      const latestBlockhashTxnJson1 = latestBlockhashTxnDeserialize1.toJson();\n\n      const nonce1 = testData.SolResponses.getAccountInfoResponse.body.result.value.data.parsed.info.blockhash;\n      should.equal(latestBlockhashTxnJson1.nonce, nonce1);\n      should.equal(latestBlockhashTxnJson1.feePayer, testData.wrwUser.walletAddress5);\n      should.equal(latestBlockhashTxnJson1.numSignatures, testData.SolInputData.unsignedSweepSignatures);\n    });\n\n    it('should skip building consolidate transaction if balance is equal to zero', async function () {\n      await basecoin\n        .recoverConsolidations({\n          userKey: testData.wrwUser.userKey,\n          backupKey: testData.wrwUser.backupKey,\n          bitgoKey: testData.wrwUser.bitgoKey,\n          walletPassphrase: testData.wrwUser.walletPassphrase,\n          startingScanIndex: 1,\n          endingScanIndex: 2,\n          durableNonces: durableNonces,\n        })\n        .should.rejectedWith('Did not find an address with funds to recover');\n    });\n\n    it('should throw if startingScanIndex is not ge to 1', async () => {\n      await basecoin\n        .recoverConsolidations({\n          userKey: testData.wrwUser.userKey,\n          backupKey: testData.wrwUser.backupKey,\n          bitgoKey: testData.wrwUser.bitgoKey,\n          startingScanIndex: -1,\n          durableNonces: durableNonces,\n        })\n        .should.be.rejectedWith(\n          'Invalid starting or ending index to scan for addresses. startingScanIndex: -1, endingScanIndex: 19.'\n        );\n    });\n\n    it('should throw if scan factor is too high', async () => {\n      await basecoin\n        .recoverConsolidations({\n          userKey: testData.wrwUser.userKey,\n          backupKey: testData.wrwUser.backupKey,\n          bitgoKey: testData.wrwUser.bitgoKey,\n          startingScanIndex: 1,\n          endingScanIndex: 300,\n          durableNonces: durableNonces,\n        })\n        .should.be.rejectedWith(\n          'Invalid starting or ending index to scan for addresses. startingScanIndex: 1, endingScanIndex: 300.'\n        );\n    });\n  });\n\n  describe('broadcastTransaction', function () {\n    const sandBox = sinon.createSandbox();\n\n    afterEach(() => {\n      sandBox.restore();\n    });\n\n    it('should broadcast a transaction succesfully', async function () {\n      const serializedSignedTransaction = testData.rawTransactions.transfer.signed;\n      const broadcastStub = sandBox\n        .stub(Sol.prototype, 'getDataFromNode' as keyof Sol)\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'sendTransaction',\n            params: [\n              serializedSignedTransaction,\n              {\n                encoding: 'base64',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.broadcastTransactionResponse);\n\n      const broadcastTxn = await basecoin.broadcastTransaction({ serializedSignedTransaction });\n      assert.ok(broadcastTxn);\n      assert.ok(broadcastTxn.txId);\n      assert.strictEqual(\n        broadcastTxn.txId,\n        '2id3YC2jK9G5Wo2phDx4gJVAew8DcY5NAojnVuao8rkxwPYPe8cSwE5GzhEgJA2y8fVjDEo6iR6ykBvDxrTQrtpb'\n      );\n      assert.strictEqual(broadcastStub.callCount, 1);\n    });\n\n    it('should throw if got an error from the node', async function () {\n      const serializedSignedTransaction = testData.rawTransactions.transfer.signed;\n      const broadcastStub = sandBox\n        .stub(Sol.prototype, 'getDataFromNode' as keyof Sol)\n        .withArgs({\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'sendTransaction',\n            params: [\n              serializedSignedTransaction,\n              {\n                encoding: 'base64',\n              },\n            ],\n          },\n        })\n        .resolves(testData.SolResponses.broadcastTransactionResponseError);\n\n      await assert.rejects(\n        async () => {\n          await basecoin.broadcastTransaction({ serializedSignedTransaction });\n        },\n        { message: 'Error broadcasting transaction: Transaction simulation failed: Blockhash not found' }\n      );\n      assert.strictEqual(broadcastStub.callCount, 1);\n    });\n\n    it('should throw if is not a valid transaction', async function () {\n      const serializedSignedTransaction = 'randomstring';\n\n      await assert.rejects(\n        async () => {\n          await basecoin.broadcastTransaction({ serializedSignedTransaction });\n        },\n        { message: 'Invalid raw transaction' }\n      );\n    });\n\n    it('should throw if is not a signed transaction', async function () {\n      const serializedSignedTransaction = testData.rawTransactions.transfer.unsigned;\n\n      await assert.rejects(\n        async () => {\n          await basecoin.broadcastTransaction({ serializedSignedTransaction });\n        },\n        { message: 'Invalid raw transaction' }\n      );\n    });\n  });\n\n  describe('AuditKey', () => {\n    const { key: keyString, commonKeychain } = solBackupKey;\n    const key = keyString.replace(/\\s/g, '');\n    const walletPassphrase = 'kAm[EFQ6o=SxlcLFDw%,';\n    const multiSigType = 'tss';\n\n    it('should return for valid inputs', () => {\n      basecoin.assertIsValidKey({\n        encryptedPrv: key,\n        publicKey: commonKeychain,\n        walletPassphrase,\n        multiSigType,\n      });\n    });\n\n    it('should throw error if the commonKeychain is invalid', () => {\n      const alteredCommonKeychain = generateRandomPassword(10);\n      assert.throws(\n        () =>\n          basecoin.assertIsValidKey({\n            encryptedPrv: key,\n            publicKey: alteredCommonKeychain,\n            walletPassphrase,\n            multiSigType,\n          }),\n        {\n          message: 'Invalid common keychain',\n        }\n      );\n    });\n\n    it('should throw error if the walletPassphrase is incorrect', () => {\n      const incorrectPassphrase = 'foo';\n      assert.throws(\n        () =>\n          basecoin.assertIsValidKey({\n            encryptedPrv: key,\n            publicKey: commonKeychain,\n            walletPassphrase: incorrectPassphrase,\n            multiSigType,\n          }),\n        {\n          message: \"failed to decrypt prv: ccm: tag doesn't match\",\n        }\n      );\n    });\n\n    it('should throw error if the key is altered', () => {\n      const alteredKey = key.replace(/[0-9]/g, '0');\n      assert.throws(\n        () =>\n          basecoin.assertIsValidKey({\n            encryptedPrv: alteredKey,\n            publicKey: commonKeychain,\n            walletPassphrase,\n            multiSigType,\n          }),\n        {\n          message: 'failed to decrypt prv: json decrypt: invalid parameters',\n        }\n      );\n    });\n\n    it('should verify consolidation transaction', async function () {\n      // Set up wallet data\n      const walletData = {\n        id: '5b34252f1bf349930e34020a00000000',\n        coin: 'tsol',\n        keys: [\n          '5b3424f91bf349930e34017500000000',\n          '5b3424f91bf349930e34017600000000',\n          '5b3424f91bf349930e34017700000000',\n        ],\n        coinSpecific: {\n          rootAddress: wallet.pub,\n        },\n        multisigType: 'tss',\n      };\n      const fakePrv = 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/tsol/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/tsol/wallet/5b34252f1bf349930e34020a00000000/consolidateAccount/build')\n        .reply(200, [\n          {\n            txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',\n            walletId: '63068ed4efa63a000877f02fd4b0fa6d',\n            txHex:\n              '02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006f50130abf8d0d8943c5b9a51a574886a7d7b3d8db18f0ddb4ab8b6d3ec27e3c2f36f3339bb92d4296af6ae4d3abfbb07877f77d0033c883de08fa4a2eea670d0201020674a9df2b94aa4b4ada1202dc2891be366501d0acb4a01ca3e02e7fd6c1f505a71c96172044f1217c3784e8f02f49e2c8fc3591e81294ab54394f9d22fd7b7a8f8401c3f67cfa52518b34a09b08f4ea77e1c4fb9d89bfaccdc33cf8b8a9cf8d7bf0e04c89c50428e4eda5cbb759427c370f0a29a50bb0d1407e57924b0cc5b36f000000000000000000000000000000000000000000000000000000000000000006a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea940000040c9568195d67eb6b396fdbe97ba2e276622ef0023af09f23e6e0292abb678d90204030305010404000000040200020c020000000100000000000000',\n            feeInfo: {\n              fee: 10000,\n              feeString: '10000',\n            },\n            txInfo: {\n              minerFee: '10000',\n              spendAmount: '1547864',\n              spendAmounts: [\n                {\n                  coinName: 'tsol',\n                  amountString: '1547864',\n                },\n              ],\n              payGoFee: '0',\n              outputs: [\n                {\n                  address: '8rQXeVEMrKvtWCEJirEM6cKYnbZuTqVTbqRPiMMAJ8R4',\n                  value: 1547864,\n                  wallet: '63068ed4efa63a000877f02f',\n                  wallets: ['63068ed4efa63a000877f02f'],\n                  enterprise: '62d71a6b86068f0008f029fd',\n                  enterprises: ['62d71a6b86068f0008f029fd'],\n                  valueString: '1547864',\n                  coinName: 'tsol',\n                  walletType: 'hot',\n                  walletTypes: ['hot'],\n                },\n              ],\n              inputs: [\n                {\n                  value: 1547864,\n                  address: 'CmYsN3f8bcm4BDkFJWNsvYgjRxMTLH6vbJWNfYdmH7GU',\n                  valueString: '1547864',\n                },\n                {\n                  value: 10000,\n                  address: 'CmYsN3f8bcm4BDkFJWNsvYgjRxMTLH6vbJWNfYdmH7GU',\n                  valueString: '10000',\n                },\n              ],\n              type: 'Send',\n            },\n            consolidateId: '68a7d5d0c66e74e216b97173bd558c6d',\n            coin: 'tsol',\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    it('should verify valid a consolidation transaction', async () => {\n      const consolidationTx = {\n        txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',\n        walletId: '63068ed4efa63a000877f02fd4b0fa6d',\n        txHex:\n          '02000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002010206aeda253a331de489838246df93879440af8c62ac4967658edc2bb5d52b9759d91c96172044f1217c3784e8f02f49e2c8fc3591e81294ab54394f9d22fd7b7a8f74a9df2b94aa4b4ada1202dc2891be366501d0acb4a01ca3e02e7fd6c1f505a7d2734f3952f3eb4aefcf6c7a6092e979dd3fe5563ccfaca1cc92652a15ddd393000000000000000000000000000000000000000000000000000000000000000006a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea9400000428dad41bbedeb38018379e4ceeb7e80757d74dd00ae8c47c38d597477339ad80204030305010404000000040200020c02000000589e170000000000',\n        feeInfo: {\n          fee: 10000,\n          feeString: '10000',\n        },\n        txInfo: {\n          minerFee: '10000',\n          spendAmount: '1547864',\n          spendAmounts: [\n            {\n              coinName: 'tsol',\n              amountString: '1547864',\n            },\n          ],\n          payGoFee: '0',\n          outputs: [\n            {\n              address: '8rQXeVEMrKvtWCEJirEM6cKYnbZuTqVTbqRPiMMAJ8R4',\n              value: 1547864,\n              wallet: '63068ed4efa63a000877f02f',\n              wallets: ['63068ed4efa63a000877f02f'],\n              enterprise: '62d71a6b86068f0008f029fd',\n              enterprises: ['62d71a6b86068f0008f029fd'],\n              valueString: '1547864',\n              coinName: 'tsol',\n              walletType: 'hot',\n              walletTypes: ['hot'],\n            },\n          ],\n          inputs: [\n            {\n              value: 1547864,\n              address: 'CmYsN3f8bcm4BDkFJWNsvYgjRxMTLH6vbJWNfYdmH7GU',\n              valueString: '1547864',\n            },\n            {\n              value: 10000,\n              address: 'CmYsN3f8bcm4BDkFJWNsvYgjRxMTLH6vbJWNfYdmH7GU',\n              valueString: '10000',\n            },\n          ],\n          type: 'Send',\n        },\n        consolidateId: '68a7d5d0c66e74e216b97173bd558c6d',\n        coin: 'tsol',\n      };\n\n      const mockedWallet: Partial<IWallet> = {\n        coinSpecific: () => {\n          const cs = {\n            rootAddress: '8rQXeVEMrKvtWCEJirEM6cKYnbZuTqVTbqRPiMMAJ8R4',\n          } as WalletCoinSpecific;\n          return cs;\n        },\n      };\n\n      try {\n        if (\n          !(await basecoin.verifyTransaction({\n            blockhash: '',\n            feePayer: '',\n            txParams: {},\n            txPrebuild: consolidationTx as unknown as TransactionPrebuild,\n            walletType: 'tss',\n            wallet: mockedWallet as IWallet,\n            verification: {\n              consolidationToBaseAddress: true,\n            },\n          }))\n        ) {\n          assert.fail('Transaction should pass verification');\n        }\n      } catch (e) {\n        assert.fail('Transaction should pass verification');\n      }\n    });\n\n    it('should verify a token consolidation transaction', async () => {\n      const consolidationTx = {\n        txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',\n        walletId: '63068ed4efa63a000877f02fd4b0fa6d',\n        txHex:\n          '02b7c2c7829eded4e8f947c90ed3b9afce71f616eb47dfcfbf4b765778149060013acb33b9f67fdd9c2512f48fac4e4c049eab93829b69404f3bd166fe3242c90700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020104096da690bd558fd8634ac14f1645d8095afd0caea5953578c596e3c0dea38305ee7298bfac55101f177735659d42ed6be890ef3a1d204d9e33f32e24c5635327ca66d1fe00826e5a4f759f87b279c1aee19cce5301af4ed66ae17db48b201ed6c2a0e8a28bf565627f1ab8a34b1a95ee1b0a2a39084f1f0e2acb1c394b20185d8e0b22657c8d9c4ce5f6495efb6410c199011530f90e3ab9d8d1e4206f9ae0ffeb0000000000000000000000000000000000000000000000000000000000000000c5f9fb32f49111ab20c33f2598fc836c113e291881ac21ee29169394011244e406a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea940000006ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9de13c74d2b4d948e1608ea6eebdafe75bc2f995aad11b21d1e2c94f2a2d12f6802050303070004040000000804020604010a0ce0076bb20400000006',\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: 'HBxZShcE86UMmF93KUM8eWJKqeEXi5cqWCLYLMMhqMYm',\n              coinName: 'sol:wif',\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: 'sol:wif',\n            },\n          ],\n          type: 'Send',\n        },\n        consolidateId: '6712d7fda6de4906d658c04aebbf8f9b',\n        coin: 'tsol',\n      };\n\n      const mockedWallet: Partial<IWallet> = {\n        coinSpecific: () => {\n          const cs = {\n            rootAddress: 'HBxZShcE86UMmF93KUM8eWJKqeEXi5cqWCLYLMMhqMYm',\n          } as WalletCoinSpecific;\n          return cs;\n        },\n      };\n\n      try {\n        if (\n          !(await basecoin.verifyTransaction({\n            blockhash: '',\n            feePayer: '',\n            txParams: {},\n            txPrebuild: consolidationTx as unknown as TransactionPrebuild,\n            walletType: 'tss',\n            wallet: mockedWallet as IWallet,\n            verification: {\n              consolidationToBaseAddress: true,\n            },\n          }))\n        ) {\n          assert.fail('Transaction should pass verification');\n        }\n      } catch (e) {\n        assert.fail('Transaction should pass verification');\n      }\n    });\n\n    it('should verify a spoofed token consolidation transaction', async () => {\n      const consolidationTx = {\n        txRequestId: '4fdd0cae-2563-43b1-b5cf-94865158ca10',\n        walletId: '63068ed4efa63a000877f02fd4b0fa6d',\n        txHex:\n          '02b7c2c7829eded4e8f947c90ed3b9afce71f616eb47dfcfbf4b765778149060013acb33b9f67fdd9c2512f48fac4e4c049eab93829b69404f3bd166fe3242c90700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020104096da690bd558fd8634ac14f1645d8095afd0caea5953578c596e3c0dea38305ee7298bfac55101f177735659d42ed6be890ef3a1d204d9e33f32e24c5635327ca66d1fe00826e5a4f759f87b279c1aee19cce5301af4ed66ae17db48b201ed6c2a0e8a28bf565627f1ab8a34b1a95ee1b0a2a39084f1f0e2acb1c394b20185d8e0b22657c8d9c4ce5f6495efb6410c199011530f90e3ab9d8d1e4206f9ae0ffeb0000000000000000000000000000000000000000000000000000000000000000c5f9fb32f49111ab20c33f2598fc836c113e291881ac21ee29169394011244e406a7d517192c568ee08a845f73d29788cf035c3145b21ab344d8062ea940000006ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9de13c74d2b4d948e1608ea6eebdafe75bc2f995aad11b21d1e2c94f2a2d12f6802050303070004040000000804020604010a0ce0076bb20400000006',\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: 'HBxZShcE86UMmF93KUM8eWJKqeEXi5cqWCLYLMMhqMYm',\n              coinName: 'sol:wif',\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: 'sol:wif',\n            },\n          ],\n          type: 'Send',\n        },\n        consolidateId: '6712d7fda6de4906d658c04aebbf8f9b',\n        coin: 'tsol',\n      };\n\n      const mockedWallet: Partial<IWallet> = {\n        coinSpecific: () => {\n          const cs = {\n            rootAddress: '8rQXeVEMrKvtWCEJirEM6cKYnbZuTqVTbqRPiMMAJ8R4',\n          } as WalletCoinSpecific;\n          return cs;\n        },\n      };\n\n      await assert.rejects(\n        async () =>\n          basecoin.verifyTransaction({\n            blockhash: '',\n            feePayer: '',\n            txParams: {},\n            txPrebuild: consolidationTx as unknown as TransactionPrebuild,\n            walletType: 'tss',\n            wallet: mockedWallet as IWallet,\n            verification: {\n              consolidationToBaseAddress: true,\n            },\n          }),\n        {\n          message: 'tx outputs does not match with expected address',\n        }\n      );\n    });\n  });\n\n  describe('blind signing token enablement protection', () => {\n    it('should verify as valid the enabletoken intent when prebuild tx matchs user intent ', async function () {\n      const { txParams, txPrebuildRaw, walletData } = testData.enableTokenFixtures;\n      const wallet = new Wallet(bitgo, basecoin, walletData);\n      const sameIntentTx = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild: txPrebuildRaw,\n        wallet,\n        verification: { verifyTokenEnablement: true },\n      } as unknown as SolVerifyTransactionOptions);\n\n      sameIntentTx.should.equal(true);\n    });\n\n    it('should thrown an error when tampered prebuild tx type ', async function () {\n      const { txParams, txPrebuildRaw, sendTxHex, walletData } = testData.enableTokenFixtures;\n      const tamperedTxPrebuild = { ...txPrebuildRaw, txHex: sendTxHex };\n\n      const wallet = new Wallet(bitgo, basecoin, walletData);\n\n      await assert.rejects(\n        async () =>\n          await basecoin.verifyTransaction({\n            txParams,\n            txPrebuild: tamperedTxPrebuild,\n            wallet,\n            verification: { verifyTokenEnablement: true },\n          } as unknown as SolVerifyTransactionOptions),\n        {\n          message:\n            'Invalid transaction type on token enablement: expected \"AssociatedTokenAccountInitialization\", got \"Send\".',\n        }\n      );\n    });\n\n    it('should verify that tokenName matches between user intent and hex', async function () {\n      const { txParams, txPrebuildRaw, wrongTokenNameTxHex, walletData } = testData.enableTokenFixtures;\n      const tamperedTxPrebuild = { ...txPrebuildRaw, txHex: wrongTokenNameTxHex };\n      const wallet = new Wallet(bitgo, basecoin, walletData);\n\n      await assert.rejects(\n        async () =>\n          basecoin.verifyTransaction({\n            txParams,\n            txPrebuild: tamperedTxPrebuild,\n            wallet,\n            verification: { verifyTokenEnablement: true },\n          } as unknown as SolVerifyTransactionOptions),\n        { message: 'Invalid token name: expected tsol:ray, got tsol:t22mint on token enablement tx' }\n      );\n    });\n\n    it('should verify that tokenAddr matches between user intent and hex', async function () {\n      const { txParams, txPrebuildRaw, wrongAddrTxHex, walletData } = testData.enableTokenFixtures;\n      const tamperedTxPrebuild = { ...txPrebuildRaw, txHex: wrongAddrTxHex };\n\n      const wallet = new Wallet(bitgo, basecoin, walletData);\n      await assert.rejects(\n        async () =>\n          basecoin.verifyTransaction({\n            txParams,\n            txPrebuild: tamperedTxPrebuild,\n            wallet,\n            verification: { verifyTokenEnablement: true },\n          } as unknown as SolVerifyTransactionOptions),\n        {\n          message:\n            'Invalid token address: expected 4bTYvvv2Hk4v2kQW8HZFFS4SzYPztQshw9Gm1suXmaBj, got G1LEgANAwKo7b8NfxTsMzrbBYDkXqi5REVJY8thrMRQm on token enablement tx',\n        }\n      );\n    });\n\n    it('should fail sendTokenEnablement call on spoofed data', async function () {\n      const { sendTokenEnablementPayload, walletData, wrongTokenNameTxHex } = testData.enableTokenFixtures;\n      const wallet = new Wallet(bitgo, basecoin, walletData);\n      nock('https://bitgo.fakeurl').get('/api/v2/tsol/key/68bafed588671cf94ed8a5dbba882ad3').reply(200, {});\n      await assert.rejects(\n        async () =>\n          wallet.sendTokenEnablement({\n            verification: { verifyTokenEnablement: true },\n            ...sendTokenEnablementPayload,\n            prebuildTx: { ...sendTokenEnablementPayload.prebuildTx, txHex: wrongTokenNameTxHex },\n          } as unknown as PrebuildAndSignTransactionOptions),\n        {\n          message: 'Invalid token name: expected tsol:ray, got tsol:t22mint on token enablement tx',\n        }\n      );\n    });\n  });\n\n  describe('isWalletAddress', () => {\n    it('should verify valid wallet address with correct keychain and index', async function () {\n      const address = '7YAesfwPk41VChUgr65bm8FEep7ymWqLSW5rpYB5zZPY';\n      const commonKeychain =\n        '8ea32ecacfc83effbd2e2790ee44fa7c59b4d86c29a12f09fb613d8195f93f4e21875cad3b98adada40c040c54c3569467df41a020881a6184096378701862bd';\n      const index = '1';\n      const keychains = [{ id: '1', type: 'tss' as const, commonKeychain }];\n\n      const result = await basecoin.isWalletAddress({ keychains, address, index });\n      result.should.equal(true);\n    });\n\n    it('should throw error for address with incorrect keychain', async function () {\n      const address = '7YAesfwPk41VChUgr65bm8FEep7ymWqLSW5rpYB5zZPY';\n      const wrongKeychain =\n        '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';\n      const index = '1';\n      const keychains = [{ id: '1', type: 'tss' as const, commonKeychain: wrongKeychain }];\n\n      await assert.rejects(async () => await basecoin.isWalletAddress({ keychains, address, index }), {\n        message: `address validation failure: ${address} is not a wallet address`,\n      });\n    });\n\n    it('should throw error for address with incorrect index', async function () {\n      const address = '7YAesfwPk41VChUgr65bm8FEep7ymWqLSW5rpYB5zZPY';\n      const commonKeychain =\n        '8ea32ecacfc83effbd2e2790ee44fa7c59b4d86c29a12f09fb613d8195f93f4e21875cad3b98adada40c040c54c3569467df41a020881a6184096378701862bd';\n      const wrongIndex = '999';\n      const keychains = [{ id: '1', type: 'tss' as const, commonKeychain }];\n\n      await assert.rejects(async () => await basecoin.isWalletAddress({ keychains, address, index: wrongIndex }), {\n        message: `address validation failure: ${address} is not a wallet address`,\n      });\n    });\n\n    it('should throw error for invalid address', async function () {\n      const invalidAddress = 'invalidaddress';\n      const commonKeychain =\n        '8ea32ecacfc83effbd2e2790ee44fa7c59b4d86c29a12f09fb613d8195f93f4e21875cad3b98adada40c040c54c3569467df41a020881a6184096378701862bd';\n      const index = '1';\n      const keychains = [{ id: '1', type: 'tss' as const, commonKeychain }];\n\n      await assert.rejects(async () => await basecoin.isWalletAddress({ keychains, address: invalidAddress, index }), {\n        message: `invalid address: ${invalidAddress}`,\n      });\n    });\n\n    it('should verify address with derivation prefix for SMC wallets', async function () {\n      // Address derived with derivation prefix m/999999/148242355/239336845/1\n      const address = 'CC715Q92C8vuEFT5xujE55Do6BkWRdpDvr7Vh8iUNUBw';\n      const commonKeychain =\n        '8ea32ecacfc83effbd2e2790ee44fa7c59b4d86c29a12f09fb613d8195f93f4e21875cad3b98adada40c040c54c3569467df41a020881a6184096378701862bd';\n      const index = '1';\n      const derivedFromParentWithSeed = 'smc-test-seed-123';\n      const keychains = [{ id: '1', type: 'tss' as const, commonKeychain }];\n\n      // This test verifies that derivedFromParentWithSeed is accepted as a parameter\n      // and the verification function correctly computes the derivation prefix internally\n      const result = await basecoin.isWalletAddress({ keychains, address, index, derivedFromParentWithSeed });\n      result.should.equal(true);\n    });\n  });\n\n  describe('getAddressFromPublicKey', () => {\n    it('should convert public key to base58 address', function () {\n      const publicKey = '61220a9394802b1d1df37b35f7a3197970f48081092cee011fc98f7b71b2bd43';\n      const expectedAddress = '7YAesfwPk41VChUgr65bm8FEep7ymWqLSW5rpYB5zZPY';\n\n      const address = basecoin.getAddressFromPublicKey(publicKey);\n      address.should.equal(expectedAddress);\n    });\n  });\n});\n"]}