@bitgo-beta/sdk-coin-algo 1.3.3-alpha.43 → 1.3.3-alpha.430

package/dist/test/unit/algo.js

@@ -0,0 +1,1223 @@
+"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 src_1 = require("../../src");
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const AlgoResources = __importStar(require("../fixtures/algo"));
+const crypto_1 = require("crypto");
+const statics_1 = require("@bitgo-beta/statics");
+const sinon_1 = __importStar(require("sinon"));
+const assert_1 = __importDefault(require("assert"));
+const algo_1 = require("../../src/algo");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const lib_1 = require("../../src/lib");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const algoBackupKey_1 = require("./fixtures/algoBackupKey");
+const nock_1 = __importDefault(require("nock"));
+describe('ALGO:', function () {
+    let bitgo;
+    let basecoin;
+    const receiver = AlgoResources.accounts.account2;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('talgo', src_1.Talgo.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('talgo');
+    });
+    describe('Should Fail: ', () => {
+        it('Does not have a txHex', async () => {
+            await basecoin
+                .explainTransaction({
+                params: {},
+            })
+                .should.be.rejectedWith('missing explain tx parameters');
+        });
+        it('Does not have a fee', async () => {
+            await basecoin
+                .explainTransaction({
+                params: {
+                    txHex: 'Some Valid Hex',
+                },
+            })
+                .should.be.rejectedWith('missing explain tx parameters');
+        });
+    });
+    describe('Transfer Builder: ', () => {
+        const buildBaseTransferTransaction = ({ destination, amount = 10000, sender, memo = '' }) => {
+            const factory = new src_1.AlgoLib.TransactionBuilderFactory(statics_1.coins.get('algo'));
+            const txBuilder = factory.getTransferBuilder();
+            const lease = new Uint8Array((0, crypto_1.randomBytes)(32));
+            const note = new Uint8Array(Buffer.from(memo, 'utf-8'));
+            txBuilder
+                .sender({ address: sender })
+                .to({ address: destination })
+                .amount(amount)
+                .isFlatFee(true)
+                .fee({
+                fee: '1000',
+            })
+                .firstRound(1)
+                .lastRound(100)
+                .lease(lease)
+                .note(note)
+                .testnet();
+            return txBuilder;
+        };
+        /**
+         * Build an unsigned account-lib single-signature send transaction
+         * @param sender The senders address
+         * @param destination The destination address of the transaction
+         * @param amount The amount to send to the recipient
+         * @param memo Optional note with the transaction
+         */
+        const buildUnsignedTransaction = async function ({ sender, destination, amount = 10000, memo = '' }) {
+            const txBuilder = buildBaseTransferTransaction({ sender, destination, amount, memo });
+            return await txBuilder.build();
+        };
+        /**
+         * Build a signed account-lib single-signature send transaction
+         * @param sender The senders address
+         * @param destination The destination address of the transaction
+         * @param amount The amount to send to the recipient
+         * @param memo Optional note with the transaction
+         */
+        const buildSignedTransaction = async function ({ sender, destination, amount = 10000, memo = '' }) {
+            const txBuilder = buildBaseTransferTransaction({ sender, destination, amount, memo });
+            txBuilder.numberOfSigners(1);
+            txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });
+            return await txBuilder.build();
+        };
+        /**
+         * Build a multi-signed account-lib single-signature send transaction
+         * @param senders The list of senders
+         * @param destination The destination address of the transaction
+         * @param amount The amount to send to the recipient
+         * @param memo Optional note with the transaction
+         */
+        const buildMultiSignedTransaction = async function ({ senders, destination, amount = 10000, memo = '' }) {
+            const txBuilder = buildBaseTransferTransaction({ sender: senders[0], destination, amount, memo });
+            txBuilder.numberOfSigners(2);
+            txBuilder.setSigners(senders);
+            txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });
+            txBuilder.sign({ key: AlgoResources.accounts.account3.prvKey });
+            return await txBuilder.build();
+        };
+        it('should explain an unsigned transfer transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.transfer.unsigned,
+                feeInfo: { fee: '1000' },
+            });
+            explain.outputAmount.should.equal('10000');
+            explain.outputs[0].amount.should.equal('10000');
+            explain.outputs[0].address.should.equal(receiver.address);
+            Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+        });
+        it('should explain a signed transfer transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.transfer.signed,
+                feeInfo: { fee: '1000' },
+            });
+            explain.outputAmount.should.equal('10000');
+            explain.outputs[0].amount.should.equal('10000');
+            explain.outputs[0].address.should.equal(receiver.address);
+            Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+        });
+        it('should explain a multiSig transfer transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.transfer.multiSigned,
+                feeInfo: { fee: '1000' },
+            });
+            explain.outputAmount.should.equal('10000');
+            explain.outputs[0].amount.should.equal('10000');
+            explain.outputs[0].address.should.equal(receiver.address);
+            Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+        });
+        it('should explain a half signed transfer transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                halfSigned: {
+                    txHex: AlgoResources.explainRawTx.transfer.halfSigned,
+                },
+                feeInfo: { fee: '1000' },
+            });
+            explain.outputAmount.should.equal('10000');
+            explain.outputs[0].amount.should.equal('10000');
+            explain.outputs[0].address.should.equal(receiver.address);
+            Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+        });
+        it('should explain an unsigned transaction', async function () {
+            const sender = AlgoResources.accounts.account1.address;
+            const destination = AlgoResources.accounts.account2.address;
+            const amount = 10000;
+            const memo = AlgoResources.explainRawTx.transfer.note;
+            const unsignedTransaction = await buildUnsignedTransaction({
+                sender,
+                destination,
+                amount,
+                memo,
+            });
+            const unsignedHex = Buffer.from(unsignedTransaction.toBroadcastFormat()).toString('hex');
+            const explain = await basecoin.explainTransaction({
+                txHex: unsignedHex,
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.outputs[0].amount.should.equal(amount.toString());
+            explain.outputs[0].address.should.equal(destination);
+        });
+        it('should explain a signed transaction', async function () {
+            const sender = AlgoResources.accounts.account1.address;
+            const destination = AlgoResources.accounts.account2.address;
+            const amount = 10000;
+            const memo = AlgoResources.explainRawTx.transfer.note;
+            const signedTransaction = await buildSignedTransaction({
+                sender,
+                destination,
+                amount,
+                memo,
+            });
+            const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');
+            const explain = await basecoin.explainTransaction({
+                txHex: signedHex,
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.outputs[0].amount.should.equal(amount.toString());
+            explain.outputs[0].address.should.equal(destination);
+        });
+        it('should explain a multiSigned transaction', async function () {
+            const senders = [AlgoResources.accounts.account1.address, AlgoResources.accounts.account3.address];
+            const destination = AlgoResources.accounts.account2.address;
+            const amount = 10000;
+            const memo = AlgoResources.explainRawTx.transfer.note;
+            const signedTransaction = await buildMultiSignedTransaction({
+                senders,
+                destination,
+                amount,
+                memo,
+            });
+            const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');
+            const explain = await basecoin.explainTransaction({
+                txHex: signedHex,
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.outputs[0].amount.should.equal(amount.toString());
+            explain.outputs[0].address.should.equal(destination);
+        });
+    });
+    describe('Asset Transfer Builder: ', () => {
+        const buildBaseAssetTransferTransaction = ({ destination, amount = 1000, tokenId, sender }) => {
+            const factory = new src_1.AlgoLib.TransactionBuilderFactory(statics_1.coins.get('algo'));
+            const txBuilder = factory.getAssetTransferBuilder();
+            const lease = new Uint8Array((0, crypto_1.randomBytes)(32));
+            txBuilder
+                .sender({ address: sender })
+                .isFlatFee(true)
+                .fee({
+                fee: '1000',
+            })
+                .tokenId(tokenId)
+                .firstRound(1)
+                .lastRound(100)
+                .lease(lease)
+                .to({ address: destination })
+                .amount(amount)
+                .testnet();
+            return txBuilder;
+        };
+        /**
+         * Build an unsigned account-lib single-signature asset transfer transaction
+         * @param sender The senders address
+         * @param destination The destination address of the transaction
+         * @param amount The amount to send to the recipient
+         * @param tokenId The assetIndex for the token
+         */
+        const buildUnsignedTransaction = async function ({ sender, destination, amount = 10000, tokenId }) {
+            const txBuilder = buildBaseAssetTransferTransaction({ sender, destination, amount, tokenId });
+            return await txBuilder.build();
+        };
+        /**
+         * Build a signed account-lib single-signature send transaction
+         * @param sender The senders address
+         * @param destination The destination address of the transaction
+         * @param amount The amount to send to the recipient
+         * @param tokenId The assetIndex for the token
+         */
+        const buildSignedTransaction = async function ({ sender, destination, amount = 10000, tokenId }) {
+            const txBuilder = buildBaseAssetTransferTransaction({ sender, destination, amount, tokenId });
+            txBuilder.numberOfSigners(1);
+            txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });
+            return await txBuilder.build();
+        };
+        it('should explain an unsigned asset transfer transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.assetTransfer.unsigned,
+                feeInfo: { fee: '1000' },
+            });
+            explain.outputAmount.should.equal('1000');
+            explain.outputs[0].amount.should.equal('1000');
+            explain.outputs[0].address.should.equal(receiver.address);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+            explain.tokenId.should.equal(1);
+        });
+        it('should explain a signed asset transfer transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.assetTransfer.signed,
+                feeInfo: { fee: '1000' },
+            });
+            explain.outputAmount.should.equal('10000000000000000000');
+            explain.outputs[0].amount.should.equal('10000000000000000000');
+            explain.outputs[0].address.should.equal(receiver.address);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+            explain.tokenId.should.equal(1);
+        });
+        it('should explain an unsigned transaction', async function () {
+            const sender = AlgoResources.accounts.account1.address;
+            const destination = AlgoResources.accounts.account2.address;
+            const amount = 10000;
+            const tokenId = 1;
+            const unsignedTransaction = await buildUnsignedTransaction({
+                sender,
+                destination,
+                amount,
+                tokenId,
+            });
+            const unsignedHex = Buffer.from(unsignedTransaction.toBroadcastFormat()).toString('hex');
+            const explain = await basecoin.explainTransaction({
+                txHex: unsignedHex,
+                feeInfo: { fee: '1000' },
+            });
+            explain.outputs[0].amount.should.equal(amount.toString());
+            explain.outputs[0].address.should.equal(destination);
+            explain.tokenId.should.equal(1);
+        });
+        it('should explain a signed transaction', async function () {
+            const sender = AlgoResources.accounts.account1.address;
+            const destination = AlgoResources.accounts.account2.address;
+            const amount = 10000;
+            const tokenId = 1;
+            const signedTransaction = await buildSignedTransaction({
+                sender,
+                destination,
+                amount,
+                tokenId,
+            });
+            const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');
+            const explain = await basecoin.explainTransaction({
+                txHex: signedHex,
+                feeInfo: { fee: '1000' },
+            });
+            explain.outputs[0].amount.should.equal(amount.toString());
+            explain.outputs[0].address.should.equal(destination);
+            explain.tokenId.should.equal(1);
+        });
+    });
+    describe('Wallet Init Builder: ', () => {
+        const buildBaseKeyRegTransaction = ({ sender, memo = '' }) => {
+            const factory = new src_1.AlgoLib.TransactionBuilderFactory(statics_1.coins.get('algo'));
+            const txBuilder = factory.getWalletInitializationBuilder();
+            const lease = new Uint8Array((0, crypto_1.randomBytes)(32));
+            const note = new Uint8Array(Buffer.from(memo, 'utf-8'));
+            txBuilder
+                .sender({ address: sender.address })
+                .isFlatFee(true)
+                .fee({
+                fee: '1000',
+            })
+                .firstRound(1)
+                .lastRound(100)
+                .lease(lease)
+                .note(note)
+                .voteKey(sender.voteKey)
+                .selectionKey(sender.selectionKey)
+                .voteFirst(1)
+                .voteLast(100)
+                .voteKeyDilution(9)
+                .testnet();
+            return txBuilder;
+        };
+        /**
+         * Build an unsigned account-lib single-signature send transaction
+         * @param sender The senders address
+         * @param memo Optional note with the transaction
+         */
+        const buildUnsignedTransaction = async function ({ sender, memo = '' }) {
+            const txBuilder = buildBaseKeyRegTransaction({ sender, memo });
+            return await txBuilder.build();
+        };
+        /**
+         * Build a signed account-lib single-signature send transaction
+         * @param sender The senders address
+         * @param memo Optional note with the transaction
+         */
+        const buildSignedTransaction = async function ({ sender, memo = '' }) {
+            const txBuilder = buildBaseKeyRegTransaction({ sender, memo });
+            txBuilder.numberOfSigners(1);
+            txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });
+            return await txBuilder.build();
+        };
+        /**
+         * Build a multi-signed account-lib single-signature send transaction
+         * @param senders The list of senders
+         * @param memo Optional note with the transaction
+         */
+        const buildMultiSignedTransaction = async function ({ senders, memo = '' }) {
+            const txBuilder = buildBaseKeyRegTransaction({ sender: senders[0], memo });
+            txBuilder.numberOfSigners(2);
+            txBuilder.setSigners(senders.map(({ address }) => address));
+            txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });
+            txBuilder.sign({ key: AlgoResources.accounts.account3.prvKey });
+            return await txBuilder.build();
+        };
+        it('should explain an unsigned KeyReg transfer transaction hex', async function () {
+            const sender = AlgoResources.accounts.account1;
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.keyreg.unsigned,
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.keyreg.note);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+            explain.voteKey.should.equal(sender.voteKey);
+            explain.selectionKey.should.equal(sender.selectionKey);
+            explain.voteFirst.should.equal(1);
+            explain.voteLast.should.equal(100);
+            explain.voteKeyDilution.should.equal(9);
+        });
+        it('should explain a signed transfer transaction hex', async function () {
+            const sender = AlgoResources.accounts.account1;
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.keyreg.signed,
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.keyreg.note);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+            explain.voteKey.should.equal(sender.voteKey);
+            explain.selectionKey.should.equal(sender.selectionKey);
+            explain.voteFirst.should.equal(1);
+            explain.voteLast.should.equal(100);
+            explain.voteKeyDilution.should.equal(9);
+        });
+        it('should explain a multiSig transfer transaction hex', async function () {
+            const sender = AlgoResources.accounts.account1;
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.keyreg.multiSigned,
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.keyreg.note);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+            explain.voteKey.should.equal(sender.voteKey);
+            explain.selectionKey.should.equal(sender.selectionKey);
+            explain.voteFirst.should.equal(1);
+            explain.voteLast.should.equal(100);
+            explain.voteKeyDilution.should.equal(9);
+        });
+        it('should explain a half signed transfer transaction hex', async function () {
+            const sender = AlgoResources.accounts.account1;
+            const explain = await basecoin.explainTransaction({
+                halfSigned: {
+                    txHex: AlgoResources.explainRawTx.keyreg.halfSigned,
+                },
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.keyreg.note);
+            explain.fee.should.equal(1000);
+            explain.changeAmount.should.equal('0');
+            explain.voteKey.should.equal(sender.voteKey);
+            explain.selectionKey.should.equal(sender.selectionKey);
+            explain.voteFirst.should.equal(1);
+            explain.voteLast.should.equal(100);
+            explain.voteKeyDilution.should.equal(9);
+        });
+        it('should explain an unsigned transaction', async function () {
+            const sender = AlgoResources.accounts.account1;
+            const memo = AlgoResources.explainRawTx.transfer.note;
+            const unsignedTransaction = await buildUnsignedTransaction({
+                sender,
+                memo,
+            });
+            const unsignedHex = Buffer.from(unsignedTransaction.toBroadcastFormat()).toString('hex');
+            const explain = await basecoin.explainTransaction({
+                txHex: unsignedHex,
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.voteKey.should.equal(sender.voteKey);
+            explain.selectionKey.should.equal(sender.selectionKey);
+            explain.voteFirst.should.equal(1);
+            explain.voteLast.should.equal(100);
+            explain.voteKeyDilution.should.equal(9);
+        });
+        it('should explain a signed transaction', async function () {
+            const sender = AlgoResources.accounts.account1;
+            const memo = AlgoResources.explainRawTx.transfer.note;
+            const signedTransaction = await buildSignedTransaction({
+                sender,
+                memo,
+            });
+            const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');
+            const explain = await basecoin.explainTransaction({
+                txHex: signedHex,
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.voteKey.should.equal(sender.voteKey);
+            explain.selectionKey.should.equal(sender.selectionKey);
+            explain.voteFirst.should.equal(1);
+            explain.voteLast.should.equal(100);
+            explain.voteKeyDilution.should.equal(9);
+        });
+        it('should explain a multiSigned transaction', async function () {
+            const senders = [AlgoResources.accounts.account1, AlgoResources.accounts.account3];
+            const memo = AlgoResources.explainRawTx.transfer.note;
+            const signedTransaction = await buildMultiSignedTransaction({
+                senders,
+                memo,
+            });
+            const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');
+            const explain = await basecoin.explainTransaction({
+                txHex: signedHex,
+                feeInfo: { fee: '1000' },
+            });
+            Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);
+            explain.voteKey.should.equal(AlgoResources.accounts.account1.voteKey);
+            explain.selectionKey.should.equal(AlgoResources.accounts.account1.selectionKey);
+            explain.voteFirst.should.equal(1);
+            explain.voteLast.should.equal(100);
+            explain.voteKeyDilution.should.equal(9);
+        });
+    });
+    describe('Sign transaction', () => {
+        it('should sign transaction', async function () {
+            const signed = await basecoin.signTransaction({
+                txPrebuild: {
+                    txHex: AlgoResources.rawTx.transfer.unsigned,
+                    keys: [AlgoResources.accounts.account1.pubKey.toString('hex')],
+                    addressVersion: 1,
+                },
+                prv: AlgoResources.accounts.account1.prvKey,
+            });
+            signed.txHex.should.equal(AlgoResources.rawTx.transfer.signed);
+        });
+        it('should sign transaction with root key', async function () {
+            const keypair = basecoin.generateRootKeyPair(AlgoResources.accounts.account1.secretKey);
+            const signed = await basecoin.signTransaction({
+                txPrebuild: {
+                    txHex: AlgoResources.rawTx.transfer.unsigned,
+                    keys: [keypair.pub],
+                    addressVersion: 1,
+                },
+                prv: keypair.prv,
+            });
+            signed.txHex.should.equal(AlgoResources.rawTx.transfer.signed);
+        });
+        it('should sign half signed transaction', async function () {
+            const signed = await basecoin.signTransaction({
+                txPrebuild: {
+                    halfSigned: {
+                        txHex: AlgoResources.rawTx.transfer.halfSigned,
+                    },
+                    keys: [
+                        AlgoResources.accounts.account1.pubKey.toString('hex'),
+                        AlgoResources.accounts.account3.pubKey.toString('hex'),
+                    ],
+                    addressVersion: 1,
+                },
+                prv: AlgoResources.accounts.account3.prvKey,
+            });
+            signed.txHex.should.equal(AlgoResources.rawTx.transfer.multisig);
+        });
+        it('should sign half signed transaction with root key', async function () {
+            const signed = await basecoin.signTransaction({
+                txPrebuild: {
+                    halfSigned: {
+                        txHex: AlgoResources.rootKeyData.unsignedTx,
+                    },
+                    keys: [
+                        AlgoResources.rootKeyData.userKeyPair.pub,
+                        AlgoResources.rootKeyData.backupPub,
+                        AlgoResources.rootKeyData.bitgoPub,
+                    ],
+                    addressVersion: 1,
+                },
+                prv: AlgoResources.rootKeyData.userKeyPair.prv,
+            });
+            signed.txHex.should.deepEqual(AlgoResources.rootKeyData.halfSignedTx);
+            const factory = new lib_1.TransactionBuilderFactory(statics_1.coins.get('algo'));
+            const tx = await factory.from(signed.txHex).build();
+            const txJson = tx.toJson();
+            txJson.from.should.equal(AlgoResources.rootKeyData.senderAddress);
+        });
+        it('should verify sign params if the key array contains addresses', function () {
+            const keys = [
+                AlgoResources.accounts.account1.address,
+                AlgoResources.accounts.account2.address,
+                AlgoResources.accounts.account3.address,
+            ];
+            const verifiedParams = basecoin.verifySignTransactionParams({
+                txPrebuild: {
+                    txHex: AlgoResources.rawTx.transfer.unsigned,
+                    keys,
+                    addressVersion: 1,
+                },
+                prv: AlgoResources.accounts.account2.secretKey.toString('hex'),
+            });
+            verifiedParams.should.have.properties([
+                'txHex',
+                'addressVersion',
+                'signers',
+                'prv',
+                'isHalfSigned',
+                'numberSigners',
+            ]);
+            const { txHex, signers, isHalfSigned } = verifiedParams;
+            txHex.should.be.equal(AlgoResources.rawTx.transfer.unsigned);
+            signers.should.be.deepEqual(keys);
+            isHalfSigned.should.be.equal(false);
+        });
+        it('should sign half signed transaction if the key array contains addresses', async function () {
+            const signed = await basecoin.signTransaction({
+                txPrebuild: {
+                    halfSigned: {
+                        txHex: AlgoResources.rawTx.transfer.halfSigned,
+                    },
+                    keys: [AlgoResources.accounts.account1.address, AlgoResources.accounts.account3.address],
+                    addressVersion: 1,
+                },
+                prv: AlgoResources.accounts.account3.prvKey,
+            });
+            signed.txHex.should.equal(AlgoResources.rawTx.transfer.multisig);
+        });
+    });
+    describe('Sign message', () => {
+        it('should sign message', async function () {
+            const signed = await basecoin.signMessage({ prv: AlgoResources.accounts.account1.prvKey }, AlgoResources.message.unsigned);
+            signed.toString('hex').should.equal(AlgoResources.message.signed);
+        });
+    });
+    describe('Generate wallet key pair: ', () => {
+        it('should generate key pair', () => {
+            const kp = basecoin.generateKeyPair();
+            basecoin.isValidPub(kp.pub).should.equal(true);
+            basecoin.isValidPrv(kp.prv).should.equal(true);
+        });
+        it('should generate key pair from seed', () => {
+            const seed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');
+            const kp = basecoin.generateKeyPair(seed);
+            basecoin.isValidPub(kp.pub).should.equal(true);
+            basecoin.isValidPrv(kp.prv).should.equal(true);
+        });
+    });
+    describe('Generate wallet Root key pair: ', () => {
+        it('should generate key pair', () => {
+            const kp = basecoin.generateRootKeyPair();
+            basecoin.isValidPub(kp.pub).should.equal(true);
+            basecoin.isValidPrv(kp.prv).should.equal(true);
+        });
+        it('should generate key pair from seed', () => {
+            const seed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');
+            const kp = basecoin.generateRootKeyPair(seed);
+            basecoin.isValidPub(kp.pub).should.equal(true);
+            kp.pub.should.equal('d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a');
+            basecoin.isValidPrv(kp.prv).should.equal(true);
+            kp.prv.should.equal('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a');
+        });
+    });
+    describe('Enable, disable and transfer Token ', () => {
+        it('should explain an enable token transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.enableToken,
+                feeInfo: { fee: '1000' },
+            });
+            explain.operations.length.should.equals(1);
+            explain.operations[0].type.should.equals('enableToken');
+            explain.operations[0].coin.should.equals('talgo:USON-16026728');
+        });
+        it('should explain an disable token transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.disableToken,
+                feeInfo: { fee: '1000' },
+            });
+            explain.operations.length.should.equals(1);
+            explain.operations[0].type.should.equals('disableToken');
+            explain.operations[0].coin.should.equals('talgo:USON-16026728');
+        });
+        it('should explain an transfer token transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.assetTransfer.signed,
+                feeInfo: { fee: '1000' },
+            });
+            explain.operations.length.should.equals(1);
+            explain.operations[0].type.should.equals('transferToken');
+            explain.operations[0].coin.should.equals('AlgoToken unknown');
+        });
+        it('should explain an enable USDT token transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.enableTokenUSDT,
+                feeInfo: { fee: '1000' },
+            });
+            explain.operations.length.should.equals(1);
+            explain.operations[0].type.should.equals('enableToken');
+            explain.operations[0].coin.should.equals('talgo:USDt-180447');
+        });
+        it('should explain an enable USDC token transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.enableTokenUSDC,
+                feeInfo: { fee: '1000' },
+            });
+            explain.operations.length.should.equals(1);
+            explain.operations[0].type.should.equals('enableToken');
+            explain.operations[0].coin.should.equals('talgo:USDC-10458941');
+        });
+        it('should explain an disable USDC token transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.disableTokenUSDC,
+                feeInfo: { fee: '1000' },
+            });
+            explain.operations.length.should.equals(1);
+            explain.operations[0].type.should.equals('disableToken');
+            explain.operations[0].coin.should.equals('talgo:USDC-10458941');
+        });
+        it('should explain an transfer USDC token transaction hex', async function () {
+            const explain = await basecoin.explainTransaction({
+                txHex: AlgoResources.explainRawTx.USDCAssetTransfer.signed,
+                feeInfo: { fee: '1000' },
+            });
+            explain.operations.length.should.equals(1);
+            explain.operations[0].type.should.equals('transferToken');
+            explain.operations[0].coin.should.equals('talgo:USDC-10458941');
+        });
+    });
+    describe('deriveKeyWithSeed', function () {
+        it('should derive key with seed', function () {
+            (() => {
+                basecoin.deriveKeyWithSeed('test');
+            }).should.throw('method deriveKeyWithSeed not supported for eddsa curve');
+        });
+    });
+    describe('Recovery', function () {
+        const fee = 1000;
+        const userKey = '{"iv":"ZJg0a0+zT+684MUl44Lm4A==","v":1,"iter":10000,"ks":128,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"abQy0OL2468=","ct":"LNlSlTJED8jSwHCmUflzqFtRPL+PojzOgfd5mD2nmLVdAoyKCWHvAieKt7lJ7zg417CUi6Qj77/s3lbqmxVsfEsk"}';
+        const userPub = 'S4D7DDRAHWZIB2RCZICSRODFCNQXGANHGA7VCWBK5I37SQT6KVHXQNKMTE';
+        const backupKey = '{"iv":"mZY8XTvHxX8BPc1rdGQQww==","v":1,"iter":10000,"ks":128,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"abQy0OL2468=","ct":"UQXo0EaPXb6TIZDYYhKYS9d/fRMNT6ptpl9BgJw3AVooSbO4nppWnTRYlQO7hpON4XY85hYDu/7hy91IX1z1bDDq"}';
+        const backupPub = '6FVGZUZOHZSXTTBRLWZDXGYSWVVYNN4ZESIEMZEMIBJCUBHC5C77OIE5RQ';
+        const rootAddress = 'FWLNDL7UXCSOPOQXA5VU2DMANZAYCCMBY377HKTGGMZ4GEPEJBFARDOGBA';
+        const walletPassphrase = 'Testing@43210!';
+        const recoveryDestination = 'GB3YETD5TSTBAIYGYHVWU3O3I7XGOB44HOZA5MOEF5M23CLLZKRQLEVAOA';
+        const bitgoPub = 'FJSWLLPRBXEGMWZY5BXA6673YKIK7JOURVCQEOWXC5TQPCXCOK3VHOO2VQ';
+        const nativeBalance = 10000000; // 10 ALGO
+        const MIN_ACCOUNT_BALANCE = 100000; // 1 AGLO
+        const nodeParams = {
+            token: '2810c2d168e8417c5f111d38d68327b8cfe2d0ddc02986490c22f8ddf4128bcd',
+            baseServer: 'http://localhost/',
+            port: 8443,
+        };
+        describe('Non-BitGo', async function () {
+            const sandBox = sinon_1.default.createSandbox();
+            const expectedAmount = new bignumber_js_1.default(nativeBalance).minus(fee).minus(MIN_ACCOUNT_BALANCE).toString();
+            afterEach(function () {
+                sandBox.verifyAndRestore();
+            });
+            it('should build and sign the recovery tx', async function () {
+                const getBalanceStub = sandBox.stub(algo_1.Algo.prototype, 'getAccountBalance').resolves(nativeBalance);
+                const recovery = await basecoin.recover({
+                    userKey,
+                    backupKey,
+                    rootAddress,
+                    walletPassphrase,
+                    fee,
+                    bitgoKey: bitgoPub,
+                    recoveryDestination: recoveryDestination,
+                    firstRound: 5002596,
+                    nodeParams,
+                });
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('id');
+                recovery.should.have.property('tx');
+                recovery.should.have.property('fee');
+                recovery.should.have.property('coin', 'talgo');
+                recovery.should.have.property('firstRound');
+                recovery.should.have.property('lastRound');
+                getBalanceStub.callCount.should.equal(1);
+                const factory = new src_1.AlgoLib.TransactionBuilderFactory(statics_1.coins.get('algo'));
+                const txBuilder = factory.from(recovery.tx);
+                const tx = await txBuilder.build();
+                const txBroadcastFormat = Buffer.from(tx.toBroadcastFormat()).toString('base64');
+                txBroadcastFormat.should.deepEqual(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(fee);
+            });
+            it('should throw for invalid rootAddress', async function () {
+                const invalidRootAddress = 'randomstring';
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress: invalidRootAddress,
+                        walletPassphrase,
+                        fee,
+                        recoveryDestination: recoveryDestination,
+                        firstRound: 5002596,
+                        nodeParams,
+                    });
+                }, { 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,
+                        fee,
+                        recoveryDestination: invalidRecoveryDestination,
+                        firstRound: 5002596,
+                        nodeParams,
+                    });
+                }, { message: 'invalid recoveryDestination, got: ' + invalidRecoveryDestination });
+            });
+            it('should throw if there is no enough balance to recover', async function () {
+                const getBalanceStub = sandBox.stub(algo_1.Algo.prototype, 'getAccountBalance').resolves(100500);
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress,
+                        fee,
+                        walletPassphrase,
+                        bitgoKey: bitgoPub,
+                        recoveryDestination,
+                        firstRound: 5003596,
+                        nodeParams,
+                    });
+                }, { message: 'Insufficient balance to recover, got balance: 100500 fee: 1000 min account balance: 100000' });
+                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,
+                        fee,
+                        recoveryDestination,
+                        firstRound: 5003596,
+                        nodeParams,
+                    });
+                }, { 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,
+                        bitgoKey: bitgoPub,
+                        walletPassphrase: 'wrongpassword',
+                        fee,
+                        recoveryDestination,
+                        firstRound: 5003596,
+                        nodeParams,
+                    });
+                }, {
+                    message: "unable to decrypt userKey or backupKey with the walletPassphrase provided, got error: password error - ccm: tag doesn't match",
+                });
+            });
+            it('should throw if bitgo key is not provided', async function () {
+                await assert_1.default.rejects(async () => {
+                    await basecoin.recover({
+                        userKey,
+                        backupKey,
+                        rootAddress,
+                        walletPassphrase,
+                        fee,
+                        recoveryDestination,
+                        firstRound: 5003596,
+                        nodeParams,
+                    });
+                }, {
+                    message: 'bitgo public key from the keyCard is required for non-bitgo recovery',
+                });
+            });
+            it('should be able to pass a utf-8 encoded note', async function () {
+                const note = 'Non-BitGo Recovery Sweep Tx';
+                sandBox.stub(algo_1.Algo.prototype, 'getAccountBalance').resolves(nativeBalance);
+                const recovery = await basecoin.recover({
+                    userKey,
+                    backupKey,
+                    rootAddress,
+                    walletPassphrase,
+                    fee,
+                    bitgoKey: bitgoPub,
+                    recoveryDestination: recoveryDestination,
+                    firstRound: 5002596,
+                    nodeParams,
+                    note,
+                });
+                recovery.should.not.be.undefined();
+                recovery.note.should.be.equal(note);
+            });
+        });
+        describe('Unsigned Sweep', function () {
+            const sandBox = sinon_1.default.createSandbox();
+            const expectedAmount = new bignumber_js_1.default(nativeBalance).minus(fee).minus(MIN_ACCOUNT_BALANCE).toString();
+            let getBalanceStub;
+            beforeEach(function () {
+                getBalanceStub = sandBox.stub(algo_1.Algo.prototype, 'getAccountBalance').resolves(nativeBalance);
+            });
+            afterEach(function () {
+                sandBox.verifyAndRestore();
+            });
+            it('should build unsigned sweep tx', async function () {
+                const recovery = await basecoin.recover({
+                    userKey: userPub,
+                    backupKey: backupPub,
+                    bitgoKey: bitgoPub,
+                    rootAddress,
+                    walletPassphrase,
+                    fee,
+                    recoveryDestination,
+                    firstRound: 5003596,
+                    nodeParams,
+                });
+                getBalanceStub.callCount.should.equal(1);
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('txHex');
+                recovery.should.have.property('type');
+                recovery.should.have.property('amount');
+                recovery.should.have.property('feeInfo');
+                recovery.should.have.property('coin', 'talgo');
+                recovery.firstRound.should.not.be.undefined();
+                recovery.lastRound.should.not.be.undefined();
+                recovery.should.have.property('keys');
+                recovery.keys.should.deepEqual([userPub, backupPub, bitgoPub]);
+                recovery.addressVersion.should.equal(1);
+                getBalanceStub.callCount.should.equal(1);
+                const factory = new src_1.AlgoLib.TransactionBuilderFactory(statics_1.coins.get('algo'));
+                const txBuilder = factory.from(recovery.txHex);
+                const tx = await txBuilder.build();
+                Buffer.from(tx.toBroadcastFormat()).toString('hex').should.deepEqual(recovery.txHex);
+                const txJson = tx.toJson();
+                txJson.amount.should.equal(expectedAmount);
+                txJson.to.should.equal(recoveryDestination);
+                txJson.from.should.equal(rootAddress);
+                txJson.fee.should.equal(fee);
+            });
+        });
+        describe('Recovery with root keys', function () {
+            const sandBox = sinon_1.default.createSandbox();
+            let userKp;
+            let backupKp;
+            let rootAddress;
+            let encryptedUserPrv;
+            let encryptedBackupPrv;
+            const expectedAmount = new bignumber_js_1.default(nativeBalance).minus(fee).minus(MIN_ACCOUNT_BALANCE).toString();
+            let getBalanceStub;
+            beforeEach(function () {
+                const userSeed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');
+                userKp = basecoin.generateRootKeyPair(userSeed);
+                encryptedUserPrv = bitgo.encrypt({
+                    input: userKp.prv,
+                    password: walletPassphrase,
+                });
+                (0, assert_1.default)(userKp.pub);
+                const backupSeed = Buffer.from('6d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');
+                backupKp = basecoin.generateRootKeyPair(backupSeed);
+                encryptedBackupPrv = bitgo.encrypt({
+                    input: backupKp.prv,
+                    password: walletPassphrase,
+                });
+                const bitgoPub = 'FJSWLLPRBXEGMWZY5BXA6673YKIK7JOURVCQEOWXC5TQPCXCOK3VHOO2VQ';
+                const userAddress = src_1.AlgoLib.algoUtils.privateKeyToAlgoAddress(userKp.prv);
+                const backupAddress = src_1.AlgoLib.algoUtils.privateKeyToAlgoAddress(backupKp.prv);
+                rootAddress = src_1.AlgoLib.algoUtils.multisigAddress(1, 2, [userAddress, backupAddress, bitgoPub]);
+            });
+            afterEach(function () {
+                sandBox.verifyAndRestore();
+            });
+            it('should build and sign non-bitgo recovery tx with root keys', async function () {
+                getBalanceStub = sandBox.stub(algo_1.Algo.prototype, 'getAccountBalance').resolves(nativeBalance);
+                const recovery = await basecoin.recover({
+                    userKey: encryptedUserPrv,
+                    backupKey: encryptedBackupPrv,
+                    rootAddress,
+                    walletPassphrase,
+                    fee,
+                    bitgoKey: bitgoPub,
+                    recoveryDestination: recoveryDestination,
+                    firstRound: 5002596,
+                    nodeParams,
+                });
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('id');
+                recovery.should.have.property('tx');
+                recovery.should.have.property('fee');
+                recovery.should.have.property('coin', 'talgo');
+                recovery.should.have.property('firstRound');
+                recovery.should.have.property('lastRound');
+                getBalanceStub.callCount.should.equal(1);
+                const factory = new src_1.AlgoLib.TransactionBuilderFactory(statics_1.coins.get('algo'));
+                const txBuilder = factory.from(recovery.tx);
+                const tx = await txBuilder.build();
+                const txBroadcastFormat = Buffer.from(tx.toBroadcastFormat()).toString('base64');
+                txBroadcastFormat.should.deepEqual(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(fee);
+            });
+            it('should build unsigned sweep tx', async function () {
+                getBalanceStub = sandBox.stub(algo_1.Algo.prototype, 'getAccountBalance').resolves(nativeBalance);
+                const recovery = await basecoin.recover({
+                    userKey: userKp.pub,
+                    backupKey: backupKp.pub,
+                    bitgoKey: bitgoPub,
+                    rootAddress,
+                    walletPassphrase,
+                    fee,
+                    recoveryDestination,
+                    firstRound: 5003596,
+                    nodeParams,
+                });
+                getBalanceStub.callCount.should.equal(1);
+                recovery.should.not.be.undefined();
+                recovery.should.have.property('txHex');
+                recovery.should.have.property('type');
+                recovery.should.have.property('amount');
+                recovery.should.have.property('feeInfo');
+                recovery.should.have.property('coin', 'talgo');
+                recovery.firstRound.should.not.be.undefined();
+                recovery.lastRound.should.not.be.undefined();
+                recovery.should.have.property('keys');
+                recovery.keys.should.deepEqual([userKp.pub, backupKp.pub, bitgoPub]);
+                recovery.addressVersion.should.equal(1);
+                getBalanceStub.callCount.should.equal(1);
+                const factory = new src_1.AlgoLib.TransactionBuilderFactory(statics_1.coins.get('algo'));
+                const txBuilder = factory.from(recovery.txHex);
+                const tx = await txBuilder.build();
+                Buffer.from(tx.toBroadcastFormat()).toString('hex').should.deepEqual(recovery.txHex);
+                const txJson = tx.toJson();
+                txJson.amount.should.equal(expectedAmount);
+                txJson.to.should.equal(recoveryDestination);
+                txJson.from.should.equal(rootAddress);
+                txJson.fee.should.equal(fee);
+            });
+        });
+    });
+    describe('AuditKey', () => {
+        const { key } = algoBackupKey_1.algoBackupKey;
+        const walletPassphrase = 'ZQ8MhxT84m4P';
+        it('should return for valid inputs', () => {
+            basecoin.assertIsValidKey({
+                encryptedPrv: key,
+                walletPassphrase,
+            });
+        });
+        it('should throw error if the walletPassphrase is incorrect', () => {
+            assert_1.default.throws(() => {
+                basecoin.assertIsValidKey({
+                    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({
+                    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({
+                    encryptedPrv,
+                    walletPassphrase,
+                });
+            }, { message: 'Invalid private key: Invalid base32 characters' });
+        });
+    });
+    describe('blind signing token enablement protection', () => {
+        let wallet;
+        const bgUrl = sdk_core_1.common.Environments['mock'].uri;
+        before(() => {
+            bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+            bitgo.safeRegister('talgo', src_1.Talgo.createInstance);
+            bitgo.initializeTestVars();
+            basecoin = bitgo.coin('talgo');
+            wallet = new sdk_core_1.Wallet(bitgo, basecoin, {
+                id: '123',
+                coin: 'talgo',
+                keys: ['1', '2', '3'],
+                coinSpecific: {
+                    rootAddress: '123',
+                },
+                type: 'hot',
+            });
+        });
+        it('should verify a valid token enablement transaction', async function () {
+            const verifyTransactionStub = (0, sinon_1.spy)(basecoin, 'verifyTransaction');
+            (0, nock_1.default)(bgUrl)
+                .post(`/api/v2/talgo/wallet/${wallet.id()}/tx/build`)
+                .reply(200, {
+                txHex: 'iaRhcmN2xCBfnMgYtbyG4RL1DspYhxQeyn9QrJ+s2ZcDTcxK+yOH+KNmZWXNA+iiZnbOA2tlJKNnZW6sdGVzdG5ldC12MS4womdoxCBIY7UYpLPITsgQ8i1PEIHLD3HwWaesIN7GL39w5Qk6IqJsds4Da2kMo3NuZMQgX5zIGLW8huES9Q7KWIcUHsp/UKyfrNmXA03MSvsjh/ikdHlwZaVheGZlcqR4YWlkzgmpOkY=',
+                txHash: 'ARYMOXMKZWM372JBFBTADZNJZU7S5HK44NZDZLVX5UR5UPIWT7FA',
+                txInfo: {
+                    id: 'ARYMOXMKZWM372JBFBTADZNJZU7S5HK44NZDZLVX5UR5UPIWT7FA',
+                    type: 'axfer',
+                    from: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',
+                    fee: 1000,
+                    firstRound: 57369892,
+                    lastRound: 57370892,
+                    note: {},
+                    tokenId: 162085446,
+                    genesisID: 'testnet-v1.0',
+                    genesisHash: 'SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=',
+                    to: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',
+                    amount: '0',
+                    txType: 'enableToken',
+                    tokenName: 'TALGO',
+                },
+                feeInfo: {
+                    size: 251,
+                    fee: 1000,
+                    feeRate: 4,
+                    feeString: '1000',
+                },
+                keys: [
+                    '42MIYL2KBISV6WJRALTTSXHBEGLNF7MMQ74FGSYUCT5YP3V2KENJGRFVVQ',
+                    'MAGXZTDFW5QEXUKOUDIGHTXOKDW7TNQEDLWPBEZEL3VFU3YAA2PGYRS65M',
+                    'TMEJTI7XNCACDG3BTODINW6CMR6ARYIKTCFPA2GMIXL4X5Q4BCE6VHMWAM',
+                ],
+                addressVersion: 1,
+                coin: 'talgo',
+            });
+            const validatePwdStub = (0, sinon_1.stub)(wallet, 'getKeychainsAndValidatePassphrase').resolves([]);
+            const signTxStub = (0, sinon_1.stub)(wallet, 'signTransaction').resolves({});
+            await wallet.sendTokenEnablements({
+                verification: { verifyTokenEnablement: true },
+                enableTokens: [
+                    {
+                        name: 'talgo:JPT-162085446',
+                        address: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',
+                    },
+                ],
+            });
+            verifyTransactionStub.called.should.be.true();
+            verifyTransactionStub.restore();
+            validatePwdStub.restore();
+            signTxStub.restore();
+        });
+        it('should throw error when invalid token enablement transaction is returned', async () => {
+            const verifyTransactionStub = (0, sinon_1.spy)(basecoin, 'verifyTransaction');
+            (0, nock_1.default)(bgUrl)
+                .post(`/api/v2/talgo/wallet/${wallet.id()}/tx/build`)
+                .reply(200, {
+                txHex: 'iaRhcmN2xCBfnMgYtbyG4RL1DspYhxQeyn9QrJ+s2ZcDTcxK+yOH+KNmZWXNA+iiZnbOA2tpeqNnZW6sdGVzdG5ldC12MS4womdoxCBIY7UYpLPITsgQ8i1PEIHLD3HwWaesIN7GL39w5Qk6IqJsds4Da21io3NuZMQgX5zIGLW8huES9Q7KWIcUHsp/UKyfrNmXA03MSvsjh/ikdHlwZaVheGZlcqR4YWlkzgACwN8=',
+                txHash: 'YPQGYNBOCPXMBFTBZH2AQGCDZ3C2762T6EYQY46F7LRG2URX6DLA',
+                txInfo: {
+                    id: 'YPQGYNBOCPXMBFTBZH2AQGCDZ3C2762T6EYQY46F7LRG2URX6DLA',
+                    type: 'axfer',
+                    from: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',
+                    fee: 1000,
+                    firstRound: 57371002,
+                    lastRound: 57372002,
+                    note: {},
+                    tokenId: 180447,
+                    genesisID: 'testnet-v1.0',
+                    genesisHash: 'SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=',
+                    to: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',
+                    amount: '0',
+                    txType: 'enableToken',
+                    tokenName: 'TALGO',
+                },
+                feeInfo: {
+                    size: 251,
+                    fee: 1000,
+                    feeRate: 4,
+                    feeString: '1000',
+                },
+                keys: [
+                    '42MIYL2KBISV6WJRALTTSXHBEGLNF7MMQ74FGSYUCT5YP3V2KENJGRFVVQ',
+                    'MAGXZTDFW5QEXUKOUDIGHTXOKDW7TNQEDLWPBEZEL3VFU3YAA2PGYRS65M',
+                    'TMEJTI7XNCACDG3BTODINW6CMR6ARYIKTCFPA2GMIXL4X5Q4BCE6VHMWAM',
+                ],
+                addressVersion: 1,
+                coin: 'talgo',
+            });
+            (0, sinon_1.stub)(wallet, 'getKeychainsAndValidatePassphrase').resolves([]);
+            (0, sinon_1.stub)(wallet, 'signTransaction').resolves({});
+            const { success, failure } = await wallet.sendTokenEnablements({
+                verification: { verifyTokenEnablement: true },
+                enableTokens: [
+                    {
+                        name: 'talgo:JPT-162085446',
+                        address: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',
+                    },
+                ],
+            });
+            verifyTransactionStub.called.should.be.true();
+            success.length.should.equal(0);
+            failure.length.should.equal(1);
+            failure[0].message.should.equal('Token enablement verification failed: expected token ID 162085446 but transaction has token ID 180447');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"algo.js","sourceRoot":"","sources":["../../../test/unit/algo.ts"],"names":[],"mappings":"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","sourcesContent":["import { AlgoLib, Talgo } from '../../src';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI, encrypt } from '@bitgo-beta/sdk-api';\nimport * as AlgoResources from '../fixtures/algo';\nimport { randomBytes } from 'crypto';\nimport { coins } from '@bitgo-beta/statics';\nimport Sinon, { SinonStub, spy, stub } from 'sinon';\nimport assert from 'assert';\nimport { Algo } from '../../src/algo';\nimport BigNumber from 'bignumber.js';\nimport { TransactionBuilderFactory } from '../../src/lib';\nimport { common, KeyPair, Wallet } from '@bitgo-beta/sdk-core';\nimport { algoBackupKey } from './fixtures/algoBackupKey';\nimport nock from 'nock';\n\ndescribe('ALGO:', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin;\n  const receiver = AlgoResources.accounts.account2;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('talgo', Talgo.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('talgo');\n  });\n\n  describe('Should Fail: ', () => {\n    it('Does not have a txHex', async () => {\n      await basecoin\n        .explainTransaction({\n          params: {},\n        })\n        .should.be.rejectedWith('missing explain tx parameters');\n    });\n\n    it('Does not have a fee', async () => {\n      await basecoin\n        .explainTransaction({\n          params: {\n            txHex: 'Some Valid Hex',\n          },\n        })\n        .should.be.rejectedWith('missing explain tx parameters');\n    });\n  });\n\n  describe('Transfer Builder: ', () => {\n    const buildBaseTransferTransaction = ({ destination, amount = 10000, sender, memo = '' }) => {\n      const factory = new AlgoLib.TransactionBuilderFactory(coins.get('algo'));\n      const txBuilder = factory.getTransferBuilder();\n      const lease = new Uint8Array(randomBytes(32));\n      const note = new Uint8Array(Buffer.from(memo, 'utf-8'));\n      txBuilder\n        .sender({ address: sender })\n        .to({ address: destination })\n        .amount(amount)\n        .isFlatFee(true)\n        .fee({\n          fee: '1000',\n        })\n        .firstRound(1)\n        .lastRound(100)\n        .lease(lease)\n        .note(note)\n        .testnet();\n      return txBuilder;\n    };\n\n    /**\n     * Build an unsigned account-lib single-signature send transaction\n     * @param sender The senders address\n     * @param destination The destination address of the transaction\n     * @param amount The amount to send to the recipient\n     * @param memo Optional note with the transaction\n     */\n    const buildUnsignedTransaction = async function ({ sender, destination, amount = 10000, memo = '' }) {\n      const txBuilder = buildBaseTransferTransaction({ sender, destination, amount, memo });\n      return await txBuilder.build();\n    };\n\n    /**\n     * Build a signed account-lib single-signature send transaction\n     * @param sender The senders address\n     * @param destination The destination address of the transaction\n     * @param amount The amount to send to the recipient\n     * @param memo Optional note with the transaction\n     */\n    const buildSignedTransaction = async function ({ sender, destination, amount = 10000, memo = '' }) {\n      const txBuilder = buildBaseTransferTransaction({ sender, destination, amount, memo });\n      txBuilder.numberOfSigners(1);\n      txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });\n      return await txBuilder.build();\n    };\n\n    /**\n     * Build a multi-signed account-lib single-signature send transaction\n     * @param senders The list of senders\n     * @param destination The destination address of the transaction\n     * @param amount The amount to send to the recipient\n     * @param memo Optional note with the transaction\n     */\n    const buildMultiSignedTransaction = async function ({ senders, destination, amount = 10000, memo = '' }) {\n      const txBuilder = buildBaseTransferTransaction({ sender: senders[0], destination, amount, memo });\n      txBuilder.numberOfSigners(2);\n      txBuilder.setSigners(senders);\n      txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });\n      txBuilder.sign({ key: AlgoResources.accounts.account3.prvKey });\n      return await txBuilder.build();\n    };\n\n    it('should explain an unsigned transfer transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.transfer.unsigned,\n        feeInfo: { fee: '1000' },\n      });\n      explain.outputAmount.should.equal('10000');\n      explain.outputs[0].amount.should.equal('10000');\n      explain.outputs[0].address.should.equal(receiver.address);\n      Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n    });\n\n    it('should explain a signed transfer transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.transfer.signed,\n        feeInfo: { fee: '1000' },\n      });\n      explain.outputAmount.should.equal('10000');\n      explain.outputs[0].amount.should.equal('10000');\n      explain.outputs[0].address.should.equal(receiver.address);\n      Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n    });\n\n    it('should explain a multiSig transfer transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.transfer.multiSigned,\n        feeInfo: { fee: '1000' },\n      });\n      explain.outputAmount.should.equal('10000');\n      explain.outputs[0].amount.should.equal('10000');\n      explain.outputs[0].address.should.equal(receiver.address);\n      Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n    });\n\n    it('should explain a half signed transfer transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        halfSigned: {\n          txHex: AlgoResources.explainRawTx.transfer.halfSigned,\n        },\n        feeInfo: { fee: '1000' },\n      });\n      explain.outputAmount.should.equal('10000');\n      explain.outputs[0].amount.should.equal('10000');\n      explain.outputs[0].address.should.equal(receiver.address);\n      Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n    });\n\n    it('should explain an unsigned transaction', async function () {\n      const sender = AlgoResources.accounts.account1.address;\n      const destination = AlgoResources.accounts.account2.address;\n      const amount = 10000;\n      const memo = AlgoResources.explainRawTx.transfer.note;\n      const unsignedTransaction = await buildUnsignedTransaction({\n        sender,\n        destination,\n        amount,\n        memo,\n      });\n      const unsignedHex = Buffer.from(unsignedTransaction.toBroadcastFormat()).toString('hex');\n      const explain = await basecoin.explainTransaction({\n        txHex: unsignedHex,\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.outputs[0].amount.should.equal(amount.toString());\n      explain.outputs[0].address.should.equal(destination);\n    });\n\n    it('should explain a signed transaction', async function () {\n      const sender = AlgoResources.accounts.account1.address;\n      const destination = AlgoResources.accounts.account2.address;\n      const amount = 10000;\n      const memo = AlgoResources.explainRawTx.transfer.note;\n      const signedTransaction = await buildSignedTransaction({\n        sender,\n        destination,\n        amount,\n        memo,\n      });\n      const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');\n      const explain = await basecoin.explainTransaction({\n        txHex: signedHex,\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.outputs[0].amount.should.equal(amount.toString());\n      explain.outputs[0].address.should.equal(destination);\n    });\n\n    it('should explain a multiSigned transaction', async function () {\n      const senders = [AlgoResources.accounts.account1.address, AlgoResources.accounts.account3.address];\n      const destination = AlgoResources.accounts.account2.address;\n      const amount = 10000;\n      const memo = AlgoResources.explainRawTx.transfer.note;\n      const signedTransaction = await buildMultiSignedTransaction({\n        senders,\n        destination,\n        amount,\n        memo,\n      });\n      const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');\n      const explain = await basecoin.explainTransaction({\n        txHex: signedHex,\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.outputs[0].memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.outputs[0].amount.should.equal(amount.toString());\n      explain.outputs[0].address.should.equal(destination);\n    });\n  });\n\n  describe('Asset Transfer Builder: ', () => {\n    const buildBaseAssetTransferTransaction = ({ destination, amount = 1000, tokenId, sender }) => {\n      const factory = new AlgoLib.TransactionBuilderFactory(coins.get('algo'));\n      const txBuilder = factory.getAssetTransferBuilder();\n      const lease = new Uint8Array(randomBytes(32));\n      txBuilder\n        .sender({ address: sender })\n        .isFlatFee(true)\n        .fee({\n          fee: '1000',\n        })\n        .tokenId(tokenId)\n        .firstRound(1)\n        .lastRound(100)\n        .lease(lease)\n        .to({ address: destination })\n        .amount(amount)\n        .testnet();\n      return txBuilder;\n    };\n\n    /**\n     * Build an unsigned account-lib single-signature asset transfer transaction\n     * @param sender The senders address\n     * @param destination The destination address of the transaction\n     * @param amount The amount to send to the recipient\n     * @param tokenId The assetIndex for the token\n     */\n    const buildUnsignedTransaction = async function ({ sender, destination, amount = 10000, tokenId }) {\n      const txBuilder = buildBaseAssetTransferTransaction({ sender, destination, amount, tokenId });\n      return await txBuilder.build();\n    };\n\n    /**\n     * Build a signed account-lib single-signature send transaction\n     * @param sender The senders address\n     * @param destination The destination address of the transaction\n     * @param amount The amount to send to the recipient\n     * @param tokenId The assetIndex for the token\n     */\n    const buildSignedTransaction = async function ({ sender, destination, amount = 10000, tokenId }) {\n      const txBuilder = buildBaseAssetTransferTransaction({ sender, destination, amount, tokenId });\n      txBuilder.numberOfSigners(1);\n      txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });\n      return await txBuilder.build();\n    };\n\n    it('should explain an unsigned asset transfer transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.assetTransfer.unsigned,\n        feeInfo: { fee: '1000' },\n      });\n      explain.outputAmount.should.equal('1000');\n      explain.outputs[0].amount.should.equal('1000');\n      explain.outputs[0].address.should.equal(receiver.address);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n      explain.tokenId.should.equal(1);\n    });\n\n    it('should explain a signed asset transfer transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.assetTransfer.signed,\n        feeInfo: { fee: '1000' },\n      });\n      explain.outputAmount.should.equal('10000000000000000000');\n      explain.outputs[0].amount.should.equal('10000000000000000000');\n      explain.outputs[0].address.should.equal(receiver.address);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n      explain.tokenId.should.equal(1);\n    });\n\n    it('should explain an unsigned transaction', async function () {\n      const sender = AlgoResources.accounts.account1.address;\n      const destination = AlgoResources.accounts.account2.address;\n      const amount = 10000;\n      const tokenId = 1;\n      const unsignedTransaction = await buildUnsignedTransaction({\n        sender,\n        destination,\n        amount,\n        tokenId,\n      });\n      const unsignedHex = Buffer.from(unsignedTransaction.toBroadcastFormat()).toString('hex');\n      const explain = await basecoin.explainTransaction({\n        txHex: unsignedHex,\n        feeInfo: { fee: '1000' },\n      });\n      explain.outputs[0].amount.should.equal(amount.toString());\n      explain.outputs[0].address.should.equal(destination);\n      explain.tokenId.should.equal(1);\n    });\n\n    it('should explain a signed transaction', async function () {\n      const sender = AlgoResources.accounts.account1.address;\n      const destination = AlgoResources.accounts.account2.address;\n      const amount = 10000;\n      const tokenId = 1;\n      const signedTransaction = await buildSignedTransaction({\n        sender,\n        destination,\n        amount,\n        tokenId,\n      });\n      const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');\n      const explain = await basecoin.explainTransaction({\n        txHex: signedHex,\n        feeInfo: { fee: '1000' },\n      });\n      explain.outputs[0].amount.should.equal(amount.toString());\n      explain.outputs[0].address.should.equal(destination);\n      explain.tokenId.should.equal(1);\n    });\n  });\n\n  describe('Wallet Init Builder: ', () => {\n    const buildBaseKeyRegTransaction = ({ sender, memo = '' }) => {\n      const factory = new AlgoLib.TransactionBuilderFactory(coins.get('algo'));\n      const txBuilder = factory.getWalletInitializationBuilder();\n      const lease = new Uint8Array(randomBytes(32));\n      const note = new Uint8Array(Buffer.from(memo, 'utf-8'));\n      txBuilder\n        .sender({ address: sender.address })\n        .isFlatFee(true)\n        .fee({\n          fee: '1000',\n        })\n        .firstRound(1)\n        .lastRound(100)\n        .lease(lease)\n        .note(note)\n        .voteKey(sender.voteKey)\n        .selectionKey(sender.selectionKey)\n        .voteFirst(1)\n        .voteLast(100)\n        .voteKeyDilution(9)\n        .testnet();\n      return txBuilder;\n    };\n\n    /**\n     * Build an unsigned account-lib single-signature send transaction\n     * @param sender The senders address\n     * @param memo Optional note with the transaction\n     */\n    const buildUnsignedTransaction = async function ({ sender, memo = '' }) {\n      const txBuilder = buildBaseKeyRegTransaction({ sender, memo });\n      return await txBuilder.build();\n    };\n\n    /**\n     * Build a signed account-lib single-signature send transaction\n     * @param sender The senders address\n     * @param memo Optional note with the transaction\n     */\n    const buildSignedTransaction = async function ({ sender, memo = '' }) {\n      const txBuilder = buildBaseKeyRegTransaction({ sender, memo });\n      txBuilder.numberOfSigners(1);\n      txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });\n      return await txBuilder.build();\n    };\n\n    /**\n     * Build a multi-signed account-lib single-signature send transaction\n     * @param senders The list of senders\n     * @param memo Optional note with the transaction\n     */\n    const buildMultiSignedTransaction = async function ({ senders, memo = '' }) {\n      const txBuilder = buildBaseKeyRegTransaction({ sender: senders[0], memo });\n      txBuilder.numberOfSigners(2);\n      txBuilder.setSigners(senders.map(({ address }) => address));\n      txBuilder.sign({ key: AlgoResources.accounts.account1.prvKey });\n      txBuilder.sign({ key: AlgoResources.accounts.account3.prvKey });\n      return await txBuilder.build();\n    };\n\n    it('should explain an unsigned KeyReg transfer transaction hex', async function () {\n      const sender = AlgoResources.accounts.account1;\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.keyreg.unsigned,\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.keyreg.note);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n      explain.voteKey.should.equal(sender.voteKey);\n      explain.selectionKey.should.equal(sender.selectionKey);\n      explain.voteFirst.should.equal(1);\n      explain.voteLast.should.equal(100);\n      explain.voteKeyDilution.should.equal(9);\n    });\n\n    it('should explain a signed transfer transaction hex', async function () {\n      const sender = AlgoResources.accounts.account1;\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.keyreg.signed,\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.keyreg.note);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n      explain.voteKey.should.equal(sender.voteKey);\n      explain.selectionKey.should.equal(sender.selectionKey);\n      explain.voteFirst.should.equal(1);\n      explain.voteLast.should.equal(100);\n      explain.voteKeyDilution.should.equal(9);\n    });\n\n    it('should explain a multiSig transfer transaction hex', async function () {\n      const sender = AlgoResources.accounts.account1;\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.keyreg.multiSigned,\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.keyreg.note);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n      explain.voteKey.should.equal(sender.voteKey);\n      explain.selectionKey.should.equal(sender.selectionKey);\n      explain.voteFirst.should.equal(1);\n      explain.voteLast.should.equal(100);\n      explain.voteKeyDilution.should.equal(9);\n    });\n\n    it('should explain a half signed transfer transaction hex', async function () {\n      const sender = AlgoResources.accounts.account1;\n      const explain = await basecoin.explainTransaction({\n        halfSigned: {\n          txHex: AlgoResources.explainRawTx.keyreg.halfSigned,\n        },\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.keyreg.note);\n      explain.fee.should.equal(1000);\n      explain.changeAmount.should.equal('0');\n      explain.voteKey.should.equal(sender.voteKey);\n      explain.selectionKey.should.equal(sender.selectionKey);\n      explain.voteFirst.should.equal(1);\n      explain.voteLast.should.equal(100);\n      explain.voteKeyDilution.should.equal(9);\n    });\n\n    it('should explain an unsigned transaction', async function () {\n      const sender = AlgoResources.accounts.account1;\n      const memo = AlgoResources.explainRawTx.transfer.note;\n      const unsignedTransaction = await buildUnsignedTransaction({\n        sender,\n        memo,\n      });\n\n      const unsignedHex = Buffer.from(unsignedTransaction.toBroadcastFormat()).toString('hex');\n      const explain = await basecoin.explainTransaction({\n        txHex: unsignedHex,\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.voteKey.should.equal(sender.voteKey);\n      explain.selectionKey.should.equal(sender.selectionKey);\n      explain.voteFirst.should.equal(1);\n      explain.voteLast.should.equal(100);\n      explain.voteKeyDilution.should.equal(9);\n    });\n\n    it('should explain a signed transaction', async function () {\n      const sender = AlgoResources.accounts.account1;\n      const memo = AlgoResources.explainRawTx.transfer.note;\n      const signedTransaction = await buildSignedTransaction({\n        sender,\n        memo,\n      });\n      const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');\n      const explain = await basecoin.explainTransaction({\n        txHex: signedHex,\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.voteKey.should.equal(sender.voteKey);\n      explain.selectionKey.should.equal(sender.selectionKey);\n      explain.voteFirst.should.equal(1);\n      explain.voteLast.should.equal(100);\n      explain.voteKeyDilution.should.equal(9);\n    });\n\n    it('should explain a multiSigned transaction', async function () {\n      const senders = [AlgoResources.accounts.account1, AlgoResources.accounts.account3];\n      const memo = AlgoResources.explainRawTx.transfer.note;\n      const signedTransaction = await buildMultiSignedTransaction({\n        senders,\n        memo,\n      });\n      const signedHex = Buffer.from(signedTransaction.toBroadcastFormat()).toString('hex');\n      const explain = await basecoin.explainTransaction({\n        txHex: signedHex,\n        feeInfo: { fee: '1000' },\n      });\n      Buffer.from(explain.memo).toString().should.equal(AlgoResources.explainRawTx.transfer.note);\n      explain.voteKey.should.equal(AlgoResources.accounts.account1.voteKey);\n      explain.selectionKey.should.equal(AlgoResources.accounts.account1.selectionKey);\n      explain.voteFirst.should.equal(1);\n      explain.voteLast.should.equal(100);\n      explain.voteKeyDilution.should.equal(9);\n    });\n  });\n  describe('Sign transaction', () => {\n    it('should sign transaction', async function () {\n      const signed = await basecoin.signTransaction({\n        txPrebuild: {\n          txHex: AlgoResources.rawTx.transfer.unsigned,\n          keys: [AlgoResources.accounts.account1.pubKey.toString('hex')],\n          addressVersion: 1,\n        },\n        prv: AlgoResources.accounts.account1.prvKey,\n      });\n      signed.txHex.should.equal(AlgoResources.rawTx.transfer.signed);\n    });\n\n    it('should sign transaction with root key', async function () {\n      const keypair = basecoin.generateRootKeyPair(AlgoResources.accounts.account1.secretKey);\n\n      const signed = await basecoin.signTransaction({\n        txPrebuild: {\n          txHex: AlgoResources.rawTx.transfer.unsigned,\n          keys: [keypair.pub],\n          addressVersion: 1,\n        },\n        prv: keypair.prv,\n      });\n      signed.txHex.should.equal(AlgoResources.rawTx.transfer.signed);\n    });\n\n    it('should sign half signed transaction', async function () {\n      const signed = await basecoin.signTransaction({\n        txPrebuild: {\n          halfSigned: {\n            txHex: AlgoResources.rawTx.transfer.halfSigned,\n          },\n          keys: [\n            AlgoResources.accounts.account1.pubKey.toString('hex'),\n            AlgoResources.accounts.account3.pubKey.toString('hex'),\n          ],\n          addressVersion: 1,\n        },\n        prv: AlgoResources.accounts.account3.prvKey,\n      });\n      signed.txHex.should.equal(AlgoResources.rawTx.transfer.multisig);\n    });\n\n    it('should sign half signed transaction with root key', async function () {\n      const signed = await basecoin.signTransaction({\n        txPrebuild: {\n          halfSigned: {\n            txHex: AlgoResources.rootKeyData.unsignedTx,\n          },\n          keys: [\n            AlgoResources.rootKeyData.userKeyPair.pub,\n            AlgoResources.rootKeyData.backupPub,\n            AlgoResources.rootKeyData.bitgoPub,\n          ],\n          addressVersion: 1,\n        },\n        prv: AlgoResources.rootKeyData.userKeyPair.prv,\n      });\n\n      signed.txHex.should.deepEqual(AlgoResources.rootKeyData.halfSignedTx);\n      const factory = new TransactionBuilderFactory(coins.get('algo'));\n      const tx = await factory.from(signed.txHex).build();\n      const txJson = tx.toJson();\n      txJson.from.should.equal(AlgoResources.rootKeyData.senderAddress);\n    });\n\n    it('should verify sign params if the key array contains addresses', function () {\n      const keys = [\n        AlgoResources.accounts.account1.address,\n        AlgoResources.accounts.account2.address,\n        AlgoResources.accounts.account3.address,\n      ];\n\n      const verifiedParams = basecoin.verifySignTransactionParams({\n        txPrebuild: {\n          txHex: AlgoResources.rawTx.transfer.unsigned,\n          keys,\n          addressVersion: 1,\n        },\n        prv: AlgoResources.accounts.account2.secretKey.toString('hex'),\n      });\n      verifiedParams.should.have.properties([\n        'txHex',\n        'addressVersion',\n        'signers',\n        'prv',\n        'isHalfSigned',\n        'numberSigners',\n      ]);\n      const { txHex, signers, isHalfSigned } = verifiedParams;\n      txHex.should.be.equal(AlgoResources.rawTx.transfer.unsigned);\n      signers.should.be.deepEqual(keys);\n      isHalfSigned.should.be.equal(false);\n    });\n\n    it('should sign half signed transaction if the key array contains addresses', async function () {\n      const signed = await basecoin.signTransaction({\n        txPrebuild: {\n          halfSigned: {\n            txHex: AlgoResources.rawTx.transfer.halfSigned,\n          },\n          keys: [AlgoResources.accounts.account1.address, AlgoResources.accounts.account3.address],\n          addressVersion: 1,\n        },\n        prv: AlgoResources.accounts.account3.prvKey,\n      });\n      signed.txHex.should.equal(AlgoResources.rawTx.transfer.multisig);\n    });\n  });\n\n  describe('Sign message', () => {\n    it('should sign message', async function () {\n      const signed = await basecoin.signMessage(\n        { prv: AlgoResources.accounts.account1.prvKey },\n        AlgoResources.message.unsigned\n      );\n      signed.toString('hex').should.equal(AlgoResources.message.signed);\n    });\n  });\n\n  describe('Generate wallet key pair: ', () => {\n    it('should generate key pair', () => {\n      const kp = basecoin.generateKeyPair();\n      basecoin.isValidPub(kp.pub).should.equal(true);\n      basecoin.isValidPrv(kp.prv).should.equal(true);\n    });\n\n    it('should generate key pair from seed', () => {\n      const seed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');\n      const kp = basecoin.generateKeyPair(seed);\n      basecoin.isValidPub(kp.pub).should.equal(true);\n      basecoin.isValidPrv(kp.prv).should.equal(true);\n    });\n  });\n\n  describe('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      basecoin.isValidPrv(kp.prv).should.equal(true);\n    });\n\n    it('should generate key pair from seed', () => {\n      const seed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');\n      const kp = basecoin.generateRootKeyPair(seed);\n      basecoin.isValidPub(kp.pub).should.equal(true);\n      kp.pub.should.equal('d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a');\n      basecoin.isValidPrv(kp.prv).should.equal(true);\n      kp.prv.should.equal(\n        '9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a'\n      );\n    });\n  });\n\n  describe('Enable, disable and transfer Token ', () => {\n    it('should explain an enable token transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.enableToken,\n        feeInfo: { fee: '1000' },\n      });\n      explain.operations.length.should.equals(1);\n      explain.operations[0].type.should.equals('enableToken');\n      explain.operations[0].coin.should.equals('talgo:USON-16026728');\n    });\n\n    it('should explain an disable token transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.disableToken,\n        feeInfo: { fee: '1000' },\n      });\n      explain.operations.length.should.equals(1);\n      explain.operations[0].type.should.equals('disableToken');\n      explain.operations[0].coin.should.equals('talgo:USON-16026728');\n    });\n    it('should explain an transfer token transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.assetTransfer.signed,\n        feeInfo: { fee: '1000' },\n      });\n      explain.operations.length.should.equals(1);\n      explain.operations[0].type.should.equals('transferToken');\n      explain.operations[0].coin.should.equals('AlgoToken unknown');\n    });\n    it('should explain an enable USDT token transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.enableTokenUSDT,\n        feeInfo: { fee: '1000' },\n      });\n      explain.operations.length.should.equals(1);\n      explain.operations[0].type.should.equals('enableToken');\n      explain.operations[0].coin.should.equals('talgo:USDt-180447');\n    });\n    it('should explain an enable USDC token transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.enableTokenUSDC,\n        feeInfo: { fee: '1000' },\n      });\n      explain.operations.length.should.equals(1);\n      explain.operations[0].type.should.equals('enableToken');\n      explain.operations[0].coin.should.equals('talgo:USDC-10458941');\n    });\n    it('should explain an disable USDC token transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.disableTokenUSDC,\n        feeInfo: { fee: '1000' },\n      });\n      explain.operations.length.should.equals(1);\n      explain.operations[0].type.should.equals('disableToken');\n      explain.operations[0].coin.should.equals('talgo:USDC-10458941');\n    });\n    it('should explain an transfer USDC token transaction hex', async function () {\n      const explain = await basecoin.explainTransaction({\n        txHex: AlgoResources.explainRawTx.USDCAssetTransfer.signed,\n        feeInfo: { fee: '1000' },\n      });\n      explain.operations.length.should.equals(1);\n      explain.operations[0].type.should.equals('transferToken');\n      explain.operations[0].coin.should.equals('talgo:USDC-10458941');\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('Recovery', function () {\n    const fee = 1000;\n    const userKey =\n      '{\"iv\":\"ZJg0a0+zT+684MUl44Lm4A==\",\"v\":1,\"iter\":10000,\"ks\":128,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"abQy0OL2468=\",\"ct\":\"LNlSlTJED8jSwHCmUflzqFtRPL+PojzOgfd5mD2nmLVdAoyKCWHvAieKt7lJ7zg417CUi6Qj77/s3lbqmxVsfEsk\"}';\n    const userPub = 'S4D7DDRAHWZIB2RCZICSRODFCNQXGANHGA7VCWBK5I37SQT6KVHXQNKMTE';\n    const backupKey =\n      '{\"iv\":\"mZY8XTvHxX8BPc1rdGQQww==\",\"v\":1,\"iter\":10000,\"ks\":128,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"abQy0OL2468=\",\"ct\":\"UQXo0EaPXb6TIZDYYhKYS9d/fRMNT6ptpl9BgJw3AVooSbO4nppWnTRYlQO7hpON4XY85hYDu/7hy91IX1z1bDDq\"}';\n    const backupPub = '6FVGZUZOHZSXTTBRLWZDXGYSWVVYNN4ZESIEMZEMIBJCUBHC5C77OIE5RQ';\n    const rootAddress = 'FWLNDL7UXCSOPOQXA5VU2DMANZAYCCMBY377HKTGGMZ4GEPEJBFARDOGBA';\n    const walletPassphrase = 'Testing@43210!';\n    const recoveryDestination = 'GB3YETD5TSTBAIYGYHVWU3O3I7XGOB44HOZA5MOEF5M23CLLZKRQLEVAOA';\n    const bitgoPub = 'FJSWLLPRBXEGMWZY5BXA6673YKIK7JOURVCQEOWXC5TQPCXCOK3VHOO2VQ';\n    const nativeBalance = 10000000; // 10 ALGO\n    const MIN_ACCOUNT_BALANCE = 100000; // 1 AGLO\n\n    const nodeParams = {\n      token: '2810c2d168e8417c5f111d38d68327b8cfe2d0ddc02986490c22f8ddf4128bcd',\n      baseServer: 'http://localhost/',\n      port: 8443,\n    };\n\n    describe('Non-BitGo', async function () {\n      const sandBox = Sinon.createSandbox();\n      const expectedAmount = new BigNumber(nativeBalance).minus(fee).minus(MIN_ACCOUNT_BALANCE).toString();\n\n      afterEach(function () {\n        sandBox.verifyAndRestore();\n      });\n\n      it('should build and sign the recovery tx', async function () {\n        const getBalanceStub = sandBox.stub(Algo.prototype, 'getAccountBalance').resolves(nativeBalance);\n\n        const recovery = await basecoin.recover({\n          userKey,\n          backupKey,\n          rootAddress,\n          walletPassphrase,\n          fee,\n          bitgoKey: bitgoPub,\n          recoveryDestination: recoveryDestination,\n          firstRound: 5002596,\n          nodeParams,\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('fee');\n        recovery.should.have.property('coin', 'talgo');\n        recovery.should.have.property('firstRound');\n        recovery.should.have.property('lastRound');\n        getBalanceStub.callCount.should.equal(1);\n        const factory = new AlgoLib.TransactionBuilderFactory(coins.get('algo'));\n        const txBuilder = factory.from(recovery.tx);\n        const tx = await txBuilder.build();\n        const txBroadcastFormat = Buffer.from(tx.toBroadcastFormat()).toString('base64');\n        txBroadcastFormat.should.deepEqual(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(fee);\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: invalidRootAddress,\n              walletPassphrase,\n              fee,\n              recoveryDestination: recoveryDestination,\n              firstRound: 5002596,\n              nodeParams,\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              fee,\n              recoveryDestination: invalidRecoveryDestination,\n              firstRound: 5002596,\n              nodeParams,\n            });\n          },\n          { message: 'invalid recoveryDestination, got: ' + invalidRecoveryDestination }\n        );\n      });\n\n      it('should throw if there is no enough balance to recover', async function () {\n        const getBalanceStub = sandBox.stub(Algo.prototype, 'getAccountBalance').resolves(100500);\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress,\n              fee,\n              walletPassphrase,\n              bitgoKey: bitgoPub,\n              recoveryDestination,\n              firstRound: 5003596,\n              nodeParams,\n            });\n          },\n          { message: 'Insufficient balance to recover, got balance: 100500 fee: 1000 min account balance: 100000' }\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              fee,\n              recoveryDestination,\n              firstRound: 5003596,\n              nodeParams,\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              bitgoKey: bitgoPub,\n              walletPassphrase: 'wrongpassword',\n              fee,\n              recoveryDestination,\n              firstRound: 5003596,\n              nodeParams,\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 throw if bitgo key is not provided', async function () {\n        await assert.rejects(\n          async () => {\n            await basecoin.recover({\n              userKey,\n              backupKey,\n              rootAddress,\n              walletPassphrase,\n              fee,\n              recoveryDestination,\n              firstRound: 5003596,\n              nodeParams,\n            });\n          },\n          {\n            message: 'bitgo public key from the keyCard is required for non-bitgo recovery',\n          }\n        );\n      });\n\n      it('should be able to pass a utf-8 encoded note', async function () {\n        const note = 'Non-BitGo Recovery Sweep Tx';\n        sandBox.stub(Algo.prototype, 'getAccountBalance').resolves(nativeBalance);\n        const recovery = await basecoin.recover({\n          userKey,\n          backupKey,\n          rootAddress,\n          walletPassphrase,\n          fee,\n          bitgoKey: bitgoPub,\n          recoveryDestination: recoveryDestination,\n          firstRound: 5002596,\n          nodeParams,\n          note,\n        });\n\n        recovery.should.not.be.undefined();\n        recovery.note.should.be.equal(note);\n      });\n    });\n\n    describe('Unsigned Sweep', function () {\n      const sandBox = Sinon.createSandbox();\n      const expectedAmount = new BigNumber(nativeBalance).minus(fee).minus(MIN_ACCOUNT_BALANCE).toString();\n      let getBalanceStub: SinonStub;\n\n      beforeEach(function () {\n        getBalanceStub = sandBox.stub(Algo.prototype, 'getAccountBalance').resolves(nativeBalance);\n      });\n\n      afterEach(function () {\n        sandBox.verifyAndRestore();\n      });\n\n      it('should build unsigned sweep tx', async function () {\n        const recovery = await basecoin.recover({\n          userKey: userPub,\n          backupKey: backupPub,\n          bitgoKey: bitgoPub,\n          rootAddress,\n          walletPassphrase,\n          fee,\n          recoveryDestination,\n          firstRound: 5003596,\n          nodeParams,\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('type');\n        recovery.should.have.property('amount');\n        recovery.should.have.property('feeInfo');\n        recovery.should.have.property('coin', 'talgo');\n        recovery.firstRound.should.not.be.undefined();\n        recovery.lastRound.should.not.be.undefined();\n        recovery.should.have.property('keys');\n        recovery.keys.should.deepEqual([userPub, backupPub, bitgoPub]);\n        recovery.addressVersion.should.equal(1);\n\n        getBalanceStub.callCount.should.equal(1);\n        const factory = new AlgoLib.TransactionBuilderFactory(coins.get('algo'));\n        const txBuilder = factory.from(recovery.txHex);\n        const tx = await txBuilder.build();\n        Buffer.from(tx.toBroadcastFormat()).toString('hex').should.deepEqual(recovery.txHex);\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(fee);\n      });\n    });\n\n    describe('Recovery with root keys', function () {\n      const sandBox = Sinon.createSandbox();\n      let userKp: KeyPair;\n      let backupKp: KeyPair;\n      let rootAddress: string;\n      let encryptedUserPrv: string;\n      let encryptedBackupPrv: string;\n\n      const expectedAmount = new BigNumber(nativeBalance).minus(fee).minus(MIN_ACCOUNT_BALANCE).toString();\n      let getBalanceStub: SinonStub;\n\n      beforeEach(function () {\n        const userSeed = Buffer.from('9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');\n        userKp = basecoin.generateRootKeyPair(userSeed);\n        encryptedUserPrv = bitgo.encrypt({\n          input: userKp.prv,\n          password: walletPassphrase,\n        });\n        assert(userKp.pub);\n\n        const backupSeed = Buffer.from('6d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60', 'hex');\n        backupKp = basecoin.generateRootKeyPair(backupSeed);\n        encryptedBackupPrv = bitgo.encrypt({\n          input: backupKp.prv,\n          password: walletPassphrase,\n        });\n        const bitgoPub = 'FJSWLLPRBXEGMWZY5BXA6673YKIK7JOURVCQEOWXC5TQPCXCOK3VHOO2VQ';\n        const userAddress = AlgoLib.algoUtils.privateKeyToAlgoAddress(userKp.prv);\n        const backupAddress = AlgoLib.algoUtils.privateKeyToAlgoAddress(backupKp.prv);\n\n        rootAddress = AlgoLib.algoUtils.multisigAddress(1, 2, [userAddress, backupAddress, bitgoPub]);\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        getBalanceStub = sandBox.stub(Algo.prototype, 'getAccountBalance').resolves(nativeBalance);\n        const recovery = await basecoin.recover({\n          userKey: encryptedUserPrv,\n          backupKey: encryptedBackupPrv,\n          rootAddress,\n          walletPassphrase,\n          fee,\n          bitgoKey: bitgoPub,\n          recoveryDestination: recoveryDestination,\n          firstRound: 5002596,\n          nodeParams,\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('fee');\n        recovery.should.have.property('coin', 'talgo');\n        recovery.should.have.property('firstRound');\n        recovery.should.have.property('lastRound');\n        getBalanceStub.callCount.should.equal(1);\n        const factory = new AlgoLib.TransactionBuilderFactory(coins.get('algo'));\n        const txBuilder = factory.from(recovery.tx);\n        const tx = await txBuilder.build();\n        const txBroadcastFormat = Buffer.from(tx.toBroadcastFormat()).toString('base64');\n        txBroadcastFormat.should.deepEqual(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(fee);\n      });\n\n      it('should build unsigned sweep tx', async function () {\n        getBalanceStub = sandBox.stub(Algo.prototype, 'getAccountBalance').resolves(nativeBalance);\n        const recovery = await basecoin.recover({\n          userKey: userKp.pub!,\n          backupKey: backupKp.pub!,\n          bitgoKey: bitgoPub,\n          rootAddress,\n          walletPassphrase,\n          fee,\n          recoveryDestination,\n          firstRound: 5003596,\n          nodeParams,\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('type');\n        recovery.should.have.property('amount');\n        recovery.should.have.property('feeInfo');\n        recovery.should.have.property('coin', 'talgo');\n        recovery.firstRound.should.not.be.undefined();\n        recovery.lastRound.should.not.be.undefined();\n        recovery.should.have.property('keys');\n        recovery.keys.should.deepEqual([userKp.pub, backupKp.pub, bitgoPub]);\n        recovery.addressVersion.should.equal(1);\n\n        getBalanceStub.callCount.should.equal(1);\n        const factory = new AlgoLib.TransactionBuilderFactory(coins.get('algo'));\n        const txBuilder = factory.from(recovery.txHex);\n        const tx = await txBuilder.build();\n        Buffer.from(tx.toBroadcastFormat()).toString('hex').should.deepEqual(recovery.txHex);\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(fee);\n      });\n    });\n  });\n\n  describe('AuditKey', () => {\n    const { key } = algoBackupKey;\n    const walletPassphrase = 'ZQ8MhxT84m4P';\n\n    it('should return for valid inputs', () => {\n      basecoin.assertIsValidKey({\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            encryptedPrv: key,\n            walletPassphrase: 'foo',\n          });\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            encryptedPrv: alteredKey,\n            walletPassphrase,\n          });\n        },\n        { message: 'failed to decrypt prv: json decrypt: invalid parameters' }\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            encryptedPrv,\n            walletPassphrase,\n          });\n        },\n        { message: 'Invalid private key: Invalid base32 characters' }\n      );\n    });\n  });\n\n  describe('blind signing token enablement protection', () => {\n    let wallet: Wallet;\n    const bgUrl = common.Environments['mock'].uri;\n\n    before(() => {\n      bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n      bitgo.safeRegister('talgo', Talgo.createInstance);\n      bitgo.initializeTestVars();\n      basecoin = bitgo.coin('talgo');\n\n      wallet = new Wallet(bitgo, basecoin, {\n        id: '123',\n        coin: 'talgo',\n        keys: ['1', '2', '3'],\n        coinSpecific: {\n          rootAddress: '123',\n        },\n        type: 'hot',\n      });\n    });\n    it('should verify a valid token enablement transaction', async function () {\n      const verifyTransactionStub = spy(basecoin, 'verifyTransaction');\n      nock(bgUrl)\n        .post(`/api/v2/talgo/wallet/${wallet.id()}/tx/build`)\n        .reply(200, {\n          txHex:\n            'iaRhcmN2xCBfnMgYtbyG4RL1DspYhxQeyn9QrJ+s2ZcDTcxK+yOH+KNmZWXNA+iiZnbOA2tlJKNnZW6sdGVzdG5ldC12MS4womdoxCBIY7UYpLPITsgQ8i1PEIHLD3HwWaesIN7GL39w5Qk6IqJsds4Da2kMo3NuZMQgX5zIGLW8huES9Q7KWIcUHsp/UKyfrNmXA03MSvsjh/ikdHlwZaVheGZlcqR4YWlkzgmpOkY=',\n          txHash: 'ARYMOXMKZWM372JBFBTADZNJZU7S5HK44NZDZLVX5UR5UPIWT7FA',\n          txInfo: {\n            id: 'ARYMOXMKZWM372JBFBTADZNJZU7S5HK44NZDZLVX5UR5UPIWT7FA',\n            type: 'axfer',\n            from: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',\n            fee: 1000,\n            firstRound: 57369892,\n            lastRound: 57370892,\n            note: {},\n            tokenId: 162085446,\n            genesisID: 'testnet-v1.0',\n            genesisHash: 'SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=',\n            to: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',\n            amount: '0',\n            txType: 'enableToken',\n            tokenName: 'TALGO',\n          },\n          feeInfo: {\n            size: 251,\n            fee: 1000,\n            feeRate: 4,\n            feeString: '1000',\n          },\n          keys: [\n            '42MIYL2KBISV6WJRALTTSXHBEGLNF7MMQ74FGSYUCT5YP3V2KENJGRFVVQ',\n            'MAGXZTDFW5QEXUKOUDIGHTXOKDW7TNQEDLWPBEZEL3VFU3YAA2PGYRS65M',\n            'TMEJTI7XNCACDG3BTODINW6CMR6ARYIKTCFPA2GMIXL4X5Q4BCE6VHMWAM',\n          ],\n          addressVersion: 1,\n          coin: 'talgo',\n        });\n      const validatePwdStub = stub(wallet, 'getKeychainsAndValidatePassphrase' as keyof Wallet).resolves([]);\n      const signTxStub = stub(wallet, 'signTransaction').resolves({});\n\n      await wallet.sendTokenEnablements({\n        verification: { verifyTokenEnablement: true },\n        enableTokens: [\n          {\n            name: 'talgo:JPT-162085446',\n            address: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',\n          },\n        ],\n      });\n\n      verifyTransactionStub.called.should.be.true();\n      verifyTransactionStub.restore();\n      validatePwdStub.restore();\n      signTxStub.restore();\n    });\n\n    it('should throw error when invalid token enablement transaction is returned', async () => {\n      const verifyTransactionStub = spy(basecoin, 'verifyTransaction');\n      nock(bgUrl)\n        .post(`/api/v2/talgo/wallet/${wallet.id()}/tx/build`)\n        .reply(200, {\n          txHex:\n            'iaRhcmN2xCBfnMgYtbyG4RL1DspYhxQeyn9QrJ+s2ZcDTcxK+yOH+KNmZWXNA+iiZnbOA2tpeqNnZW6sdGVzdG5ldC12MS4womdoxCBIY7UYpLPITsgQ8i1PEIHLD3HwWaesIN7GL39w5Qk6IqJsds4Da21io3NuZMQgX5zIGLW8huES9Q7KWIcUHsp/UKyfrNmXA03MSvsjh/ikdHlwZaVheGZlcqR4YWlkzgACwN8=',\n          txHash: 'YPQGYNBOCPXMBFTBZH2AQGCDZ3C2762T6EYQY46F7LRG2URX6DLA',\n          txInfo: {\n            id: 'YPQGYNBOCPXMBFTBZH2AQGCDZ3C2762T6EYQY46F7LRG2URX6DLA',\n            type: 'axfer',\n            from: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',\n            fee: 1000,\n            firstRound: 57371002,\n            lastRound: 57372002,\n            note: {},\n            tokenId: 180447,\n            genesisID: 'testnet-v1.0',\n            genesisHash: 'SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=',\n            to: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',\n            amount: '0',\n            txType: 'enableToken',\n            tokenName: 'TALGO',\n          },\n          feeInfo: {\n            size: 251,\n            fee: 1000,\n            feeRate: 4,\n            feeString: '1000',\n          },\n          keys: [\n            '42MIYL2KBISV6WJRALTTSXHBEGLNF7MMQ74FGSYUCT5YP3V2KENJGRFVVQ',\n            'MAGXZTDFW5QEXUKOUDIGHTXOKDW7TNQEDLWPBEZEL3VFU3YAA2PGYRS65M',\n            'TMEJTI7XNCACDG3BTODINW6CMR6ARYIKTCFPA2GMIXL4X5Q4BCE6VHMWAM',\n          ],\n          addressVersion: 1,\n          coin: 'talgo',\n        });\n      stub(wallet, 'getKeychainsAndValidatePassphrase' as keyof Wallet).resolves([]);\n      stub(wallet, 'signTransaction').resolves({});\n\n      const { success, failure } = await wallet.sendTokenEnablements({\n        verification: { verifyTokenEnablement: true },\n        enableTokens: [\n          {\n            name: 'talgo:JPT-162085446',\n            address: 'L6OMQGFVXSDOCEXVB3FFRBYUD3FH6UFMT6WNTFYDJXGEV6ZDQ74EXGF6BE',\n          },\n        ],\n      });\n\n      verifyTransactionStub.called.should.be.true();\n      success.length.should.equal(0);\n      failure.length.should.equal(1);\n      failure[0].message.should.equal(\n        'Token enablement verification failed: expected token ID 162085446 but transaction has token ID 180447'\n      );\n    });\n  });\n});\n"]}