@bitgo-beta/sdk-coin-hbar 2.0.73-alpha.13 → 2.0.73-alpha.131

package/dist/test/unit/hbar.js

@@ -0,0 +1,1437 @@
+"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 sinon_1 = __importDefault(require("sinon"));
+const crypto_1 = require("crypto");
+const bignumber_js_1 = require("bignumber.js");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const TestData = __importStar(require("../fixtures/hbar"));
+const src_1 = require("../../src");
+const getBuilderFactory_1 = require("./getBuilderFactory");
+const hbarBackupKey_1 = require("./fixtures/hbarBackupKey");
+describe('Hedera Hashgraph:', function () {
+    let bitgo;
+    let basecoin;
+    let token;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('thbar', src_1.Thbar.createInstance);
+        bitgo.safeRegister('hbar', src_1.Hbar.createInstance);
+        src_1.HbarToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {
+            bitgo.safeRegister(name, coinConstructor);
+        });
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('thbar');
+        token = bitgo.coin('thbar:usdc');
+    });
+    it('should instantiate the coin', function () {
+        const basecoin = bitgo.coin('hbar');
+        basecoin.should.be.an.instanceof(src_1.Hbar);
+    });
+    it('should check valid addresses', async function () {
+        const badAddresses = [
+            '',
+            '0.0',
+            'YZ09fd-',
+            '0.0.0.a',
+            'sadasdfggg',
+            '0.2.a.b',
+            '0.0.100?=sksjd',
+            '0.0.41098?memoId=',
+        ];
+        const goodAddresses = [
+            '0',
+            '0.0.0',
+            '0.0.41098',
+            '0.0.0?memoId=84',
+            '0.0.41098',
+            '0.0.41098?memoId=2aaaaa',
+            '0.0.41098?memoId=1',
+        ];
+        badAddresses.map((addr) => {
+            basecoin.isValidAddress(addr).should.equal(false);
+        });
+        goodAddresses.map((addr) => {
+            basecoin.isValidAddress(addr).should.equal(true);
+        });
+        const hexAddress = '0x23C3E227BE97281A70A549c7dDB8d5Caad3E7C84';
+        basecoin.isValidAddress(hexAddress).should.equal(false);
+    });
+    it('should explain a transaction', async function () {
+        const tx = JSON.parse(TestData.rawTransactionForExplain);
+        const explain = await basecoin.explainTransaction(tx);
+        explain.id.should.equal('0.0.43285@1600529800.643093586');
+        explain.outputAmount.should.equal('2200000000');
+        explain.timestamp.should.equal('1600529800.643093586');
+        explain.expiration.should.equal('180');
+        explain.outputs[0].amount.should.equal('2200000000');
+        explain.outputs[0].address.should.equal('0.0.43283');
+        explain.outputs[0].memo.should.equal('1');
+        explain.fee.should.equal(1160407);
+        explain.changeAmount.should.equal('0');
+    });
+    it('should explain a token transfer transaction', async function () {
+        const tokenTransferParam = {
+            txHex: TestData.UNSIGNED_TOKEN_TRANSFER,
+            feeInfo: {
+                size: 1000,
+                fee: 1160407,
+                feeRate: 1160407,
+            },
+        };
+        const explain = await basecoin.explainTransaction(tokenTransferParam);
+        explain.id.should.equal('0.0.81320@1596110493.372646570');
+        explain.outputAmount.should.equal('0');
+        explain.timestamp.should.equal('1596110493.372646570');
+        explain.expiration.should.equal('180');
+        explain.outputs[0].amount.should.equal('10');
+        explain.outputs[0].address.should.equal('0.0.75861');
+        explain.outputs[0].memo.should.equal('');
+        explain.outputs[0].tokenName.should.equal('thbar:usdc');
+        explain.fee.should.equal(1160407);
+        explain.changeAmount.should.equal('0');
+    });
+    it('should explain a multirecipients transfer transaction', async function () {
+        const multiTransferParam = {
+            txHex: TestData.UNSIGNED_MULTI_TRANSFER,
+            feeInfo: {
+                size: 1000,
+                fee: 1160407,
+                feeRate: 1160407,
+            },
+        };
+        const explain = await basecoin.explainTransaction(multiTransferParam);
+        explain.id.should.equal('0.0.81320@1596110493.372646570');
+        explain.outputAmount.should.equal('25');
+        explain.expiration.should.equal('180');
+        explain.outputs[0].amount.should.equal('10');
+        explain.outputs[0].address.should.equal('0.0.75861');
+        explain.outputs[0].memo.should.equal('');
+        explain.outputs[1].amount.should.equal('15');
+        explain.outputs[1].address.should.equal('0.0.78963');
+        explain.fee.should.equal(1160407);
+        explain.changeAmount.should.equal('0');
+    });
+    it('should explain a multirecipients token transfer transaction', async function () {
+        const tokenMultiTransferParam = {
+            txHex: TestData.UNSIGNED_TOKEN_MULTI_TRANSFER,
+            feeInfo: {
+                size: 1000,
+                fee: 1160407,
+                feeRate: 1160407,
+            },
+        };
+        const explain = await basecoin.explainTransaction(tokenMultiTransferParam);
+        explain.id.should.equal('0.0.81320@1596110493.372646570');
+        explain.outputAmount.should.equal('0');
+        explain.timestamp.should.equal('1596110493.372646570');
+        explain.expiration.should.equal('180');
+        explain.outputs[0].amount.should.equal('10');
+        explain.outputs[0].address.should.equal('0.0.75861');
+        explain.outputs[0].memo.should.equal('');
+        explain.outputs[0].tokenName.should.equal('thbar:usdc');
+        explain.outputs[1].amount.should.equal('15');
+        explain.outputs[1].address.should.equal('0.0.78963');
+        explain.outputs[1].tokenName.should.equal('thbar:usdc');
+        explain.fee.should.equal(1160407);
+        explain.changeAmount.should.equal('0');
+    });
+    it('should explain a token associate transaction', async function () {
+        const tokenAssociateParam = {
+            txHex: TestData.UNSIGNED_TOKEN_ASSOCIATE,
+            feeInfo: {
+                size: 1000,
+                fee: 1160407,
+                feeRate: 1160407,
+            },
+        };
+        const explain = await basecoin.explainTransaction(tokenAssociateParam);
+        explain.id.should.equal('0.0.81320@1596110493.372646570');
+        explain.outputAmount.should.equal('0');
+        explain.timestamp.should.equal('1596110493.372646570');
+        explain.expiration.should.equal('180');
+        explain.outputs[0].amount.should.equal('0');
+        explain.outputs[0].address.should.equal('0.0.81320');
+        explain.outputs[0].memo.should.equal('');
+        explain.outputs[0].tokenName.should.equal('thbar:usdc');
+        explain.fee.should.equal(1160407);
+        explain.changeAmount.should.equal('0');
+    });
+    it('should verify isWalletAddress', async function () {
+        const baseAddress = '0.0.41098';
+        const validAddress1 = '0.0.41098?memoId=1';
+        const validAddress2 = '0.0.41098?memoId=2';
+        const unrelatedValidAddress = '0.1.41098?memoId=1';
+        const invalidAddress = '0.0.0.a';
+        (await basecoin.isWalletAddress({ address: validAddress1, baseAddress })).should.true();
+        (await basecoin.isWalletAddress({ address: validAddress2, baseAddress })).should.true();
+        (await basecoin.isWalletAddress({ address: validAddress2, baseAddress: validAddress1 })).should.true();
+        (await basecoin.isWalletAddress({ address: unrelatedValidAddress, baseAddress })).should.false();
+        assert_1.default.rejects(async () => basecoin.isWalletAddress({ address: invalidAddress, baseAddress }), `invalid address ${invalidAddress}`);
+    });
+    describe('Keypairs:', () => {
+        it('should generate a keypair from random seed', function () {
+            const keyPair = basecoin.generateKeyPair();
+            keyPair.should.have.property('pub');
+            keyPair.should.have.property('prv');
+            basecoin.isValidPub(keyPair.pub).should.equal(true);
+        });
+        it('should generate a keypair from a seed', function () {
+            const seedText = '80350b4208d381fbfe2276a326603049fe500731c46d3c9936b5ce036b51377f';
+            const seed = Buffer.from(seedText, 'hex');
+            const keyPair = basecoin.generateKeyPair(seed);
+            keyPair.prv.should.equal('302e020100300506032b65700422042080350b4208d381fbfe2276a326603049fe500731c46d3c9936b5ce036b51377f');
+            keyPair.pub.should.equal('302a300506032b65700321009cc402b5c75214269c2826e3c6119377cab6c367601338661c87a4e07c6e0333');
+        });
+        it('should validate a stellar seed', function () {
+            basecoin.isStellarSeed('SBMWLNV75BPI2VB4G27RWOMABVRTSSF7352CCYGVELZDSHCXWCYFKXIX').should.ok();
+        });
+        it('should convert a stellar seed to an hbar prv', function () {
+            const seed = basecoin.convertFromStellarSeed('SBMWLNV75BPI2VB4G27RWOMABVRTSSF7352CCYGVELZDSHCXWCYFKXIX');
+            seed.should.equal('302e020100300506032b6570042204205965b6bfe85e8d543c36bf1b39800d633948bfdf742160d522f2391c57b0b055');
+        });
+    });
+    describe('Verify Transaction:', () => {
+        let newTxPrebuild;
+        let newTxParams;
+        let newTxParamsWithError;
+        let newTxParamsWithExtraData;
+        const txPrebuild = {
+            recipients: [
+                {
+                    address: 'lionteste212',
+                    amount: '1000',
+                },
+            ],
+            txHex: TestData.UNSIGNED_MULTI_TRANSFER,
+            txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',
+            isVotingTransaction: false,
+            coin: 'thbar',
+            feeInfo: {
+                size: 1000,
+                fee: 1160407,
+                feeRate: 1160407,
+            },
+        };
+        const txParams = {
+            txPrebuild,
+            recipients: [
+                {
+                    address: '0.0.75861',
+                    amount: '10',
+                },
+                {
+                    address: '0.0.78963',
+                    amount: '15',
+                },
+            ],
+        };
+        const memo = { value: '' };
+        const txParamsWithError = {
+            txPrebuild,
+            recipients: [
+                {
+                    address: '0.0.75861',
+                    amount: '1000',
+                },
+            ],
+        };
+        const txParamsWithExtraData = {
+            txPrebuild,
+            recipients: [
+                {
+                    address: '0.0.75861',
+                    amount: '10',
+                    data: undefined,
+                },
+                {
+                    address: '0.0.78963',
+                    amount: '15',
+                    data: undefined,
+                },
+            ],
+        };
+        const walletData = {
+            id: '5b34252f1bf349930e34020a00000000',
+            coin: 'thbar',
+            keys: [
+                '5b3424f91bf349930e34017500000000',
+                '5b3424f91bf349930e34017600000000',
+                '5b3424f91bf349930e34017700000000',
+            ],
+            coinSpecific: {
+                baseAddress: '0.0.2935',
+            },
+            multisigType: 'onchain',
+        };
+        const walletObj = new sdk_core_1.Wallet(bitgo, basecoin, walletData);
+        before(function () {
+            newTxPrebuild = () => {
+                return _.cloneDeep(txPrebuild);
+            };
+            newTxParams = () => {
+                return _.cloneDeep(txParams);
+            };
+            newTxParamsWithError = () => {
+                return _.cloneDeep(txParamsWithError);
+            };
+            newTxParamsWithExtraData = () => {
+                return _.cloneDeep(txParamsWithExtraData);
+            };
+        });
+        it('should verify native transfer transactions', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should fail verify when input `recipients` is absent', async function () {
+            const txParams = newTxParams();
+            txParams.recipients = undefined;
+            const txPrebuild = newTxPrebuild();
+            await basecoin
+                .verifyTransaction({ txParams, txPrebuild, memo: memo, wallet: walletObj })
+                .should.be.rejectedWith('missing required tx params property recipients');
+        });
+        it('should fail verify transactions when have different recipients', async function () {
+            const txParams = newTxParamsWithError();
+            const txPrebuild = newTxPrebuild();
+            await basecoin
+                .verifyTransaction({ txParams, txPrebuild, memo, 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,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should verify create associated token account transaction', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            txParams.type = 'enabletoken';
+            txParams.recipients = [
+                {
+                    address: '0.0.81320',
+                    amount: '0',
+                    tokenName: 'thbar:usdc',
+                },
+            ];
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                wallet: walletObj,
+                verification: { verifyTokenEnablement: true },
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should fail verify create associated token account transaction with mismatch recipients', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            txParams.type = 'enabletoken';
+            txParams.recipients = [
+                {
+                    address: '0.0.81321',
+                    amount: '0',
+                    tokenName: 'thbar:usdc',
+                },
+            ];
+            await basecoin
+                .verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                wallet: walletObj,
+                verification: { verifyTokenEnablement: true },
+            })
+                .should.be.rejectedWith('Invalid token enablement transaction: Expected account 0.0.81321, got 0.0.81320');
+        });
+        it('should verify token transfer transaction', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txHex = TestData.UNSIGNED_TOKEN_MULTI_TRANSFER;
+            txParams.recipients = [
+                {
+                    address: '0.0.75861',
+                    amount: '10',
+                    tokenName: 'thbar:usdc',
+                },
+                {
+                    address: '0.0.78963',
+                    amount: '15',
+                    tokenName: 'thbar:usdc',
+                },
+            ];
+            const validTransaction = await token.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                wallet: walletObj,
+            });
+            validTransaction.should.equal(true);
+        });
+        it('should verify token transfer transaction with any token name on token base coin', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txHex = TestData.UNSIGNED_TOKEN_MULTI_TRANSFER;
+            txParams.recipients = [
+                {
+                    address: '0.0.75861',
+                    amount: '10',
+                    tokenName: 'thbar:usdc',
+                },
+                {
+                    address: '0.0.78963',
+                    amount: '15',
+                },
+            ];
+            (await token.verifyTransaction({ txParams, txPrebuild, memo, wallet: walletObj })).should.equal(true);
+        });
+        it('should fail to verify token transfer with mismatched recipients', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txHex = TestData.UNSIGNED_TOKEN_MULTI_TRANSFER;
+            txParams.recipients = [
+                {
+                    address: '0.0.75861',
+                    amount: '11',
+                    tokenName: 'thbar:usdc',
+                },
+                {
+                    address: '0.0.78963',
+                    amount: '15',
+                },
+            ];
+            await token
+                .verifyTransaction({ txParams, txPrebuild, memo, wallet: walletObj })
+                .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');
+        });
+        it('should fail to verify token transfer with incorrect token name', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txHex = TestData.UNSIGNED_TOKEN_MULTI_TRANSFER;
+            txParams.recipients = [
+                {
+                    address: '0.0.75861',
+                    amount: '11',
+                    tokenName: 'thbar:usdc',
+                },
+                {
+                    address: '0.0.78963',
+                    amount: '15',
+                    tokenName: 'invalidtoken',
+                },
+            ];
+            await token
+                .verifyTransaction({ txParams, txPrebuild, memo, wallet: walletObj })
+                .should.be.rejectedWith('Incorrect token name specified in recipients');
+        });
+        it('should success to verify transfer having address with memo id', async function () {
+            const txParams = newTxParams();
+            const txPrebuild = newTxPrebuild();
+            txPrebuild.txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            txParams.type = 'enabletoken';
+            txParams.recipients = [
+                {
+                    address: '0.0.81320?memoId=1',
+                    amount: '0',
+                    tokenName: 'thbar:usdc',
+                },
+            ];
+            const validTransaction = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                memo,
+                wallet: walletObj,
+                verification: { verifyTokenEnablement: true },
+            });
+            validTransaction.should.equal(true);
+        });
+    });
+    describe('Verify Token Enablement Transaction:', () => {
+        it('should verify a valid token enablement transaction with tokenName', async function () {
+            const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            const expectedToken = { tokenName: 'thbar:usdc' };
+            const expectedAccountId = '0.0.81320';
+            await basecoin.verifyTokenEnablementTransaction(txHex, expectedToken, expectedAccountId);
+        });
+        it('should verify a valid token enablement transaction with tokenId', async function () {
+            const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            const expectedToken = { tokenId: '0.0.429274' }; // Actual tokenId for thbar:usdc
+            const expectedAccountId = '0.0.81320';
+            await basecoin.verifyTokenEnablementTransaction(txHex, expectedToken, expectedAccountId);
+        });
+        it('should fail when txHex is missing', async function () {
+            await basecoin
+                .verifyTokenEnablementTransaction('', { tokenName: 'thbar:usdc' }, '0.0.81320')
+                .should.be.rejectedWith('Missing required parameters: txHex');
+        });
+        it('should fail when expectedAccountId is missing', async function () {
+            await basecoin
+                .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_ASSOCIATE, { tokenName: 'thbar:usdc' }, '')
+                .should.be.rejectedWith('Missing required parameters: expectedAccountId');
+        });
+        it('should fail when wallet platform sends spoofed transaction hex for token enablement', async function () {
+            // Create a valid transaction response structure from wallet platform with spoofed txHex
+            // The txHex looks like valid hex but contains malicious/invalid transaction data
+            const spoofedTxHex = '0a0c0a080800100018a8fb0410130a0c0a080800100018d5d0041014'; // Valid hex but invalid transaction
+            // Mock the API endpoints that will be called during token enablement
+            const bgUrl = sdk_core_1.common.Environments['mock'].uri;
+            // Mock the key endpoint needed for signing
+            (0, nock_1.default)(bgUrl)
+                .post('/api/v2/thbar/key/5b3424f91bf34993006eae94')
+                .reply(200, [
+                {
+                    encryptedPrv: 'fakePrv',
+                },
+            ]);
+            // Mock the prebuild API response to return spoofed txHex
+            (0, nock_1.default)(bgUrl)
+                .post('/api/v2/thbar/wallet/5b34252f1bf34993006eae96/tx/build')
+                .reply(200, {
+                txHex: spoofedTxHex,
+                txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',
+                recipients: [
+                    {
+                        address: '0.0.81320',
+                        amount: '0', // Valid amount for token enablement
+                    },
+                ],
+                coin: 'thbar',
+                feeInfo: {
+                    size: 1000,
+                    fee: 1160407,
+                    feeRate: 1160407,
+                },
+            });
+            // This should fail because the spoofed transaction hex contains invalid transaction data
+            // The verification logic should catch this when trying to validate the transaction
+            await assert_1.default.rejects(async () => {
+                // Test the verification directly instead of going through the wallet flow
+                await basecoin.verifyTokenEnablementTransaction(spoofedTxHex, { tokenName: 'thbar:usdc' }, '0.0.81320');
+            }, (error) => {
+                // The error should indicate that the transaction is invalid
+                return error.message.includes('Invalid token enablement transaction');
+            });
+        });
+        it('should fail when both tokenId and tokenName are missing', async function () {
+            await basecoin
+                .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_ASSOCIATE, {}, '0.0.81320')
+                .should.be.rejectedWith('Missing required parameters: expectedToken.tokenId|tokenName');
+        });
+        it('should fail when token name does not match', async function () {
+            await basecoin
+                .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_ASSOCIATE, { tokenName: 'thbar:wrongtoken' }, '0.0.81320')
+                .should.be.rejectedWith(/Expected token name thbar:wrongtoken, got thbar:usdc/);
+        });
+        it('should fail when account ID does not match', async function () {
+            await basecoin
+                .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_ASSOCIATE, { tokenName: 'thbar:usdc' }, '0.0.99999')
+                .should.be.rejectedWith(/Expected account 0.0.99999, got 0.0.81320/);
+        });
+        it('should fail when transaction is not a token enablement (has non-zero amount)', async function () {
+            // Use a regular transfer transaction which has non-zero amount
+            await basecoin
+                .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_TRANSFER, { tokenName: 'thbar:usdc' }, '0.0.81320')
+                .should.be.rejectedWith(/Expected output amount '0'/);
+        });
+        it('should fail when transaction type is not tokenAssociate', async function () {
+            // Use a regular transfer transaction which is not tokenAssociate
+            // This will fail on amount validation first, but that's expected behavior
+            await basecoin
+                .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_TRANSFER, { tokenName: 'thbar:usdc' }, '0.0.81320')
+                .should.be.rejectedWith(/Expected output amount '0'/);
+        });
+        it('should validate transaction type for valid token associate transaction', async function () {
+            // This test ensures the transaction type validation works for valid token associate transactions
+            const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            const expectedToken = { tokenName: 'thbar:usdc' };
+            const expectedAccountId = '0.0.81320';
+            await basecoin.verifyTokenEnablementTransaction(txHex, expectedToken, expectedAccountId);
+        });
+        it('should fail with invalid transaction hex', async function () {
+            await basecoin
+                .verifyTokenEnablementTransaction('invalid_hex', { tokenName: 'thbar:usdc' }, '0.0.81320')
+                .should.be.rejectedWith(/Invalid token enablement transaction/);
+        });
+        it('should fail when txHex contains wrong tokenId compared to expected', async function () {
+            // This test ensures direct txHex validation catches spoofed tokenIds
+            const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            const wrongTokenId = '0.0.999999'; // Wrong tokenId
+            const expectedAccountId = '0.0.81320';
+            await basecoin
+                .verifyTokenEnablementTransaction(txHex, { tokenId: wrongTokenId }, expectedAccountId)
+                .should.be.rejectedWith(new RegExp(`Expected tokenId ${_.escapeRegExp(wrongTokenId)}, but transaction contains tokenId`));
+        });
+        it('should fail when txHex contains wrong accountId compared to expected', async function () {
+            // This test ensures direct txHex validation catches spoofed accountIds
+            const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            const expectedToken = { tokenName: 'thbar:usdc' };
+            const wrongAccountId = '0.0.999999'; // Wrong accountId
+            await basecoin
+                .verifyTokenEnablementTransaction(txHex, expectedToken, wrongAccountId)
+                .should.be.rejectedWith(new RegExp(`Expected account ${_.escapeRegExp(wrongAccountId)}, got`));
+        });
+        it('should pass verification for valid token enablement transaction without throwing error', async function () {
+            // This test ensures that a valid token enablement transaction passes all validations
+            const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            const expectedToken = { tokenName: 'thbar:usdc' };
+            const expectedAccountId = '0.0.81320';
+            // This should complete without throwing any errors
+            await basecoin.verifyTokenEnablementTransaction(txHex, expectedToken, expectedAccountId);
+            // If we reach this point, the test passed
+            assert_1.default.ok(true, 'Valid token enablement transaction should not throw any errors');
+        });
+        it('should successfully complete sendTokenEnablements with valid transaction response from wallet platform', async function () {
+            const validTxHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;
+            const wallet = {
+                id: () => '5b34252f1bf34993006eae96',
+                coin: () => 'thbar',
+                prebuildTransaction: async () => ({
+                    txHex: validTxHex, // Valid token associate transaction
+                    txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',
+                    recipients: [{ address: '0.0.81320', amount: '0' }],
+                    coin: 'thbar',
+                    feeInfo: { size: 1000, fee: 1160407, feeRate: 1160407 },
+                }),
+                sendTokenEnablements: async (params) => {
+                    const txPrebuild = await wallet.prebuildTransaction();
+                    await basecoin.verifyTransaction({
+                        txParams: {
+                            type: 'enabletoken',
+                            recipients: [{ address: '0.0.81320', amount: '0', tokenName: 'thbar:usdc' }],
+                        },
+                        txPrebuild,
+                        verification: { verifyTokenEnablement: true },
+                    });
+                    return {
+                        success: [{ txid: txPrebuild.txid, status: 'success' }],
+                        failure: [],
+                    };
+                },
+            };
+            await wallet.sendTokenEnablements({
+                recipients: [{ address: '0.0.81320', tokenName: 'thbar:usdc' }],
+            });
+            assert_1.default.ok(true, 'Valid token enablement transaction should complete successfully through sendTokenEnablements flow');
+        });
+        it('should detect spoofed transaction hex through sendTokenEnablements flow', async function () {
+            // Use a valid transfer transaction hex instead of a token associate transaction
+            // This will parse correctly but fail validation because it's not a token associate transaction
+            const spoofedTxHex = TestData.UNSIGNED_TOKEN_TRANSFER; // Valid transfer transaction, not token associate
+            // Create a wallet mock for the sendTokenEnablements flow
+            const wallet = {
+                id: () => '5b34252f1bf34993006eae96',
+                coin: () => 'thbar',
+                prebuildTransaction: async () => ({
+                    txHex: spoofedTxHex,
+                    txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',
+                    recipients: [{ address: '0.0.81320', amount: '0' }],
+                    coin: 'thbar',
+                    feeInfo: { size: 1000, fee: 1160407, feeRate: 1160407 },
+                }),
+                sendTokenEnablements: async (params) => {
+                    // This should trigger the verification and fail
+                    const txPrebuild = await wallet.prebuildTransaction();
+                    return basecoin.verifyTransaction({
+                        txParams: {
+                            type: 'enabletoken',
+                            recipients: [{ address: '0.0.81320', amount: '0', tokenName: 'thbar:usdc' }],
+                        },
+                        txPrebuild,
+                        verification: { verifyTokenEnablement: true },
+                    });
+                },
+            };
+            // This should fail because the spoofed transaction hex contains a transfer transaction, not a token associate
+            await assert_1.default.rejects(async () => {
+                await wallet.sendTokenEnablements({
+                    recipients: [{ address: '0.0.81320', tokenName: 'thbar:usdc' }],
+                });
+            }, (error) => {
+                // The error should indicate that the transaction is invalid for token enablement
+                return (error.message.includes('Invalid token enablement transaction') ||
+                    error.message.includes('Token enablement transaction missing tokenId') ||
+                    error.message.includes("Expected output amount '0'") ||
+                    error.message.includes('Transaction is not a TokenAssociate transaction'));
+            });
+        });
+    });
+    describe('Sign Message', () => {
+        it('should be performed', async () => {
+            const keyPair = new src_1.KeyPair();
+            const messageToSign = Buffer.from((0, crypto_1.randomBytes)(32)).toString('hex');
+            const signature = await basecoin.signMessage(keyPair.getKeys(), messageToSign);
+            keyPair.verifySignature(messageToSign, Uint8Array.from(Buffer.from(signature, 'hex'))).should.equals(true);
+        });
+        it('should fail with missing private key', async () => {
+            const keyPair = new src_1.KeyPair({
+                pub: '302a300506032b6570032100d8fd745361df270776a3ab1b55d5590ec00a26ab45eea37197dc9894a81fcb82',
+            }).getKeys();
+            const messageToSign = Buffer.from((0, crypto_1.randomBytes)(32)).toString('hex');
+            await basecoin.signMessage(keyPair, messageToSign).should.be.rejectedWith('Invalid key pair options');
+        });
+    });
+    describe('Sign transaction:', () => {
+        const destination = '0.0.129369';
+        const source = '0.0.1234';
+        const amount = '100000';
+        /**
+         * Build an unsigned account-lib multi-signature send transaction
+         * @param destination The destination address of the transaction
+         * @param source The account sending thist ransaction
+         * @param amount The amount to send to the recipient
+         */
+        const buildUnsignedTransaction = async function ({ destination, source, amount = '100000' }) {
+            const factory = (0, getBuilderFactory_1.getBuilderFactory)('thbar');
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.fee({
+                fee: '100000',
+            });
+            txBuilder.source({ address: source });
+            txBuilder.send({ address: destination, amount });
+            return await txBuilder.build();
+        };
+        it('should sign transaction', async function () {
+            const key = new src_1.KeyPair();
+            const unsignedTransaction = await buildUnsignedTransaction({
+                destination,
+                source,
+                amount,
+            });
+            const tx = await basecoin.signTransaction({
+                prv: key.getKeys().prv.toString(),
+                txPrebuild: {
+                    txHex: unsignedTransaction.toBroadcastFormat(),
+                },
+            });
+            const factory = (0, getBuilderFactory_1.getBuilderFactory)('thbar');
+            const txBuilder = factory.from(tx.halfSigned.txHex);
+            const signedTx = await txBuilder.build();
+            const txJson = signedTx.toJson();
+            txJson.should.have.properties('to', 'amount');
+            txJson.to?.should.equal(destination);
+            txJson.from.should.equal(source);
+            txJson.amount?.should.equal(amount);
+            txJson.instructionsData.params.recipients[0].should.deepEqual({
+                address: destination,
+                amount,
+            });
+            signedTx.signature.length.should.equal(1);
+        });
+        it('should fully sign transaction with root key', async function () {
+            const key1 = basecoin.generateRootKeyPair();
+            const key2 = basecoin.generateRootKeyPair();
+            const unsignedTransaction = await buildUnsignedTransaction({
+                destination,
+                source,
+                amount,
+            });
+            const txHalfSigned = await basecoin.signTransaction({
+                prv: key1.prv,
+                txPrebuild: {
+                    txHex: unsignedTransaction.toBroadcastFormat(),
+                },
+            });
+            const factory = (0, getBuilderFactory_1.getBuilderFactory)('thbar');
+            const txBuilderHalfSigned = factory.from(txHalfSigned.halfSigned.txHex);
+            const halfSignedTx = await txBuilderHalfSigned.build();
+            const halfSignedTxJson = halfSignedTx.toJson();
+            halfSignedTxJson.should.have.properties('to', 'amount');
+            halfSignedTxJson.to?.should.equal(destination);
+            halfSignedTxJson.from.should.equal(source);
+            halfSignedTxJson.amount?.should.equal(amount);
+            halfSignedTxJson.instructionsData.params.recipients[0].should.deepEqual({
+                address: destination,
+                amount,
+            });
+            halfSignedTx.signature.length.should.equal(1);
+            const txSigned = await basecoin.signTransaction({
+                prv: key2.prv,
+                txPrebuild: {
+                    txHex: halfSignedTx.toBroadcastFormat(),
+                },
+            });
+            const txBuilderSigned = factory.from(txSigned.txHex);
+            const signedTx = await txBuilderSigned.build();
+            const signedTxJson = signedTx.toJson();
+            signedTxJson.should.have.properties('to', 'amount');
+            signedTxJson.to?.should.equal(destination);
+            signedTxJson.from.should.equal(source);
+            signedTxJson.amount?.should.equal(amount);
+            signedTxJson.instructionsData.params.recipients[0].should.deepEqual({
+                address: destination,
+                amount,
+            });
+            signedTx.signature.length.should.equal(2);
+        });
+    });
+    describe('Recovery', function () {
+        const defaultValidDuration = '180';
+        const defaultFee = 10000000;
+        const defaultNodeId = '0.0.3';
+        const userKey = '{"iv":"WlPuJOejRWgj/NTd3UMgrw==","v":1,"iter":10000,"ks":256,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"6yAVFvreHSQ=","ct":"8j/lBVkFByKlVhaS9JWmmLja5yTokjaIiLDxMIDjMojVEim9T36WAm5qW6v1V0A7QcEuGiVl3PKMDa+Gr6tI/HT58DW5RE+pHzya9MUQpAgNrJr8VEWjrXWqZECVtra1/bKCyB+mozc="}';
+        const userPub = '302a300506032b6570032100ddd53a1591d72b181109bd3e57b18603740490b9ab4d37bc7fa27480e6b8c911';
+        const backupKey = '{"iv":"D5DVDozQx9B02JeFV0/OVA==","v":1,"iter":10000,"ks":256,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"7FUNF8M35bo=","ct":"ZiPsu5Qe/AIS4JQXt+rrusHnYCy4CqurM16R5wJrd4CEx7u85y3yy5ErnsdyYYcc3txyNmUIQ2/CBq/LKoKO/VIeU++CnKxzGuHGcNI47BPk3RQK42a66uIQn/yTR++XgdK1KhvUL3U="}';
+        const backupPub = '302a300506032b65700321006293e4ec9bf1b2d8fae631119107248a65e2207a05d32a11f42cc3d9a3005d4a';
+        const rootAddress = '0.0.7671186';
+        const walletPassphrase = 'TestPasswordPleaseIgnore';
+        const recoveryDestination = '0.0.7651908';
+        const bitgoKey = '5a93b01ea87e963f61c974a89d62e3841392f1ba020fbbcc65a8089ca025abbb';
+        const memo = '4';
+        const balance = '1000000000';
+        const formatBalanceResponse = (balance) => new bignumber_js_1.BigNumber(balance).dividedBy(basecoin.getBaseFactor()).toFixed(9) + ' ℏ';
+        const tokenId = '0.0.429274';
+        describe('Non-BitGo', async function () {
+            const sandBox = sinon_1.default.createSandbox();
+            afterEach(function () {
+                sandBox.verifyAndRestore();
+            });
+            it('should build and sign the recovery tx', async function () {
+                const expectedAmount = new bignumber_js_1.BigNumber(balance).minus(defaultFee).toString();
+                const getBalanceStub = sandBox
+                    .stub(src_1.Hbar.prototype, 'getAccountBalance')
+                    .resolves({ hbars: formatBalanceResponse(balance), tokens: [] });
+                const recovery = await basecoin.recover({
+                    userKey,
+                    backupKey,
+                    rootAddress,
+                    walletPassphrase,
+                    recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                });
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('id');
+                recovery.should.have.property('tx');
+                recovery.should.have.property('coin', 'thbar');
+                recovery.should.have.property('nodeId', defaultNodeId);
+                getBalanceStub.callCount.should.equal(1);
+                const txBuilder = basecoin.getBuilderFactory().from(recovery.tx);
+                const tx = await txBuilder.build();
+                tx.toBroadcastFormat().should.equal(recovery.tx);
+                const txJson = tx.toJson();
+                txJson.amount.should.equal(expectedAmount);
+                txJson.to.should.equal(recoveryDestination);
+                txJson.from.should.equal(rootAddress);
+                txJson.fee.should.equal(defaultFee);
+                txJson.node.should.equal(defaultNodeId);
+                txJson.memo.should.equal(memo);
+                txJson.validDuration.should.equal(defaultValidDuration);
+                txJson.should.have.property('startTime');
+                recovery.should.have.property('startTime', txJson.startTime);
+                recovery.should.have.property('id', rootAddress + '@' + txJson.startTime);
+            });
+            it('should throw for invalid rootAddress', async function () {
+                const invalidRootAddress = 'randomstring';
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress: 'randomstring',
+                        walletPassphrase,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                    });
+                }, { message: 'invalid rootAddress, got: ' + invalidRootAddress });
+            });
+            it('should throw for invalid recoveryDestination', async function () {
+                const invalidRecoveryDestination = 'randomstring';
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress,
+                        walletPassphrase,
+                        recoveryDestination: 'randomstring',
+                    });
+                }, { message: 'invalid recoveryDestination, got: ' + invalidRecoveryDestination });
+            });
+            it('should throw for invalid nodeId', async function () {
+                const invalidNodeId = 'a.2.3';
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress,
+                        walletPassphrase,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        nodeId: invalidNodeId,
+                    });
+                }, { message: 'invalid nodeId, got: ' + invalidNodeId });
+            });
+            it('should throw for invalid maxFee', async function () {
+                const invalidMaxFee = '-32';
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress,
+                        walletPassphrase,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        maxFee: invalidMaxFee,
+                    });
+                }, { message: 'invalid maxFee, got: ' + invalidMaxFee });
+            });
+            it('should throw if there is no enough balance to recover', async function () {
+                const getBalanceStub = sandBox
+                    .stub(src_1.Hbar.prototype, 'getAccountBalance')
+                    .resolves({ hbars: formatBalanceResponse('100'), tokens: [] });
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress,
+                        walletPassphrase,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                    });
+                }, { message: 'Insufficient balance to recover, got balance: 100 fee: 10000000' });
+                getBalanceStub.callCount.should.equal(1);
+            });
+            it('should throw if the walletPassphrase is undefined', async function () {
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                    });
+                }, { message: 'walletPassphrase is required for non-bitgo recovery' });
+            });
+            it('should throw if the walletPassphrase is wrong', async function () {
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress,
+                        walletPassphrase: 'randompassword',
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                    });
+                }, {
+                    message: "unable to decrypt userKey or backupKey with the walletPassphrase provided, got error: password error - ccm: tag doesn't match",
+                });
+            });
+            it('should build and sign the recovery tx for tokens', async function () {
+                const balance = '100';
+                const data = {
+                    hbars: '1',
+                    tokens: [{ tokenId: tokenId, balance: balance, decimals: 6 }],
+                };
+                const getBalanceStub = sandBox.stub(src_1.Hbar.prototype, 'getAccountBalance').resolves(data);
+                const recovery = await basecoin.recover({
+                    userKey,
+                    backupKey,
+                    rootAddress,
+                    walletPassphrase,
+                    recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                    tokenId: tokenId,
+                });
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('id');
+                recovery.should.have.property('tx');
+                recovery.should.have.property('coin', 'thbar');
+                recovery.should.have.property('nodeId', defaultNodeId);
+                getBalanceStub.callCount.should.equal(1);
+                const txBuilder = basecoin.getBuilderFactory().from(recovery.tx);
+                const tx = await txBuilder.build();
+                tx.toBroadcastFormat().should.equal(recovery.tx);
+                const txJson = tx.toJson();
+                txJson.amount.should.equal(balance);
+                txJson.to.should.equal(recoveryDestination);
+                txJson.from.should.equal(rootAddress);
+                txJson.fee.should.equal(defaultFee);
+                txJson.node.should.equal(defaultNodeId);
+                txJson.memo.should.equal(memo);
+                txJson.validDuration.should.equal(defaultValidDuration);
+                txJson.should.have.property('startTime');
+                recovery.should.have.property('startTime', txJson.startTime);
+                recovery.should.have.property('id', rootAddress + '@' + txJson.startTime);
+            });
+            it('should throw error for non supported invalid tokenId', async function () {
+                const invalidTokenId = 'randomstring';
+                const data = {
+                    hbars: '1',
+                    tokens: [{ tokenId: tokenId, balance: '100', decimals: 6 }],
+                };
+                sandBox.stub(src_1.Hbar.prototype, 'getAccountBalance').resolves(data);
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress: rootAddress,
+                        walletPassphrase,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        tokenId: invalidTokenId,
+                    });
+                }, { message: 'Unsupported token: ' + invalidTokenId });
+            });
+            it('should throw error for insufficient balance for tokenId if token balance not exist', async function () {
+                const data = {
+                    hbars: '100',
+                    tokens: [{ tokenId: 'randomString', balance: '100', decimals: 6 }],
+                };
+                sandBox.stub(src_1.Hbar.prototype, 'getAccountBalance').resolves(data);
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress: rootAddress,
+                        walletPassphrase,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        tokenId: tokenId,
+                    });
+                }, { message: 'Insufficient balance to recover token: ' + tokenId + ' for account: ' + rootAddress });
+            });
+            it('should throw error for insufficient balance for tokenId if token balance exist with 0 amount', async function () {
+                const data = {
+                    hbars: '100',
+                    tokens: [{ tokenId: 'randomString', balance: '0', decimals: 6 }],
+                };
+                sandBox.stub(src_1.Hbar.prototype, 'getAccountBalance').resolves(data);
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress: rootAddress,
+                        walletPassphrase,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        tokenId: tokenId,
+                    });
+                }, { message: 'Insufficient balance to recover token: ' + tokenId + ' for account: ' + rootAddress });
+            });
+            it('should throw error for insufficient native balance for token transfer', async function () {
+                const data = {
+                    hbars: '0.01',
+                    tokens: [{ tokenId: tokenId, balance: '10', decimals: 6 }],
+                };
+                sandBox.stub(src_1.Hbar.prototype, 'getAccountBalance').resolves(data);
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress: rootAddress,
+                        walletPassphrase,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        tokenId: tokenId,
+                    });
+                }, { message: 'Insufficient native balance to recover tokens, got native balance: 1000000 fee: ' + defaultFee });
+            });
+        });
+        describe('Unsigned Sweep', function () {
+            const sandBox = sinon_1.default.createSandbox();
+            let getBalanceStub;
+            afterEach(function () {
+                sandBox.verifyAndRestore();
+            });
+            it('should build unsigned sweep tx', async function () {
+                getBalanceStub = sandBox
+                    .stub(src_1.Hbar.prototype, 'getAccountBalance')
+                    .resolves({ hbars: formatBalanceResponse(balance), tokens: [] });
+                const startTime = (Date.now() / 1000 + 10).toFixed(); // timestamp in seconds, 10 seconds from now
+                const expectedAmount = new bignumber_js_1.BigNumber(balance).minus(defaultFee).toString();
+                const recovery = await basecoin.recover({
+                    userKey: userPub,
+                    backupKey: backupPub,
+                    rootAddress,
+                    bitgoKey,
+                    recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                    startTime,
+                });
+                getBalanceStub.callCount.should.equal(1);
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('txHex');
+                recovery.should.have.property('id', rootAddress + '@' + startTime + '.0');
+                recovery.should.have.property('userKey', userPub);
+                recovery.should.have.property('backupKey', backupPub);
+                recovery.should.have.property('bitgoKey', bitgoKey);
+                recovery.should.have.property('address', rootAddress);
+                recovery.should.have.property('coin', 'thbar');
+                recovery.should.have.property('maxFee', defaultFee.toString());
+                recovery.should.have.property('recipients', [{ address: recoveryDestination, amount: expectedAmount }]);
+                recovery.should.have.property('amount', expectedAmount);
+                recovery.should.have.property('validDuration', defaultValidDuration);
+                recovery.should.have.property('nodeId', defaultNodeId);
+                recovery.should.have.property('memo', memo);
+                recovery.should.have.property('startTime', startTime + '.0');
+                const txBuilder = basecoin.getBuilderFactory().from(recovery.txHex);
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.id.should.equal(rootAddress + '@' + startTime + '.0');
+                txJson.amount.should.equal(expectedAmount);
+                txJson.to.should.equal(recoveryDestination);
+                txJson.from.should.equal(rootAddress);
+                txJson.fee.should.equal(defaultFee);
+                txJson.node.should.equal(defaultNodeId);
+                txJson.memo.should.equal(memo);
+                txJson.validDuration.should.equal(defaultValidDuration);
+                txJson.startTime.should.equal(startTime + '.0');
+                txJson.validDuration.should.equal(defaultValidDuration);
+            });
+            it('should build unsigned sweep tx for tokens', async function () {
+                const balance = '100';
+                const data = {
+                    hbars: '1',
+                    tokens: [{ tokenId: tokenId, balance: balance, decimals: 6 }],
+                };
+                getBalanceStub = sandBox.stub(src_1.Hbar.prototype, 'getAccountBalance').resolves(data);
+                const startTime = (Date.now() / 1000 + 10).toFixed(); // timestamp in seconds, 10 seconds from now
+                const recovery = await basecoin.recover({
+                    userKey: userPub,
+                    backupKey: backupPub,
+                    rootAddress,
+                    bitgoKey,
+                    recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                    startTime,
+                    tokenId: tokenId,
+                });
+                getBalanceStub.callCount.should.equal(1);
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('txHex');
+                recovery.should.have.property('id', rootAddress + '@' + startTime + '.0');
+                recovery.should.have.property('userKey', userPub);
+                recovery.should.have.property('backupKey', backupPub);
+                recovery.should.have.property('bitgoKey', bitgoKey);
+                recovery.should.have.property('address', rootAddress);
+                recovery.should.have.property('coin', 'thbar');
+                recovery.should.have.property('maxFee', defaultFee.toString());
+                recovery.should.have.property('recipients', [
+                    { address: recoveryDestination, amount: balance, tokenName: 'thbar:usdc' },
+                ]);
+                recovery.should.have.property('amount', balance);
+                recovery.should.have.property('validDuration', defaultValidDuration);
+                recovery.should.have.property('nodeId', defaultNodeId);
+                recovery.should.have.property('memo', memo);
+                recovery.should.have.property('startTime', startTime + '.0');
+                const txBuilder = basecoin.getBuilderFactory().from(recovery.txHex);
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.id.should.equal(rootAddress + '@' + startTime + '.0');
+                txJson.amount.should.equal(balance);
+                txJson.to.should.equal(recoveryDestination);
+                txJson.from.should.equal(rootAddress);
+                txJson.fee.should.equal(defaultFee);
+                txJson.node.should.equal(defaultNodeId);
+                txJson.memo.should.equal(memo);
+                txJson.validDuration.should.equal(defaultValidDuration);
+                txJson.startTime.should.equal(startTime + '.0');
+                txJson.validDuration.should.equal(defaultValidDuration);
+            });
+            it('should throw if startTime is undefined', async function () {
+                const startTime = undefined;
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey: userPub,
+                        backupKey: backupPub,
+                        rootAddress,
+                        bitgoKey,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        startTime,
+                    });
+                }, { message: 'start time is required for unsigned sweep' });
+            });
+            it('should throw for invalid userKey', async function () {
+                const startTime = (Date.now() / 1000 + 10).toFixed();
+                const invalidUserPub = '302a300506032b6570032100randomstring';
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey: invalidUserPub,
+                        backupKey: backupPub,
+                        bitgoKey,
+                        rootAddress,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        startTime,
+                    });
+                }, { message: 'invalid userKey, got: ' + invalidUserPub });
+            });
+            it('should throw for invalid backupKey', async function () {
+                const invalidBackupPub = '302a300506032b6570032100randomstring';
+                const startTime = (Date.now() / 1000 + 10).toFixed();
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey: userPub,
+                        backupKey: invalidBackupPub,
+                        bitgoKey,
+                        rootAddress,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        startTime,
+                    });
+                }, { message: 'invalid backupKey, got: ' + invalidBackupPub });
+            });
+            it('should throw if startTime is a valid timestamp', async function () {
+                const startTime = 'asd';
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey: userPub,
+                        backupKey: backupPub,
+                        rootAddress,
+                        bitgoKey,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        startTime,
+                    });
+                }, { message: 'invalid startTime, got: ' + startTime });
+            });
+            it('should throw if startTime is not a future date', async function () {
+                const startTime = (Date.now() / 1000 - 1).toString(); // timestamp in seconds, 1 second ago
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey: userPub,
+                        backupKey: backupPub,
+                        rootAddress,
+                        bitgoKey,
+                        recoveryDestination: recoveryDestination + '?memoId=' + memo,
+                        startTime,
+                    });
+                }, { message: 'startTime must be a future timestamp, got: ' + startTime });
+            });
+        });
+        describe('Recovery with root keys', function () {
+            const sandBox = sinon_1.default.createSandbox();
+            let getBalanceStub;
+            const walletPassphrase = 'testbtcpassword1999';
+            const userEddsaRootXPrv = '{"iv":"lHOTkiuucR2JWFD1x1gqpQ==","v":1,"iter":10000,"ks":128,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"HkFrDVH++d8=","ct":"NBtbYdFEK84oH9uxwl/UrhRsW5nGJPnMSpRAo8Blrc7WTSPxGXmVS/EpUYEV03HG06/EnyBR0/Y6bjLQz4gkL6cGJD9hgyKqDvc9RtKHagEbo75oxPr0zP+r1HMUGBW38Ttgor674gBeb1Myew69xcS9KgguNxwz77X6fdeBhrfogLY22vcuLA=="}';
+            const userEddsaRootPub = 'd9cb9c9c617cfa0b715849516bb054a2b5d78c0e3eeef011176fb8bc0108c531';
+            const backupEddsaRootXprv = '{"iv":"sBoEFBBNoi2YVICPf16/BQ==","v":1,"iter":10000,"ks":128,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"HkFrDVH++d8=","ct":"GscOqJC+Iq+Lr39plQp5ZCamVlpJHOltGTZ7/UnUunIhFmZWMBLxjEVnMOtPreb0NZ4/SFqO/N3mZvq6JbB7vWRxJuqkBIiVcIRwkSWdW55cboKx2ec3ajg8+uO2pbvNDs26Q+9NtZ4jZnKNqSUXiCmtJXLRHQ32oyD+olKRpIR2NQo2+7kIEw=="}';
+            const backupEddsaRootPub = 'f163b1b8ee4c3343a97ac1d2470b967e967ac7b4e3731cacf02f28a1434a2f99';
+            const rootAddress = '0.0.3644667';
+            const memoId = '0';
+            beforeEach(function () {
+                getBalanceStub = sandBox
+                    .stub(src_1.Hbar.prototype, 'getAccountBalance')
+                    .resolves({ hbars: formatBalanceResponse(balance), tokens: [] });
+            });
+            afterEach(function () {
+                sandBox.verifyAndRestore();
+            });
+            it('should build and sign non-bitgo recovery tx with root keys', async function () {
+                const expectedAmount = new bignumber_js_1.BigNumber(balance).minus(defaultFee).toString();
+                const recovery = await basecoin.recover({
+                    userKey: userEddsaRootXPrv,
+                    backupKey: backupEddsaRootXprv,
+                    rootAddress,
+                    walletPassphrase,
+                    recoveryDestination: recoveryDestination + '?memoId=' + memoId,
+                });
+                getBalanceStub.callCount.should.equal(1);
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('id');
+                recovery.should.have.property('tx');
+                recovery.should.have.property('coin', 'thbar');
+                recovery.should.have.property('nodeId', defaultNodeId);
+                getBalanceStub.callCount.should.equal(1);
+                const txBuilder = basecoin.getBuilderFactory().from(recovery.tx);
+                const tx = await txBuilder.build();
+                tx.toBroadcastFormat().should.equal(recovery.tx);
+                const txJson = tx.toJson();
+                txJson.amount.should.equal(expectedAmount);
+                txJson.to.should.equal(recoveryDestination);
+                txJson.from.should.equal(rootAddress);
+                txJson.fee.should.equal(defaultFee);
+                txJson.node.should.equal(defaultNodeId);
+                txJson.memo.should.equal(memoId);
+                txJson.validDuration.should.equal(defaultValidDuration);
+                txJson.should.have.property('startTime');
+                recovery.should.have.property('startTime', txJson.startTime);
+                recovery.should.have.property('id', rootAddress + '@' + txJson.startTime);
+            });
+            it('should build unsigned sweep tx', async function () {
+                const startTime = (Date.now() / 1000 + 10).toFixed(); // timestamp in seconds, 10 seconds from now
+                const expectedAmount = new bignumber_js_1.BigNumber(balance).minus(defaultFee).toString();
+                const recovery = await basecoin.recover({
+                    userKey: userEddsaRootPub,
+                    backupKey: backupEddsaRootPub,
+                    rootAddress,
+                    bitgoKey,
+                    recoveryDestination: recoveryDestination + '?memoId=' + memoId,
+                    startTime,
+                });
+                getBalanceStub.callCount.should.equal(1);
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('txHex');
+                recovery.should.have.property('id', rootAddress + '@' + startTime + '.0');
+                recovery.should.have.property('userKey', userEddsaRootPub);
+                recovery.should.have.property('backupKey', backupEddsaRootPub);
+                recovery.should.have.property('bitgoKey', bitgoKey);
+                recovery.should.have.property('address', rootAddress);
+                recovery.should.have.property('coin', 'thbar');
+                recovery.should.have.property('maxFee', defaultFee.toString());
+                recovery.should.have.property('recipients', [{ address: recoveryDestination, amount: expectedAmount }]);
+                recovery.should.have.property('amount', expectedAmount);
+                recovery.should.have.property('validDuration', defaultValidDuration);
+                recovery.should.have.property('nodeId', defaultNodeId);
+                recovery.should.have.property('memo', memoId);
+                recovery.should.have.property('startTime', startTime + '.0');
+                const txBuilder = basecoin.getBuilderFactory().from(recovery.txHex);
+                const tx = await txBuilder.build();
+                const txJson = tx.toJson();
+                txJson.id.should.equal(rootAddress + '@' + startTime + '.0');
+                txJson.amount.should.equal(expectedAmount);
+                txJson.to.should.equal(recoveryDestination);
+                txJson.from.should.equal(rootAddress);
+                txJson.fee.should.equal(defaultFee);
+                txJson.node.should.equal(defaultNodeId);
+                txJson.memo.should.equal(memoId);
+                txJson.validDuration.should.equal(defaultValidDuration);
+                txJson.startTime.should.equal(startTime + '.0');
+                txJson.validDuration.should.equal(defaultValidDuration);
+            });
+        });
+    });
+    describe('broadcastTransaction', function () {
+        const sandBox = sinon_1.default.createSandbox();
+        afterEach(function () {
+            sandBox.verifyAndRestore();
+        });
+        it('should succeed if the startTime and serializedSignedTransaction are valid', async function () {
+            const startTime = (Date.now() / 1000 - 3).toFixed(); // timestamp in seconds, -3 seconds from now so it's valid after 2 seconds
+            const expectedResponse = { txId: '0.0.7668465@' + startTime + '.0', status: 'SUCCESS' };
+            const broadcastStub = sandBox.stub(src_1.Hbar.prototype, 'clientBroadcastTransaction').resolves(expectedResponse);
+            const serializedSignedTransaction = '1acc010a640a20592a4fbb7263c59d450e651df96620dc9208ee7c7d9d6f2fdcb91c53f88312611a40105b7d250c81f3705bc0b85168ce3fd00330131bb7701378681c8c2e6a09a91828715e7334f4ef28d20ff09887c6e87c0a5c693e23824c26f3ba161fce0448050a640a20a6905095616c3cfaa1bf61b53de30e938ce4112c3cc4d25393ec6b9bf4dea0631a40bf98c5b89b7a08544edaa1f4c08a0dfa6ec3f78b7e2fd27049283984050f38ccf0303ee57a377cc0a725ffd99d69e9fd914770ab0949ba556d84b3b00cb07e0d22500a130a0608cea8c1ad0612090800100018f185d40312060800100018031880c2d72f220308b40132013472240a220a0f0a090800100018f185d40310d3b0510a0f0a090800100018c484d30310d4b051';
+            const result = await basecoin.broadcastTransaction({ serializedSignedTransaction, startTime });
+            broadcastStub.callCount.should.equal(1);
+            result.should.deepEqual(expectedResponse);
+        });
+        it('should throw if the startTime is expired', async function () {
+            const startTime = (Date.now() / 1000 - 2000).toFixed(); // timestamp in seconds, 2000 seconds from now
+            const serializedSignedTransaction = '1acc010a640a20592a4fbb7263c59d450e651df96620dc9208ee7c7d9d6f2fdcb91c53f88312611a40105b7d250c81f3705bc0b85168ce3fd00330131bb7701378681c8c2e6a09a91828715e7334f4ef28d20ff09887c6e87c0a5c693e23824c26f3ba161fce0448050a640a20a6905095616c3cfaa1bf61b53de30e938ce4112c3cc4d25393ec6b9bf4dea0631a40bf98c5b89b7a08544edaa1f4c08a0dfa6ec3f78b7e2fd27049283984050f38ccf0303ee57a377cc0a725ffd99d69e9fd914770ab0949ba556d84b3b00cb07e0d22500a130a0608cea8c1ad0612090800100018f185d40312060800100018031880c2d72f220308b40132013472240a220a0f0a090800100018f185d40310d3b0510a0f0a090800100018c484d30310d4b051';
+            await assert_1.default.rejects(async () => {
+                await basecoin.broadcastTransaction({ serializedSignedTransaction, startTime });
+            }, (error) => {
+                assert_1.default.ok(error.message.includes('Failed to broadcast transaction, error: startTime window expired'));
+                return true;
+            });
+        });
+        it('should throw if the serializedSignedTransaction is invalid', async function () {
+            const startTime = (Date.now() / 1000 - 10).toFixed(); // timestamp in seconds, 10 seconds from now
+            const serializedSignedTransaction = 'randomstring';
+            await assert_1.default.rejects(async () => {
+                await basecoin.broadcastTransaction({ serializedSignedTransaction, startTime });
+            });
+        });
+        it('should throw if the startTime in the tx is invalid', async function () {
+            const expectedResponse = 'transaction 0.0.7668465@1706056301.000000000 failed precheck with status INVALID_TRANSACTION_START';
+            sandBox.stub(src_1.Hbar.prototype, 'clientBroadcastTransaction').rejects(new Error(expectedResponse));
+            const serializedSignedTransaction = '1acc010a640a20592a4fbb7263c59d450e651df96620dc9208ee7c7d9d6f2fdcb91c53f88312611a40105b7d250c81f3705bc0b85168ce3fd00330131bb7701378681c8c2e6a09a91828715e7334f4ef28d20ff09887c6e87c0a5c693e23824c26f3ba161fce0448050a640a20a6905095616c3cfaa1bf61b53de30e938ce4112c3cc4d25393ec6b9bf4dea0631a40bf98c5b89b7a08544edaa1f4c08a0dfa6ec3f78b7e2fd27049283984050f38ccf0303ee57a377cc0a725ffd99d69e9fd914770ab0949ba556d84b3b00cb07e0d22500a130a0608cea8c1ad0612090800100018f185d40312060800100018031880c2d72f220308b40132013472240a220a0f0a090800100018f185d40310d3b0510a0f0a090800100018c484d30310d4b051';
+            await assert_1.default.rejects(async () => {
+                await basecoin.broadcastTransaction({ serializedSignedTransaction });
+            }, { message: expectedResponse });
+        });
+    });
+    describe('deriveKeyWithSeed', function () {
+        it('should derive key with seed', function () {
+            (() => {
+                basecoin.deriveKeyWithSeed('test');
+            }).should.throw('method deriveKeyWithSeed not supported for eddsa curve');
+        });
+    });
+    describe('Generate wallet Root key pair: ', () => {
+        it('should generate key pair', () => {
+            const kp = basecoin.generateRootKeyPair();
+            basecoin.isValidPub(kp.pub).should.equal(true);
+            const keypair = new src_1.KeyPair({ prv: kp.prv }).getKeys(true);
+            keypair.should.have.property('prv');
+            keypair.prv?.should.equal(kp.prv.slice(0, 64));
+            keypair.pub.should.equal(kp.pub);
+        });
+        it('should generate key pair from seed', () => {
+            const seed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');
+            const kp = basecoin.generateRootKeyPair(seed);
+            basecoin.isValidPub(kp.pub).should.equal(true);
+            kp.pub.should.equal('d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a');
+            kp.prv.should.equal('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a');
+            const keypair = new src_1.KeyPair({ prv: kp.prv }).getKeys(true);
+            keypair.should.have.property('prv');
+            keypair.prv?.should.equal(kp.prv.slice(0, 64));
+            keypair.pub.should.equal(kp.pub);
+        });
+    });
+    describe('AuditKey', () => {
+        const { key } = hbarBackupKey_1.hbarBackupKey;
+        const walletPassphrase = 'kAm[EFQ6o=SxlcLFDw%,';
+        it('should return for valid inputs', () => {
+            basecoin.assertIsValidKey({
+                coinName: 'hbar',
+                encryptedPrv: key,
+                walletPassphrase,
+            });
+        });
+        it('should throw error if the walletPassphrase is incorrect', () => {
+            assert_1.default.throws(() => basecoin.assertIsValidKey({
+                coinName: 'hbar',
+                encryptedPrv: key,
+                walletPassphrase: 'foo',
+            }), { 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({
+                coinName: 'hbar',
+                encryptedPrv: alteredKey,
+                walletPassphrase,
+            }), {
+                message: 'failed to decrypt prv: json decrypt: invalid parameters',
+            });
+        });
+        it('should throw error if the key is not a valid key', () => {
+            const invalidKey = '#@)$#($*@)#($*';
+            const encryptedPrv = (0, sdk_api_1.encrypt)(walletPassphrase, invalidKey);
+            assert_1.default.throws(() => basecoin.assertIsValidKey({
+                coinName: 'hbar',
+                encryptedPrv,
+                walletPassphrase,
+            }), {
+                message: 'Invalid private key: Invalid private key length. Must be a hex and multiple of 2',
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hbar.js","sourceRoot":"","sources":["../../../test/unit/hbar.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\n\nimport * as _ from 'lodash';\nimport nock from 'nock';\nimport Sinon, { SinonStub } from 'sinon';\nimport { randomBytes } from 'crypto';\nimport { BigNumber } from 'bignumber.js';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI, encrypt } from '@bitgo-beta/sdk-api';\nimport { common, Wallet } from '@bitgo-beta/sdk-core';\nimport { TxData, Transfer } from '../../src/lib/iface';\n\nimport * as TestData from '../fixtures/hbar';\nimport { Hbar, Thbar, KeyPair, HbarToken } from '../../src';\nimport { getBuilderFactory } from './getBuilderFactory';\nimport { hbarBackupKey } from './fixtures/hbarBackupKey';\n\ndescribe('Hedera Hashgraph:', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin;\n  let token;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('thbar', Thbar.createInstance);\n    bitgo.safeRegister('hbar', Hbar.createInstance);\n    HbarToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {\n      bitgo.safeRegister(name, coinConstructor);\n    });\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('thbar');\n    token = bitgo.coin('thbar:usdc');\n  });\n\n  it('should instantiate the coin', function () {\n    const basecoin = bitgo.coin('hbar');\n    basecoin.should.be.an.instanceof(Hbar);\n  });\n\n  it('should check valid addresses', async function () {\n    const badAddresses = [\n      '',\n      '0.0',\n      'YZ09fd-',\n      '0.0.0.a',\n      'sadasdfggg',\n      '0.2.a.b',\n      '0.0.100?=sksjd',\n      '0.0.41098?memoId=',\n    ];\n    const goodAddresses = [\n      '0',\n      '0.0.0',\n      '0.0.41098',\n      '0.0.0?memoId=84',\n      '0.0.41098',\n      '0.0.41098?memoId=2aaaaa',\n      '0.0.41098?memoId=1',\n    ];\n\n    badAddresses.map((addr) => {\n      basecoin.isValidAddress(addr).should.equal(false);\n    });\n    goodAddresses.map((addr) => {\n      basecoin.isValidAddress(addr).should.equal(true);\n    });\n\n    const hexAddress = '0x23C3E227BE97281A70A549c7dDB8d5Caad3E7C84';\n    basecoin.isValidAddress(hexAddress).should.equal(false);\n  });\n\n  it('should explain a transaction', async function () {\n    const tx = JSON.parse(TestData.rawTransactionForExplain);\n    const explain = await basecoin.explainTransaction(tx);\n\n    explain.id.should.equal('0.0.43285@1600529800.643093586');\n    explain.outputAmount.should.equal('2200000000');\n    explain.timestamp.should.equal('1600529800.643093586');\n    explain.expiration.should.equal('180');\n    explain.outputs[0].amount.should.equal('2200000000');\n    explain.outputs[0].address.should.equal('0.0.43283');\n    explain.outputs[0].memo.should.equal('1');\n    explain.fee.should.equal(1160407);\n    explain.changeAmount.should.equal('0');\n  });\n\n  it('should explain a token transfer transaction', async function () {\n    const tokenTransferParam = {\n      txHex: TestData.UNSIGNED_TOKEN_TRANSFER,\n      feeInfo: {\n        size: 1000,\n        fee: 1160407,\n        feeRate: 1160407,\n      },\n    };\n    const explain = await basecoin.explainTransaction(tokenTransferParam);\n\n    explain.id.should.equal('0.0.81320@1596110493.372646570');\n    explain.outputAmount.should.equal('0');\n    explain.timestamp.should.equal('1596110493.372646570');\n    explain.expiration.should.equal('180');\n    explain.outputs[0].amount.should.equal('10');\n    explain.outputs[0].address.should.equal('0.0.75861');\n    explain.outputs[0].memo.should.equal('');\n    explain.outputs[0].tokenName.should.equal('thbar:usdc');\n    explain.fee.should.equal(1160407);\n    explain.changeAmount.should.equal('0');\n  });\n\n  it('should explain a multirecipients transfer transaction', async function () {\n    const multiTransferParam = {\n      txHex: TestData.UNSIGNED_MULTI_TRANSFER,\n      feeInfo: {\n        size: 1000,\n        fee: 1160407,\n        feeRate: 1160407,\n      },\n    };\n    const explain = await basecoin.explainTransaction(multiTransferParam);\n\n    explain.id.should.equal('0.0.81320@1596110493.372646570');\n    explain.outputAmount.should.equal('25');\n    explain.expiration.should.equal('180');\n    explain.outputs[0].amount.should.equal('10');\n    explain.outputs[0].address.should.equal('0.0.75861');\n    explain.outputs[0].memo.should.equal('');\n    explain.outputs[1].amount.should.equal('15');\n    explain.outputs[1].address.should.equal('0.0.78963');\n    explain.fee.should.equal(1160407);\n    explain.changeAmount.should.equal('0');\n  });\n\n  it('should explain a multirecipients token transfer transaction', async function () {\n    const tokenMultiTransferParam = {\n      txHex: TestData.UNSIGNED_TOKEN_MULTI_TRANSFER,\n      feeInfo: {\n        size: 1000,\n        fee: 1160407,\n        feeRate: 1160407,\n      },\n    };\n    const explain = await basecoin.explainTransaction(tokenMultiTransferParam);\n\n    explain.id.should.equal('0.0.81320@1596110493.372646570');\n    explain.outputAmount.should.equal('0');\n    explain.timestamp.should.equal('1596110493.372646570');\n    explain.expiration.should.equal('180');\n    explain.outputs[0].amount.should.equal('10');\n    explain.outputs[0].address.should.equal('0.0.75861');\n    explain.outputs[0].memo.should.equal('');\n    explain.outputs[0].tokenName.should.equal('thbar:usdc');\n    explain.outputs[1].amount.should.equal('15');\n    explain.outputs[1].address.should.equal('0.0.78963');\n    explain.outputs[1].tokenName.should.equal('thbar:usdc');\n    explain.fee.should.equal(1160407);\n    explain.changeAmount.should.equal('0');\n  });\n\n  it('should explain a token associate transaction', async function () {\n    const tokenAssociateParam = {\n      txHex: TestData.UNSIGNED_TOKEN_ASSOCIATE,\n      feeInfo: {\n        size: 1000,\n        fee: 1160407,\n        feeRate: 1160407,\n      },\n    };\n    const explain = await basecoin.explainTransaction(tokenAssociateParam);\n\n    explain.id.should.equal('0.0.81320@1596110493.372646570');\n    explain.outputAmount.should.equal('0');\n    explain.timestamp.should.equal('1596110493.372646570');\n    explain.expiration.should.equal('180');\n    explain.outputs[0].amount.should.equal('0');\n    explain.outputs[0].address.should.equal('0.0.81320');\n    explain.outputs[0].memo.should.equal('');\n    explain.outputs[0].tokenName.should.equal('thbar:usdc');\n    explain.fee.should.equal(1160407);\n    explain.changeAmount.should.equal('0');\n  });\n\n  it('should verify isWalletAddress', async function () {\n    const baseAddress = '0.0.41098';\n    const validAddress1 = '0.0.41098?memoId=1';\n    const validAddress2 = '0.0.41098?memoId=2';\n    const unrelatedValidAddress = '0.1.41098?memoId=1';\n    const invalidAddress = '0.0.0.a';\n    (await basecoin.isWalletAddress({ address: validAddress1, baseAddress })).should.true();\n    (await basecoin.isWalletAddress({ address: validAddress2, baseAddress })).should.true();\n    (await basecoin.isWalletAddress({ address: validAddress2, baseAddress: validAddress1 })).should.true();\n    (await basecoin.isWalletAddress({ address: unrelatedValidAddress, baseAddress })).should.false();\n\n    assert.rejects(\n      async () => basecoin.isWalletAddress({ address: invalidAddress, baseAddress }),\n      `invalid address ${invalidAddress}`\n    );\n  });\n\n  describe('Keypairs:', () => {\n    it('should generate a keypair from random seed', function () {\n      const keyPair = basecoin.generateKeyPair();\n      keyPair.should.have.property('pub');\n      keyPair.should.have.property('prv');\n\n      basecoin.isValidPub(keyPair.pub).should.equal(true);\n    });\n\n    it('should generate a keypair from a seed', function () {\n      const seedText = '80350b4208d381fbfe2276a326603049fe500731c46d3c9936b5ce036b51377f';\n      const seed = Buffer.from(seedText, 'hex');\n      const keyPair = basecoin.generateKeyPair(seed);\n\n      keyPair.prv.should.equal(\n        '302e020100300506032b65700422042080350b4208d381fbfe2276a326603049fe500731c46d3c9936b5ce036b51377f'\n      );\n      keyPair.pub.should.equal(\n        '302a300506032b65700321009cc402b5c75214269c2826e3c6119377cab6c367601338661c87a4e07c6e0333'\n      );\n    });\n\n    it('should validate a stellar seed', function () {\n      basecoin.isStellarSeed('SBMWLNV75BPI2VB4G27RWOMABVRTSSF7352CCYGVELZDSHCXWCYFKXIX').should.ok();\n    });\n\n    it('should convert a stellar seed to an hbar prv', function () {\n      const seed = basecoin.convertFromStellarSeed('SBMWLNV75BPI2VB4G27RWOMABVRTSSF7352CCYGVELZDSHCXWCYFKXIX');\n      seed.should.equal(\n        '302e020100300506032b6570042204205965b6bfe85e8d543c36bf1b39800d633948bfdf742160d522f2391c57b0b055'\n      );\n    });\n  });\n\n  describe('Verify Transaction:', () => {\n    let newTxPrebuild;\n    let newTxParams;\n    let newTxParamsWithError;\n    let newTxParamsWithExtraData;\n    const txPrebuild = {\n      recipients: [\n        {\n          address: 'lionteste212',\n          amount: '1000',\n        },\n      ],\n      txHex: TestData.UNSIGNED_MULTI_TRANSFER,\n      txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',\n      isVotingTransaction: false,\n      coin: 'thbar',\n      feeInfo: {\n        size: 1000,\n        fee: 1160407,\n        feeRate: 1160407,\n      },\n    };\n    const txParams = {\n      txPrebuild,\n      recipients: [\n        {\n          address: '0.0.75861',\n          amount: '10',\n        },\n        {\n          address: '0.0.78963',\n          amount: '15',\n        },\n      ],\n    };\n    const memo = { value: '' };\n    const txParamsWithError = {\n      txPrebuild,\n      recipients: [\n        {\n          address: '0.0.75861',\n          amount: '1000',\n        },\n      ],\n    };\n    const txParamsWithExtraData = {\n      txPrebuild,\n      recipients: [\n        {\n          address: '0.0.75861',\n          amount: '10',\n          data: undefined,\n        },\n        {\n          address: '0.0.78963',\n          amount: '15',\n          data: undefined,\n        },\n      ],\n    };\n    const walletData = {\n      id: '5b34252f1bf349930e34020a00000000',\n      coin: 'thbar',\n      keys: [\n        '5b3424f91bf349930e34017500000000',\n        '5b3424f91bf349930e34017600000000',\n        '5b3424f91bf349930e34017700000000',\n      ],\n      coinSpecific: {\n        baseAddress: '0.0.2935',\n      },\n      multisigType: 'onchain',\n    };\n    const walletObj = new Wallet(bitgo, basecoin, walletData);\n\n    before(function () {\n      newTxPrebuild = () => {\n        return _.cloneDeep(txPrebuild);\n      };\n      newTxParams = () => {\n        return _.cloneDeep(txParams);\n      };\n      newTxParamsWithError = () => {\n        return _.cloneDeep(txParamsWithError);\n      };\n      newTxParamsWithExtraData = () => {\n        return _.cloneDeep(txParamsWithExtraData);\n      };\n    });\n\n    it('should verify native transfer transactions', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\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 fail verify when input `recipients` is absent', async function () {\n      const txParams = newTxParams();\n      txParams.recipients = undefined;\n      const txPrebuild = newTxPrebuild();\n      await basecoin\n        .verifyTransaction({ txParams, txPrebuild, memo: memo, wallet: walletObj } as any)\n        .should.be.rejectedWith('missing required tx params property recipients');\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, 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 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        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 txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n      txParams.type = 'enabletoken';\n      txParams.recipients = [\n        {\n          address: '0.0.81320',\n          amount: '0',\n          tokenName: 'thbar:usdc',\n        },\n      ];\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        wallet: walletObj,\n        verification: { verifyTokenEnablement: true },\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should fail verify create associated token account transaction with mismatch recipients', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n      txParams.type = 'enabletoken';\n      txParams.recipients = [\n        {\n          address: '0.0.81321',\n          amount: '0',\n          tokenName: 'thbar:usdc',\n        },\n      ];\n      await basecoin\n        .verifyTransaction({\n          txParams,\n          txPrebuild,\n          memo,\n          wallet: walletObj,\n          verification: { verifyTokenEnablement: true },\n        } as any)\n        .should.be.rejectedWith('Invalid token enablement transaction: Expected account 0.0.81321, got 0.0.81320');\n    });\n\n    it('should verify token transfer transaction', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txHex = TestData.UNSIGNED_TOKEN_MULTI_TRANSFER;\n      txParams.recipients = [\n        {\n          address: '0.0.75861',\n          amount: '10',\n          tokenName: 'thbar:usdc',\n        },\n        {\n          address: '0.0.78963',\n          amount: '15',\n          tokenName: 'thbar:usdc',\n        },\n      ];\n      const validTransaction = await token.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        wallet: walletObj,\n      } as any);\n      validTransaction.should.equal(true);\n    });\n\n    it('should verify token transfer transaction with any token name on token base coin', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txHex = TestData.UNSIGNED_TOKEN_MULTI_TRANSFER;\n      txParams.recipients = [\n        {\n          address: '0.0.75861',\n          amount: '10',\n          tokenName: 'thbar:usdc',\n        },\n        {\n          address: '0.0.78963',\n          amount: '15',\n        },\n      ];\n      (await token.verifyTransaction({ txParams, txPrebuild, memo, wallet: walletObj } as any)).should.equal(true);\n    });\n\n    it('should fail to verify token transfer with mismatched recipients', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txHex = TestData.UNSIGNED_TOKEN_MULTI_TRANSFER;\n      txParams.recipients = [\n        {\n          address: '0.0.75861',\n          amount: '11',\n          tokenName: 'thbar:usdc',\n        },\n        {\n          address: '0.0.78963',\n          amount: '15',\n        },\n      ];\n      await token\n        .verifyTransaction({ txParams, txPrebuild, memo, wallet: walletObj } as any)\n        .should.be.rejectedWith('Tx outputs does not match with expected txParams recipients');\n    });\n\n    it('should fail to verify token transfer with incorrect token name', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txHex = TestData.UNSIGNED_TOKEN_MULTI_TRANSFER;\n      txParams.recipients = [\n        {\n          address: '0.0.75861',\n          amount: '11',\n          tokenName: 'thbar:usdc',\n        },\n        {\n          address: '0.0.78963',\n          amount: '15',\n          tokenName: 'invalidtoken',\n        },\n      ];\n      await token\n        .verifyTransaction({ txParams, txPrebuild, memo, wallet: walletObj } as any)\n        .should.be.rejectedWith('Incorrect token name specified in recipients');\n    });\n\n    it('should success to verify transfer having address with memo id', async function () {\n      const txParams = newTxParams();\n      const txPrebuild = newTxPrebuild();\n      txPrebuild.txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n      txParams.type = 'enabletoken';\n      txParams.recipients = [\n        {\n          address: '0.0.81320?memoId=1',\n          amount: '0',\n          tokenName: 'thbar:usdc',\n        },\n      ];\n      const validTransaction = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        memo,\n        wallet: walletObj,\n        verification: { verifyTokenEnablement: true },\n      } as any);\n      validTransaction.should.equal(true);\n    });\n  });\n\n  describe('Verify Token Enablement Transaction:', () => {\n    it('should verify a valid token enablement transaction with tokenName', async function () {\n      const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n      const expectedToken = { tokenName: 'thbar:usdc' };\n      const expectedAccountId = '0.0.81320';\n\n      await basecoin.verifyTokenEnablementTransaction(txHex, expectedToken, expectedAccountId);\n    });\n\n    it('should verify a valid token enablement transaction with tokenId', async function () {\n      const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n      const expectedToken = { tokenId: '0.0.429274' }; // Actual tokenId for thbar:usdc\n      const expectedAccountId = '0.0.81320';\n\n      await basecoin.verifyTokenEnablementTransaction(txHex, expectedToken, expectedAccountId);\n    });\n\n    it('should fail when txHex is missing', async function () {\n      await basecoin\n        .verifyTokenEnablementTransaction('', { tokenName: 'thbar:usdc' }, '0.0.81320')\n        .should.be.rejectedWith('Missing required parameters: txHex');\n    });\n\n    it('should fail when expectedAccountId is missing', async function () {\n      await basecoin\n        .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_ASSOCIATE, { tokenName: 'thbar:usdc' }, '')\n        .should.be.rejectedWith('Missing required parameters: expectedAccountId');\n    });\n\n    it('should fail when wallet platform sends spoofed transaction hex for token enablement', async function () {\n      // Create a valid transaction response structure from wallet platform with spoofed txHex\n      // The txHex looks like valid hex but contains malicious/invalid transaction data\n      const spoofedTxHex = '0a0c0a080800100018a8fb0410130a0c0a080800100018d5d0041014'; // Valid hex but invalid transaction\n\n      // Mock the API endpoints that will be called during token enablement\n      const bgUrl = common.Environments['mock'].uri;\n\n      // Mock the key endpoint needed for signing\n      nock(bgUrl)\n        .post('/api/v2/thbar/key/5b3424f91bf34993006eae94')\n        .reply(200, [\n          {\n            encryptedPrv: 'fakePrv',\n          },\n        ]);\n\n      // Mock the prebuild API response to return spoofed txHex\n      nock(bgUrl)\n        .post('/api/v2/thbar/wallet/5b34252f1bf34993006eae96/tx/build')\n        .reply(200, {\n          txHex: spoofedTxHex,\n          txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',\n          recipients: [\n            {\n              address: '0.0.81320',\n              amount: '0', // Valid amount for token enablement\n            },\n          ],\n          coin: 'thbar',\n          feeInfo: {\n            size: 1000,\n            fee: 1160407,\n            feeRate: 1160407,\n          },\n        });\n\n      // This should fail because the spoofed transaction hex contains invalid transaction data\n      // The verification logic should catch this when trying to validate the transaction\n      await assert.rejects(\n        async () => {\n          // Test the verification directly instead of going through the wallet flow\n          await basecoin.verifyTokenEnablementTransaction(spoofedTxHex, { tokenName: 'thbar:usdc' }, '0.0.81320');\n        },\n        (error: any) => {\n          // The error should indicate that the transaction is invalid\n          return error.message.includes('Invalid token enablement transaction');\n        }\n      );\n    });\n\n    it('should fail when both tokenId and tokenName are missing', async function () {\n      await basecoin\n        .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_ASSOCIATE, {}, '0.0.81320')\n        .should.be.rejectedWith('Missing required parameters: expectedToken.tokenId|tokenName');\n    });\n\n    it('should fail when token name does not match', async function () {\n      await basecoin\n        .verifyTokenEnablementTransaction(\n          TestData.UNSIGNED_TOKEN_ASSOCIATE,\n          { tokenName: 'thbar:wrongtoken' },\n          '0.0.81320'\n        )\n        .should.be.rejectedWith(/Expected token name thbar:wrongtoken, got thbar:usdc/);\n    });\n\n    it('should fail when account ID does not match', async function () {\n      await basecoin\n        .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_ASSOCIATE, { tokenName: 'thbar:usdc' }, '0.0.99999')\n        .should.be.rejectedWith(/Expected account 0.0.99999, got 0.0.81320/);\n    });\n\n    it('should fail when transaction is not a token enablement (has non-zero amount)', async function () {\n      // Use a regular transfer transaction which has non-zero amount\n      await basecoin\n        .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_TRANSFER, { tokenName: 'thbar:usdc' }, '0.0.81320')\n        .should.be.rejectedWith(/Expected output amount '0'/);\n    });\n\n    it('should fail when transaction type is not tokenAssociate', async function () {\n      // Use a regular transfer transaction which is not tokenAssociate\n      // This will fail on amount validation first, but that's expected behavior\n      await basecoin\n        .verifyTokenEnablementTransaction(TestData.UNSIGNED_TOKEN_TRANSFER, { tokenName: 'thbar:usdc' }, '0.0.81320')\n        .should.be.rejectedWith(/Expected output amount '0'/);\n    });\n\n    it('should validate transaction type for valid token associate transaction', async function () {\n      // This test ensures the transaction type validation works for valid token associate transactions\n      const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n      const expectedToken = { tokenName: 'thbar:usdc' };\n      const expectedAccountId = '0.0.81320';\n\n      await basecoin.verifyTokenEnablementTransaction(txHex, expectedToken, expectedAccountId);\n    });\n\n    it('should fail with invalid transaction hex', async function () {\n      await basecoin\n        .verifyTokenEnablementTransaction('invalid_hex', { tokenName: 'thbar:usdc' }, '0.0.81320')\n        .should.be.rejectedWith(/Invalid token enablement transaction/);\n    });\n\n    it('should fail when txHex contains wrong tokenId compared to expected', async function () {\n      // This test ensures direct txHex validation catches spoofed tokenIds\n      const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n      const wrongTokenId = '0.0.999999'; // Wrong tokenId\n      const expectedAccountId = '0.0.81320';\n\n      await basecoin\n        .verifyTokenEnablementTransaction(txHex, { tokenId: wrongTokenId }, expectedAccountId)\n        .should.be.rejectedWith(\n          new RegExp(`Expected tokenId ${_.escapeRegExp(wrongTokenId)}, but transaction contains tokenId`)\n        );\n    });\n\n    it('should fail when txHex contains wrong accountId compared to expected', async function () {\n      // This test ensures direct txHex validation catches spoofed accountIds\n      const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n      const expectedToken = { tokenName: 'thbar:usdc' };\n      const wrongAccountId = '0.0.999999'; // Wrong accountId\n\n      await basecoin\n        .verifyTokenEnablementTransaction(txHex, expectedToken, wrongAccountId)\n        .should.be.rejectedWith(new RegExp(`Expected account ${_.escapeRegExp(wrongAccountId)}, got`));\n    });\n\n    it('should pass verification for valid token enablement transaction without throwing error', async function () {\n      // This test ensures that a valid token enablement transaction passes all validations\n      const txHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n      const expectedToken = { tokenName: 'thbar:usdc' };\n      const expectedAccountId = '0.0.81320';\n\n      // This should complete without throwing any errors\n      await basecoin.verifyTokenEnablementTransaction(txHex, expectedToken, expectedAccountId);\n\n      // If we reach this point, the test passed\n      assert.ok(true, 'Valid token enablement transaction should not throw any errors');\n    });\n\n    it('should successfully complete sendTokenEnablements with valid transaction response from wallet platform', async function () {\n      const validTxHex = TestData.UNSIGNED_TOKEN_ASSOCIATE;\n\n      const wallet = {\n        id: () => '5b34252f1bf34993006eae96',\n        coin: () => 'thbar',\n        prebuildTransaction: async () => ({\n          txHex: validTxHex, // Valid token associate transaction\n          txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',\n          recipients: [{ address: '0.0.81320', amount: '0' }],\n          coin: 'thbar',\n          feeInfo: { size: 1000, fee: 1160407, feeRate: 1160407 },\n        }),\n        sendTokenEnablements: async (params: any) => {\n          const txPrebuild = await wallet.prebuildTransaction();\n          await basecoin.verifyTransaction({\n            txParams: {\n              type: 'enabletoken',\n              recipients: [{ address: '0.0.81320', amount: '0', tokenName: 'thbar:usdc' }],\n            },\n            txPrebuild,\n            verification: { verifyTokenEnablement: true },\n          });\n\n          return {\n            success: [{ txid: txPrebuild.txid, status: 'success' }],\n            failure: [],\n          };\n        },\n      };\n\n      await wallet.sendTokenEnablements({\n        recipients: [{ address: '0.0.81320', tokenName: 'thbar:usdc' }],\n      });\n\n      assert.ok(\n        true,\n        'Valid token enablement transaction should complete successfully through sendTokenEnablements flow'\n      );\n    });\n\n    it('should detect spoofed transaction hex through sendTokenEnablements flow', async function () {\n      // Use a valid transfer transaction hex instead of a token associate transaction\n      // This will parse correctly but fail validation because it's not a token associate transaction\n      const spoofedTxHex = TestData.UNSIGNED_TOKEN_TRANSFER; // Valid transfer transaction, not token associate\n\n      // Create a wallet mock for the sendTokenEnablements flow\n      const wallet = {\n        id: () => '5b34252f1bf34993006eae96',\n        coin: () => 'thbar',\n        prebuildTransaction: async () => ({\n          txHex: spoofedTxHex,\n          txid: '586c5b59b10b134d04c16ac1b273fe3c5529f34aef75db4456cd469c5cdac7e2',\n          recipients: [{ address: '0.0.81320', amount: '0' }],\n          coin: 'thbar',\n          feeInfo: { size: 1000, fee: 1160407, feeRate: 1160407 },\n        }),\n        sendTokenEnablements: async (params: any) => {\n          // This should trigger the verification and fail\n          const txPrebuild = await wallet.prebuildTransaction();\n          return basecoin.verifyTransaction({\n            txParams: {\n              type: 'enabletoken',\n              recipients: [{ address: '0.0.81320', amount: '0', tokenName: 'thbar:usdc' }],\n            },\n            txPrebuild,\n            verification: { verifyTokenEnablement: true },\n          });\n        },\n      };\n\n      // This should fail because the spoofed transaction hex contains a transfer transaction, not a token associate\n      await assert.rejects(\n        async () => {\n          await wallet.sendTokenEnablements({\n            recipients: [{ address: '0.0.81320', tokenName: 'thbar:usdc' }],\n          });\n        },\n        (error: any) => {\n          // The error should indicate that the transaction is invalid for token enablement\n          return (\n            error.message.includes('Invalid token enablement transaction') ||\n            error.message.includes('Token enablement transaction missing tokenId') ||\n            error.message.includes(\"Expected output amount '0'\") ||\n            error.message.includes('Transaction is not a TokenAssociate transaction')\n          );\n        }\n      );\n    });\n  });\n\n  describe('Sign Message', () => {\n    it('should be performed', async () => {\n      const keyPair = new KeyPair();\n      const messageToSign = Buffer.from(randomBytes(32)).toString('hex');\n      const signature = await basecoin.signMessage(keyPair.getKeys(), messageToSign);\n      keyPair.verifySignature(messageToSign, Uint8Array.from(Buffer.from(signature, 'hex'))).should.equals(true);\n    });\n\n    it('should fail with missing private key', async () => {\n      const keyPair = new KeyPair({\n        pub: '302a300506032b6570032100d8fd745361df270776a3ab1b55d5590ec00a26ab45eea37197dc9894a81fcb82',\n      }).getKeys();\n      const messageToSign = Buffer.from(randomBytes(32)).toString('hex');\n      await basecoin.signMessage(keyPair, messageToSign).should.be.rejectedWith('Invalid key pair options');\n    });\n  });\n\n  describe('Sign transaction:', () => {\n    const destination = '0.0.129369';\n    const source = '0.0.1234';\n    const amount = '100000';\n    /**\n     * Build an unsigned account-lib multi-signature send transaction\n     * @param destination The destination address of the transaction\n     * @param source The account sending thist ransaction\n     * @param amount The amount to send to the recipient\n     */\n    const buildUnsignedTransaction = async function ({ destination, source, amount = '100000' }) {\n      const factory = getBuilderFactory('thbar');\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.fee({\n        fee: '100000',\n      });\n      txBuilder.source({ address: source });\n      txBuilder.send({ address: destination, amount });\n\n      return await txBuilder.build();\n    };\n\n    it('should sign transaction', async function () {\n      const key = new KeyPair();\n      const unsignedTransaction = await buildUnsignedTransaction({\n        destination,\n        source,\n        amount,\n      });\n\n      const tx = await basecoin.signTransaction({\n        prv: key.getKeys().prv!.toString(),\n        txPrebuild: {\n          txHex: unsignedTransaction.toBroadcastFormat(),\n        },\n      });\n\n      const factory = getBuilderFactory('thbar');\n      const txBuilder = factory.from(tx.halfSigned.txHex);\n      const signedTx = await txBuilder.build();\n      const txJson = signedTx.toJson() as TxData;\n      txJson.should.have.properties('to', 'amount');\n      txJson.to?.should.equal(destination);\n      txJson.from.should.equal(source);\n      txJson.amount?.should.equal(amount);\n      (txJson.instructionsData as Transfer).params.recipients[0].should.deepEqual({\n        address: destination,\n        amount,\n      });\n      signedTx.signature.length.should.equal(1);\n    });\n\n    it('should fully sign transaction with root key', async function () {\n      const key1 = basecoin.generateRootKeyPair();\n      const key2 = basecoin.generateRootKeyPair();\n\n      const unsignedTransaction = await buildUnsignedTransaction({\n        destination,\n        source,\n        amount,\n      });\n\n      const txHalfSigned = await basecoin.signTransaction({\n        prv: key1.prv,\n        txPrebuild: {\n          txHex: unsignedTransaction.toBroadcastFormat(),\n        },\n      });\n\n      const factory = getBuilderFactory('thbar');\n      const txBuilderHalfSigned = factory.from(txHalfSigned.halfSigned.txHex);\n      const halfSignedTx = await txBuilderHalfSigned.build();\n      const halfSignedTxJson = halfSignedTx.toJson() as TxData;\n      halfSignedTxJson.should.have.properties('to', 'amount');\n      halfSignedTxJson.to?.should.equal(destination);\n      halfSignedTxJson.from.should.equal(source);\n      halfSignedTxJson.amount?.should.equal(amount);\n      (halfSignedTxJson.instructionsData as Transfer).params.recipients[0].should.deepEqual({\n        address: destination,\n        amount,\n      });\n      halfSignedTx.signature.length.should.equal(1);\n\n      const txSigned = await basecoin.signTransaction({\n        prv: key2.prv,\n        txPrebuild: {\n          txHex: halfSignedTx.toBroadcastFormat(),\n        },\n      });\n\n      const txBuilderSigned = factory.from(txSigned.txHex);\n      const signedTx = await txBuilderSigned.build();\n      const signedTxJson = signedTx.toJson() as TxData;\n      signedTxJson.should.have.properties('to', 'amount');\n      signedTxJson.to?.should.equal(destination);\n      signedTxJson.from.should.equal(source);\n      signedTxJson.amount?.should.equal(amount);\n      (signedTxJson.instructionsData as Transfer).params.recipients[0].should.deepEqual({\n        address: destination,\n        amount,\n      });\n      signedTx.signature.length.should.equal(2);\n    });\n  });\n\n  describe('Recovery', function () {\n    const defaultValidDuration = '180';\n    const defaultFee = 10000000;\n    const defaultNodeId = '0.0.3';\n    const userKey =\n      '{\"iv\":\"WlPuJOejRWgj/NTd3UMgrw==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"6yAVFvreHSQ=\",\"ct\":\"8j/lBVkFByKlVhaS9JWmmLja5yTokjaIiLDxMIDjMojVEim9T36WAm5qW6v1V0A7QcEuGiVl3PKMDa+Gr6tI/HT58DW5RE+pHzya9MUQpAgNrJr8VEWjrXWqZECVtra1/bKCyB+mozc=\"}';\n    const userPub = '302a300506032b6570032100ddd53a1591d72b181109bd3e57b18603740490b9ab4d37bc7fa27480e6b8c911';\n    const backupKey =\n      '{\"iv\":\"D5DVDozQx9B02JeFV0/OVA==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"7FUNF8M35bo=\",\"ct\":\"ZiPsu5Qe/AIS4JQXt+rrusHnYCy4CqurM16R5wJrd4CEx7u85y3yy5ErnsdyYYcc3txyNmUIQ2/CBq/LKoKO/VIeU++CnKxzGuHGcNI47BPk3RQK42a66uIQn/yTR++XgdK1KhvUL3U=\"}';\n    const backupPub = '302a300506032b65700321006293e4ec9bf1b2d8fae631119107248a65e2207a05d32a11f42cc3d9a3005d4a';\n    const rootAddress = '0.0.7671186';\n    const walletPassphrase = 'TestPasswordPleaseIgnore';\n    const recoveryDestination = '0.0.7651908';\n    const bitgoKey = '5a93b01ea87e963f61c974a89d62e3841392f1ba020fbbcc65a8089ca025abbb';\n    const memo = '4';\n    const balance = '1000000000';\n    const formatBalanceResponse = (balance: string) =>\n      new BigNumber(balance).dividedBy(basecoin.getBaseFactor()).toFixed(9) + ' ℏ';\n    const tokenId = '0.0.429274';\n\n    describe('Non-BitGo', async function () {\n      const sandBox = Sinon.createSandbox();\n\n      afterEach(function () {\n        sandBox.verifyAndRestore();\n      });\n\n      it('should build and sign the recovery tx', async function () {\n        const expectedAmount = new BigNumber(balance).minus(defaultFee).toString();\n        const getBalanceStub = sandBox\n          .stub(Hbar.prototype, 'getAccountBalance')\n          .resolves({ hbars: formatBalanceResponse(balance), tokens: [] });\n\n        const recovery = await basecoin.recover({\n          userKey,\n          backupKey,\n          rootAddress,\n          walletPassphrase,\n          recoveryDestination: recoveryDestination + '?memoId=' + memo,\n        });\n\n        recovery.should.not.be.undefined();\n        recovery.should.have.property('id');\n        recovery.should.have.property('tx');\n        recovery.should.have.property('coin', 'thbar');\n        recovery.should.have.property('nodeId', defaultNodeId);\n        getBalanceStub.callCount.should.equal(1);\n        const txBuilder = basecoin.getBuilderFactory().from(recovery.tx);\n        const tx = await txBuilder.build();\n        tx.toBroadcastFormat().should.equal(recovery.tx);\n        const txJson = tx.toJson();\n        txJson.amount.should.equal(expectedAmount);\n        txJson.to.should.equal(recoveryDestination);\n        txJson.from.should.equal(rootAddress);\n        txJson.fee.should.equal(defaultFee);\n        txJson.node.should.equal(defaultNodeId);\n        txJson.memo.should.equal(memo);\n        txJson.validDuration.should.equal(defaultValidDuration);\n        txJson.should.have.property('startTime');\n        recovery.should.have.property('startTime', txJson.startTime);\n        recovery.should.have.property('id', rootAddress + '@' + txJson.startTime);\n      });\n\n      it('should throw for invalid rootAddress', async function () {\n        const invalidRootAddress = 'randomstring';\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress: 'randomstring',\n              walletPassphrase,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n            });\n          },\n          { message: 'invalid rootAddress, got: ' + invalidRootAddress }\n        );\n      });\n\n      it('should throw for invalid recoveryDestination', async function () {\n        const invalidRecoveryDestination = 'randomstring';\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress,\n              walletPassphrase,\n              recoveryDestination: 'randomstring',\n            });\n          },\n          { message: 'invalid recoveryDestination, got: ' + invalidRecoveryDestination }\n        );\n      });\n\n      it('should throw for invalid nodeId', async function () {\n        const invalidNodeId = 'a.2.3';\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress,\n              walletPassphrase,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              nodeId: invalidNodeId,\n            });\n          },\n          { message: 'invalid nodeId, got: ' + invalidNodeId }\n        );\n      });\n\n      it('should throw for invalid maxFee', async function () {\n        const invalidMaxFee = '-32';\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress,\n              walletPassphrase,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              maxFee: invalidMaxFee,\n            });\n          },\n          { message: 'invalid maxFee, got: ' + invalidMaxFee }\n        );\n      });\n\n      it('should throw if there is no enough balance to recover', async function () {\n        const getBalanceStub = sandBox\n          .stub(Hbar.prototype, 'getAccountBalance')\n          .resolves({ hbars: formatBalanceResponse('100'), tokens: [] });\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress,\n              walletPassphrase,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n            });\n          },\n          { message: 'Insufficient balance to recover, got balance: 100 fee: 10000000' }\n        );\n\n        getBalanceStub.callCount.should.equal(1);\n      });\n\n      it('should throw if the walletPassphrase is undefined', async function () {\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n            });\n          },\n          { message: 'walletPassphrase is required for non-bitgo recovery' }\n        );\n      });\n\n      it('should throw if the walletPassphrase is wrong', async function () {\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress,\n              walletPassphrase: 'randompassword',\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n            });\n          },\n          {\n            message:\n              \"unable to decrypt userKey or backupKey with the walletPassphrase provided, got error: password error - ccm: tag doesn't match\",\n          }\n        );\n      });\n\n      it('should build and sign the recovery tx for tokens', async function () {\n        const balance = '100';\n        const data = {\n          hbars: '1',\n          tokens: [{ tokenId: tokenId, balance: balance, decimals: 6 }],\n        };\n        const getBalanceStub = sandBox.stub(Hbar.prototype, 'getAccountBalance').resolves(data);\n\n        const recovery = await basecoin.recover({\n          userKey,\n          backupKey,\n          rootAddress,\n          walletPassphrase,\n          recoveryDestination: recoveryDestination + '?memoId=' + memo,\n          tokenId: tokenId,\n        });\n\n        recovery.should.not.be.undefined();\n        recovery.should.have.property('id');\n        recovery.should.have.property('tx');\n        recovery.should.have.property('coin', 'thbar');\n        recovery.should.have.property('nodeId', defaultNodeId);\n        getBalanceStub.callCount.should.equal(1);\n        const txBuilder = basecoin.getBuilderFactory().from(recovery.tx);\n        const tx = await txBuilder.build();\n        tx.toBroadcastFormat().should.equal(recovery.tx);\n        const txJson = tx.toJson();\n        txJson.amount.should.equal(balance);\n        txJson.to.should.equal(recoveryDestination);\n        txJson.from.should.equal(rootAddress);\n        txJson.fee.should.equal(defaultFee);\n        txJson.node.should.equal(defaultNodeId);\n        txJson.memo.should.equal(memo);\n        txJson.validDuration.should.equal(defaultValidDuration);\n        txJson.should.have.property('startTime');\n        recovery.should.have.property('startTime', txJson.startTime);\n        recovery.should.have.property('id', rootAddress + '@' + txJson.startTime);\n      });\n\n      it('should throw error for non supported invalid tokenId', async function () {\n        const invalidTokenId = 'randomstring';\n        const data = {\n          hbars: '1',\n          tokens: [{ tokenId: tokenId, balance: '100', decimals: 6 }],\n        };\n        sandBox.stub(Hbar.prototype, 'getAccountBalance').resolves(data);\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress: rootAddress,\n              walletPassphrase,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              tokenId: invalidTokenId,\n            });\n          },\n          { message: 'Unsupported token: ' + invalidTokenId }\n        );\n      });\n\n      it('should throw error for insufficient balance for tokenId if token balance not exist', async function () {\n        const data = {\n          hbars: '100',\n          tokens: [{ tokenId: 'randomString', balance: '100', decimals: 6 }],\n        };\n        sandBox.stub(Hbar.prototype, 'getAccountBalance').resolves(data);\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress: rootAddress,\n              walletPassphrase,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              tokenId: tokenId,\n            });\n          },\n          { message: 'Insufficient balance to recover token: ' + tokenId + ' for account: ' + rootAddress }\n        );\n      });\n\n      it('should throw error for insufficient balance for tokenId if token balance exist with 0 amount', async function () {\n        const data = {\n          hbars: '100',\n          tokens: [{ tokenId: 'randomString', balance: '0', decimals: 6 }],\n        };\n        sandBox.stub(Hbar.prototype, 'getAccountBalance').resolves(data);\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress: rootAddress,\n              walletPassphrase,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              tokenId: tokenId,\n            });\n          },\n          { message: 'Insufficient balance to recover token: ' + tokenId + ' for account: ' + rootAddress }\n        );\n      });\n\n      it('should throw error for insufficient native balance for token transfer', async function () {\n        const data = {\n          hbars: '0.01',\n          tokens: [{ tokenId: tokenId, balance: '10', decimals: 6 }],\n        };\n        sandBox.stub(Hbar.prototype, 'getAccountBalance').resolves(data);\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress: rootAddress,\n              walletPassphrase,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              tokenId: tokenId,\n            });\n          },\n          { message: 'Insufficient native balance to recover tokens, got native balance: 1000000 fee: ' + defaultFee }\n        );\n      });\n    });\n\n    describe('Unsigned Sweep', function () {\n      const sandBox = Sinon.createSandbox();\n      let getBalanceStub: SinonStub;\n\n      afterEach(function () {\n        sandBox.verifyAndRestore();\n      });\n\n      it('should build unsigned sweep tx', async function () {\n        getBalanceStub = sandBox\n          .stub(Hbar.prototype, 'getAccountBalance')\n          .resolves({ hbars: formatBalanceResponse(balance), tokens: [] });\n        const startTime = (Date.now() / 1000 + 10).toFixed(); // timestamp in seconds, 10 seconds from now\n        const expectedAmount = new BigNumber(balance).minus(defaultFee).toString();\n\n        const recovery = await basecoin.recover({\n          userKey: userPub,\n          backupKey: backupPub,\n          rootAddress,\n          bitgoKey,\n          recoveryDestination: recoveryDestination + '?memoId=' + memo,\n          startTime,\n        });\n\n        getBalanceStub.callCount.should.equal(1);\n\n        recovery.should.not.be.undefined();\n        recovery.should.have.property('txHex');\n        recovery.should.have.property('id', rootAddress + '@' + startTime + '.0');\n        recovery.should.have.property('userKey', userPub);\n        recovery.should.have.property('backupKey', backupPub);\n        recovery.should.have.property('bitgoKey', bitgoKey);\n        recovery.should.have.property('address', rootAddress);\n        recovery.should.have.property('coin', 'thbar');\n        recovery.should.have.property('maxFee', defaultFee.toString());\n        recovery.should.have.property('recipients', [{ address: recoveryDestination, amount: expectedAmount }]);\n        recovery.should.have.property('amount', expectedAmount);\n        recovery.should.have.property('validDuration', defaultValidDuration);\n        recovery.should.have.property('nodeId', defaultNodeId);\n        recovery.should.have.property('memo', memo);\n        recovery.should.have.property('startTime', startTime + '.0');\n        const txBuilder = basecoin.getBuilderFactory().from(recovery.txHex);\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n        txJson.id.should.equal(rootAddress + '@' + startTime + '.0');\n        txJson.amount.should.equal(expectedAmount);\n        txJson.to.should.equal(recoveryDestination);\n        txJson.from.should.equal(rootAddress);\n        txJson.fee.should.equal(defaultFee);\n        txJson.node.should.equal(defaultNodeId);\n        txJson.memo.should.equal(memo);\n        txJson.validDuration.should.equal(defaultValidDuration);\n        txJson.startTime.should.equal(startTime + '.0');\n        txJson.validDuration.should.equal(defaultValidDuration);\n      });\n\n      it('should build unsigned sweep tx for tokens', async function () {\n        const balance = '100';\n        const data = {\n          hbars: '1',\n          tokens: [{ tokenId: tokenId, balance: balance, decimals: 6 }],\n        };\n        getBalanceStub = sandBox.stub(Hbar.prototype, 'getAccountBalance').resolves(data);\n        const startTime = (Date.now() / 1000 + 10).toFixed(); // timestamp in seconds, 10 seconds from now\n        const recovery = await basecoin.recover({\n          userKey: userPub,\n          backupKey: backupPub,\n          rootAddress,\n          bitgoKey,\n          recoveryDestination: recoveryDestination + '?memoId=' + memo,\n          startTime,\n          tokenId: tokenId,\n        });\n\n        getBalanceStub.callCount.should.equal(1);\n\n        recovery.should.not.be.undefined();\n        recovery.should.have.property('txHex');\n        recovery.should.have.property('id', rootAddress + '@' + startTime + '.0');\n        recovery.should.have.property('userKey', userPub);\n        recovery.should.have.property('backupKey', backupPub);\n        recovery.should.have.property('bitgoKey', bitgoKey);\n        recovery.should.have.property('address', rootAddress);\n        recovery.should.have.property('coin', 'thbar');\n        recovery.should.have.property('maxFee', defaultFee.toString());\n        recovery.should.have.property('recipients', [\n          { address: recoveryDestination, amount: balance, tokenName: 'thbar:usdc' },\n        ]);\n        recovery.should.have.property('amount', balance);\n        recovery.should.have.property('validDuration', defaultValidDuration);\n        recovery.should.have.property('nodeId', defaultNodeId);\n        recovery.should.have.property('memo', memo);\n        recovery.should.have.property('startTime', startTime + '.0');\n        const txBuilder = basecoin.getBuilderFactory().from(recovery.txHex);\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n        txJson.id.should.equal(rootAddress + '@' + startTime + '.0');\n        txJson.amount.should.equal(balance);\n        txJson.to.should.equal(recoveryDestination);\n        txJson.from.should.equal(rootAddress);\n        txJson.fee.should.equal(defaultFee);\n        txJson.node.should.equal(defaultNodeId);\n        txJson.memo.should.equal(memo);\n        txJson.validDuration.should.equal(defaultValidDuration);\n        txJson.startTime.should.equal(startTime + '.0');\n        txJson.validDuration.should.equal(defaultValidDuration);\n      });\n\n      it('should throw if startTime is undefined', async function () {\n        const startTime = undefined;\n\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey: userPub,\n              backupKey: backupPub,\n              rootAddress,\n              bitgoKey,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              startTime,\n            });\n          },\n          { message: 'start time is required for unsigned sweep' }\n        );\n      });\n\n      it('should throw for invalid userKey', async function () {\n        const startTime = (Date.now() / 1000 + 10).toFixed();\n        const invalidUserPub = '302a300506032b6570032100randomstring';\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey: invalidUserPub,\n              backupKey: backupPub,\n              bitgoKey,\n              rootAddress,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              startTime,\n            });\n          },\n          { message: 'invalid userKey, got: ' + invalidUserPub }\n        );\n      });\n\n      it('should throw for invalid backupKey', async function () {\n        const invalidBackupPub = '302a300506032b6570032100randomstring';\n        const startTime = (Date.now() / 1000 + 10).toFixed();\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey: userPub,\n              backupKey: invalidBackupPub,\n              bitgoKey,\n              rootAddress,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              startTime,\n            });\n          },\n          { message: 'invalid backupKey, got: ' + invalidBackupPub }\n        );\n      });\n\n      it('should throw if startTime is a valid timestamp', async function () {\n        const startTime = 'asd';\n\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey: userPub,\n              backupKey: backupPub,\n              rootAddress,\n              bitgoKey,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              startTime,\n            });\n          },\n          { message: 'invalid startTime, got: ' + startTime }\n        );\n      });\n\n      it('should throw if startTime is not a future date', async function () {\n        const startTime = (Date.now() / 1000 - 1).toString(); // timestamp in seconds, 1 second ago\n\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey: userPub,\n              backupKey: backupPub,\n              rootAddress,\n              bitgoKey,\n              recoveryDestination: recoveryDestination + '?memoId=' + memo,\n              startTime,\n            });\n          },\n          { message: 'startTime must be a future timestamp, got: ' + startTime }\n        );\n      });\n    });\n\n    describe('Recovery with root keys', function () {\n      const sandBox = Sinon.createSandbox();\n      let getBalanceStub: SinonStub;\n      const walletPassphrase = 'testbtcpassword1999';\n      const userEddsaRootXPrv =\n        '{\"iv\":\"lHOTkiuucR2JWFD1x1gqpQ==\",\"v\":1,\"iter\":10000,\"ks\":128,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"HkFrDVH++d8=\",\"ct\":\"NBtbYdFEK84oH9uxwl/UrhRsW5nGJPnMSpRAo8Blrc7WTSPxGXmVS/EpUYEV03HG06/EnyBR0/Y6bjLQz4gkL6cGJD9hgyKqDvc9RtKHagEbo75oxPr0zP+r1HMUGBW38Ttgor674gBeb1Myew69xcS9KgguNxwz77X6fdeBhrfogLY22vcuLA==\"}';\n      const userEddsaRootPub = 'd9cb9c9c617cfa0b715849516bb054a2b5d78c0e3eeef011176fb8bc0108c531';\n      const backupEddsaRootXprv =\n        '{\"iv\":\"sBoEFBBNoi2YVICPf16/BQ==\",\"v\":1,\"iter\":10000,\"ks\":128,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"HkFrDVH++d8=\",\"ct\":\"GscOqJC+Iq+Lr39plQp5ZCamVlpJHOltGTZ7/UnUunIhFmZWMBLxjEVnMOtPreb0NZ4/SFqO/N3mZvq6JbB7vWRxJuqkBIiVcIRwkSWdW55cboKx2ec3ajg8+uO2pbvNDs26Q+9NtZ4jZnKNqSUXiCmtJXLRHQ32oyD+olKRpIR2NQo2+7kIEw==\"}';\n      const backupEddsaRootPub = 'f163b1b8ee4c3343a97ac1d2470b967e967ac7b4e3731cacf02f28a1434a2f99';\n      const rootAddress = '0.0.3644667';\n      const memoId = '0';\n\n      beforeEach(function () {\n        getBalanceStub = sandBox\n          .stub(Hbar.prototype, 'getAccountBalance')\n          .resolves({ hbars: formatBalanceResponse(balance), tokens: [] });\n      });\n\n      afterEach(function () {\n        sandBox.verifyAndRestore();\n      });\n\n      it('should build and sign non-bitgo recovery tx with root keys', async function () {\n        const expectedAmount = new BigNumber(balance).minus(defaultFee).toString();\n\n        const recovery = await basecoin.recover({\n          userKey: userEddsaRootXPrv,\n          backupKey: backupEddsaRootXprv,\n          rootAddress,\n          walletPassphrase,\n          recoveryDestination: recoveryDestination + '?memoId=' + memoId,\n        });\n\n        getBalanceStub.callCount.should.equal(1);\n\n        recovery.should.not.be.undefined();\n        recovery.should.have.property('id');\n        recovery.should.have.property('tx');\n        recovery.should.have.property('coin', 'thbar');\n        recovery.should.have.property('nodeId', defaultNodeId);\n        getBalanceStub.callCount.should.equal(1);\n        const txBuilder = basecoin.getBuilderFactory().from(recovery.tx);\n        const tx = await txBuilder.build();\n        tx.toBroadcastFormat().should.equal(recovery.tx);\n        const txJson = tx.toJson();\n        txJson.amount.should.equal(expectedAmount);\n        txJson.to.should.equal(recoveryDestination);\n        txJson.from.should.equal(rootAddress);\n        txJson.fee.should.equal(defaultFee);\n        txJson.node.should.equal(defaultNodeId);\n        txJson.memo.should.equal(memoId);\n        txJson.validDuration.should.equal(defaultValidDuration);\n        txJson.should.have.property('startTime');\n        recovery.should.have.property('startTime', txJson.startTime);\n        recovery.should.have.property('id', rootAddress + '@' + txJson.startTime);\n      });\n\n      it('should build unsigned sweep tx', async function () {\n        const startTime = (Date.now() / 1000 + 10).toFixed(); // timestamp in seconds, 10 seconds from now\n        const expectedAmount = new BigNumber(balance).minus(defaultFee).toString();\n\n        const recovery = await basecoin.recover({\n          userKey: userEddsaRootPub,\n          backupKey: backupEddsaRootPub,\n          rootAddress,\n          bitgoKey,\n          recoveryDestination: recoveryDestination + '?memoId=' + memoId,\n          startTime,\n        });\n\n        getBalanceStub.callCount.should.equal(1);\n\n        recovery.should.not.be.undefined();\n        recovery.should.have.property('txHex');\n        recovery.should.have.property('id', rootAddress + '@' + startTime + '.0');\n        recovery.should.have.property('userKey', userEddsaRootPub);\n        recovery.should.have.property('backupKey', backupEddsaRootPub);\n        recovery.should.have.property('bitgoKey', bitgoKey);\n        recovery.should.have.property('address', rootAddress);\n        recovery.should.have.property('coin', 'thbar');\n        recovery.should.have.property('maxFee', defaultFee.toString());\n        recovery.should.have.property('recipients', [{ address: recoveryDestination, amount: expectedAmount }]);\n        recovery.should.have.property('amount', expectedAmount);\n        recovery.should.have.property('validDuration', defaultValidDuration);\n        recovery.should.have.property('nodeId', defaultNodeId);\n        recovery.should.have.property('memo', memoId);\n        recovery.should.have.property('startTime', startTime + '.0');\n        const txBuilder = basecoin.getBuilderFactory().from(recovery.txHex);\n        const tx = await txBuilder.build();\n        const txJson = tx.toJson();\n        txJson.id.should.equal(rootAddress + '@' + startTime + '.0');\n        txJson.amount.should.equal(expectedAmount);\n        txJson.to.should.equal(recoveryDestination);\n        txJson.from.should.equal(rootAddress);\n        txJson.fee.should.equal(defaultFee);\n        txJson.node.should.equal(defaultNodeId);\n        txJson.memo.should.equal(memoId);\n        txJson.validDuration.should.equal(defaultValidDuration);\n        txJson.startTime.should.equal(startTime + '.0');\n        txJson.validDuration.should.equal(defaultValidDuration);\n      });\n    });\n  });\n\n  describe('broadcastTransaction', function () {\n    const sandBox = Sinon.createSandbox();\n\n    afterEach(function () {\n      sandBox.verifyAndRestore();\n    });\n\n    it('should succeed if the startTime and serializedSignedTransaction are valid', async function () {\n      const startTime = (Date.now() / 1000 - 3).toFixed(); // timestamp in seconds, -3 seconds from now so it's valid after 2 seconds\n      const expectedResponse = { txId: '0.0.7668465@' + startTime + '.0', status: 'SUCCESS' };\n      const broadcastStub = sandBox.stub(Hbar.prototype, 'clientBroadcastTransaction').resolves(expectedResponse);\n      const serializedSignedTransaction =\n        '1acc010a640a20592a4fbb7263c59d450e651df96620dc9208ee7c7d9d6f2fdcb91c53f88312611a40105b7d250c81f3705bc0b85168ce3fd00330131bb7701378681c8c2e6a09a91828715e7334f4ef28d20ff09887c6e87c0a5c693e23824c26f3ba161fce0448050a640a20a6905095616c3cfaa1bf61b53de30e938ce4112c3cc4d25393ec6b9bf4dea0631a40bf98c5b89b7a08544edaa1f4c08a0dfa6ec3f78b7e2fd27049283984050f38ccf0303ee57a377cc0a725ffd99d69e9fd914770ab0949ba556d84b3b00cb07e0d22500a130a0608cea8c1ad0612090800100018f185d40312060800100018031880c2d72f220308b40132013472240a220a0f0a090800100018f185d40310d3b0510a0f0a090800100018c484d30310d4b051';\n      const result = await basecoin.broadcastTransaction({ serializedSignedTransaction, startTime });\n      broadcastStub.callCount.should.equal(1);\n      result.should.deepEqual(expectedResponse);\n    });\n\n    it('should throw if the startTime is expired', async function () {\n      const startTime = (Date.now() / 1000 - 2000).toFixed(); // timestamp in seconds, 2000 seconds from now\n      const serializedSignedTransaction =\n        '1acc010a640a20592a4fbb7263c59d450e651df96620dc9208ee7c7d9d6f2fdcb91c53f88312611a40105b7d250c81f3705bc0b85168ce3fd00330131bb7701378681c8c2e6a09a91828715e7334f4ef28d20ff09887c6e87c0a5c693e23824c26f3ba161fce0448050a640a20a6905095616c3cfaa1bf61b53de30e938ce4112c3cc4d25393ec6b9bf4dea0631a40bf98c5b89b7a08544edaa1f4c08a0dfa6ec3f78b7e2fd27049283984050f38ccf0303ee57a377cc0a725ffd99d69e9fd914770ab0949ba556d84b3b00cb07e0d22500a130a0608cea8c1ad0612090800100018f185d40312060800100018031880c2d72f220308b40132013472240a220a0f0a090800100018f185d40310d3b0510a0f0a090800100018c484d30310d4b051';\n      await assert.rejects(\n        async () => {\n          await basecoin.broadcastTransaction({ serializedSignedTransaction, startTime });\n        },\n        (error: any) => {\n          assert.ok(error.message.includes('Failed to broadcast transaction, error: startTime window expired'));\n          return true;\n        }\n      );\n    });\n\n    it('should throw if the serializedSignedTransaction is invalid', async function () {\n      const startTime = (Date.now() / 1000 - 10).toFixed(); // timestamp in seconds, 10 seconds from now\n      const serializedSignedTransaction = 'randomstring';\n      await assert.rejects(async () => {\n        await basecoin.broadcastTransaction({ serializedSignedTransaction, startTime });\n      });\n    });\n\n    it('should throw if the startTime in the tx is invalid', async function () {\n      const expectedResponse =\n        'transaction 0.0.7668465@1706056301.000000000 failed precheck with status INVALID_TRANSACTION_START';\n      sandBox.stub(Hbar.prototype, 'clientBroadcastTransaction').rejects(new Error(expectedResponse));\n      const serializedSignedTransaction =\n        '1acc010a640a20592a4fbb7263c59d450e651df96620dc9208ee7c7d9d6f2fdcb91c53f88312611a40105b7d250c81f3705bc0b85168ce3fd00330131bb7701378681c8c2e6a09a91828715e7334f4ef28d20ff09887c6e87c0a5c693e23824c26f3ba161fce0448050a640a20a6905095616c3cfaa1bf61b53de30e938ce4112c3cc4d25393ec6b9bf4dea0631a40bf98c5b89b7a08544edaa1f4c08a0dfa6ec3f78b7e2fd27049283984050f38ccf0303ee57a377cc0a725ffd99d69e9fd914770ab0949ba556d84b3b00cb07e0d22500a130a0608cea8c1ad0612090800100018f185d40312060800100018031880c2d72f220308b40132013472240a220a0f0a090800100018f185d40310d3b0510a0f0a090800100018c484d30310d4b051';\n\n      await assert.rejects(\n        async () => {\n          await basecoin.broadcastTransaction({ serializedSignedTransaction });\n        },\n        { message: expectedResponse }\n      );\n    });\n  });\n\n  describe('deriveKeyWithSeed', function () {\n    it('should derive key with seed', function () {\n      (() => {\n        basecoin.deriveKeyWithSeed('test');\n      }).should.throw('method deriveKeyWithSeed not supported for eddsa curve');\n    });\n  });\n\n  describe('Generate wallet Root key pair: ', () => {\n    it('should generate key pair', () => {\n      const kp = basecoin.generateRootKeyPair();\n      basecoin.isValidPub(kp.pub).should.equal(true);\n      const keypair = new KeyPair({ prv: kp.prv }).getKeys(true);\n      keypair.should.have.property('prv');\n      keypair.prv?.should.equal(kp.prv.slice(0, 64));\n      keypair.pub.should.equal(kp.pub);\n    });\n\n    it('should generate key pair from seed', () => {\n      const seed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');\n      const kp = basecoin.generateRootKeyPair(seed);\n      basecoin.isValidPub(kp.pub).should.equal(true);\n      kp.pub.should.equal('d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a');\n      kp.prv.should.equal(\n        '9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a'\n      );\n\n      const keypair = new KeyPair({ prv: kp.prv }).getKeys(true);\n      keypair.should.have.property('prv');\n      keypair.prv?.should.equal(kp.prv.slice(0, 64));\n      keypair.pub.should.equal(kp.pub);\n    });\n  });\n\n  describe('AuditKey', () => {\n    const { key } = hbarBackupKey;\n    const walletPassphrase = 'kAm[EFQ6o=SxlcLFDw%,';\n\n    it('should return for valid inputs', () => {\n      basecoin.assertIsValidKey({\n        coinName: 'hbar',\n        encryptedPrv: key,\n        walletPassphrase,\n      });\n    });\n\n    it('should throw error if the walletPassphrase is incorrect', () => {\n      assert.throws(\n        () =>\n          basecoin.assertIsValidKey({\n            coinName: 'hbar',\n            encryptedPrv: key,\n            walletPassphrase: 'foo',\n          }),\n        { message: \"failed to decrypt prv: ccm: tag doesn't match\" }\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            coinName: 'hbar',\n            encryptedPrv: alteredKey,\n            walletPassphrase,\n          }),\n        {\n          message: 'failed to decrypt prv: json decrypt: invalid parameters',\n        }\n      );\n    });\n\n    it('should throw error if the key is not a valid key', () => {\n      const invalidKey = '#@)$#($*@)#($*';\n      const encryptedPrv = encrypt(walletPassphrase, invalidKey);\n      assert.throws(\n        () =>\n          basecoin.assertIsValidKey({\n            coinName: 'hbar',\n            encryptedPrv,\n            walletPassphrase,\n          }),\n        {\n          message: 'Invalid private key: Invalid private key length. Must be a hex and multiple of 2',\n        }\n      );\n    });\n  });\n});\n"]}