@bitgo/sdk-coin-ton 3.9.2 → 3.9.4

package/dist/test/unit/ton.js

@@ -0,0 +1,668 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_test_1 = require("@bitgo/sdk-test");
+const sdk_api_1 = require("@bitgo/sdk-api");
+const src_1 = require("../../src");
+const sinon = __importStar(require("sinon"));
+const assert_1 = __importDefault(require("assert"));
+const testData = __importStar(require("../resources/ton"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const should_1 = __importDefault(require("should"));
+const utils_1 = __importDefault(require("../../src/lib/utils"));
+const tonweb_1 = __importDefault(require("tonweb"));
+describe('TON:', function () {
+    let basecoin;
+    const bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+    bitgo.safeRegister('ton', src_1.Ton.createInstance);
+    bitgo.safeRegister('tton', src_1.Tton.createInstance);
+    bitgo.initializeTestVars();
+    const txPrebuildList = [
+        {
+            txHex: Buffer.from(testData.signedSendTransaction.tx, 'base64').toString('hex'),
+            txInfo: {},
+        },
+        {
+            txHex: Buffer.from(testData.signedSingleNominatorWithdrawTransaction.tx, 'base64').toString('hex'),
+            txInfo: {},
+        },
+    ];
+    const txPrebuildBounceableList = [
+        {
+            txHex: Buffer.from(testData.signedSendTransaction.txBounceable, 'base64').toString('hex'),
+            txInfo: {},
+        },
+        {
+            txHex: Buffer.from(testData.signedSingleNominatorWithdrawTransaction.txBounceable, 'base64').toString('hex'),
+            txInfo: {},
+        },
+    ];
+    const txParamsList = [
+        {
+            recipients: [testData.signedSendTransaction.recipient],
+        },
+        {
+            recipients: [testData.signedSingleNominatorWithdrawTransaction.recipient],
+        },
+    ];
+    const txParamsBounceableList = [
+        {
+            recipients: [testData.signedSendTransaction.recipientBounceable],
+        },
+        {
+            recipients: [testData.signedSingleNominatorWithdrawTransaction.recipientBounceable],
+        },
+    ];
+    it('should return the right info', function () {
+        const ton = bitgo.coin('ton');
+        const tton = bitgo.coin('tton');
+        ton.getChain().should.equal('ton');
+        ton.getFamily().should.equal('ton');
+        ton.getFullName().should.equal('Ton');
+        ton.getBaseFactor().should.equal(1e9);
+        tton.getChain().should.equal('tton');
+        tton.getFamily().should.equal('ton');
+        tton.getFullName().should.equal('Testnet Ton');
+        tton.getBaseFactor().should.equal(1e9);
+    });
+    describe('Verify transaction: ', () => {
+        basecoin = bitgo.coin('tton');
+        txParamsList.forEach((_, index) => {
+            const txParams = txParamsList[index];
+            const txPrebuild = txPrebuildList[index];
+            const txParamsBounceable = txParamsBounceableList[index];
+            const txPrebuildBounceable = txPrebuildBounceableList[index];
+            it('should succeed to verify transaction', async function () {
+                const verification = {};
+                const isTransactionVerified = await basecoin.verifyTransaction({
+                    txParams,
+                    txPrebuild,
+                    verification,
+                });
+                isTransactionVerified.should.equal(true);
+                const isBounceableTransactionVerified = await basecoin.verifyTransaction({
+                    txParams: txParamsBounceable,
+                    txPrebuild: txPrebuildBounceable,
+                    verification: {},
+                });
+                isBounceableTransactionVerified.should.equal(true);
+            });
+            it('should succeed to verify transaction when recipients amount are numbers', async function () {
+                const txParamsWithNumberAmounts = JSON.parse(JSON.stringify(txParams));
+                txParamsWithNumberAmounts.recipients[0].amount = 20000000;
+                const verification = {};
+                await basecoin
+                    .verifyTransaction({
+                    txParams: txParamsWithNumberAmounts,
+                    txPrebuild,
+                    verification,
+                })
+                    .should.rejectedWith('Tx outputs does not match with expected txParams recipients');
+            });
+            it('should succeed to verify transaction when recipients amount are strings', async function () {
+                const txParamsWithNumberAmounts = JSON.parse(JSON.stringify(txParams));
+                txParamsWithNumberAmounts.recipients[0].amount = '20000000';
+                const verification = {};
+                await basecoin
+                    .verifyTransaction({
+                    txParams: txParamsWithNumberAmounts,
+                    txPrebuild,
+                    verification,
+                })
+                    .should.rejectedWith('Tx outputs does not match with expected txParams recipients');
+            });
+            it('should succeed to verify transaction when recipients amounts are number and amount is same', async function () {
+                const verification = {};
+                await basecoin
+                    .verifyTransaction({
+                    txParams,
+                    txPrebuild,
+                    verification,
+                })
+                    .should.resolvedWith(true);
+            });
+            it('should succeed to verify transaction when recipients amounts are string and amount is same', async function () {
+                const verification = {};
+                await basecoin
+                    .verifyTransaction({
+                    txParams,
+                    txPrebuild,
+                    verification,
+                })
+                    .should.resolvedWith(true);
+            });
+            it('should succeed to verify transaction when recipient address are non bounceable', async function () {
+                const txParamsWithNumberAmounts = JSON.parse(JSON.stringify(txParams));
+                txParamsWithNumberAmounts.recipients[0].address = new tonweb_1.default.Address(txParamsWithNumberAmounts.recipients[0].address).toString(true, true, false);
+                const verification = {};
+                const isVerified = await basecoin.verifyTransaction({
+                    txParams: txParamsWithNumberAmounts,
+                    txPrebuild,
+                    verification,
+                });
+                isVerified.should.equal(true);
+            });
+            it('should fail to verify transaction with invalid param', async function () {
+                const txPrebuild = {};
+                await basecoin
+                    .verifyTransaction({
+                    txParams,
+                    txPrebuild,
+                })
+                    .should.rejectedWith('missing required tx prebuild property txHex');
+            });
+        });
+        it('should succeed to verify transaction with recipient having memo', async function () {
+            const txParams = {
+                recipients: [testData.signedSendTransactionForMemoId.recipient],
+            };
+            const txPrebuild = {
+                txHex: Buffer.from(testData.signedSendTransactionForMemoId.tx, 'base64').toString('hex'),
+                txInfo: {},
+            };
+            const verification = {};
+            const isTransactionVerified = await basecoin.verifyTransaction({
+                txParams,
+                txPrebuild,
+                verification,
+            });
+            isTransactionVerified.should.equal(true);
+        });
+    });
+    describe('Explain Transaction: ', () => {
+        const basecoin = bitgo.coin('tton');
+        it('should explain a transfer transaction', async function () {
+            const explainedTransaction = (await basecoin.explainTransaction({
+                txHex: Buffer.from(testData.signedSendTransaction.tx, 'base64').toString('hex'),
+            }));
+            explainedTransaction.should.deepEqual({
+                displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],
+                id: 'tuyOkyFUMv_neV_FeNBH24Nd4cML2jUgDP4zjGkuOFI=',
+                outputs: [
+                    {
+                        address: testData.signedSendTransaction.recipient.address,
+                        amount: testData.signedSendTransaction.recipient.amount,
+                    },
+                ],
+                outputAmount: testData.signedSendTransaction.recipient.amount,
+                changeOutputs: [],
+                changeAmount: '0',
+                fee: { fee: 'UNKNOWN' },
+                withdrawAmount: undefined,
+            });
+        });
+        it('should explain a non-bounceable transfer transaction', async function () {
+            const explainedTransaction = (await basecoin.explainTransaction({
+                txHex: Buffer.from(testData.signedSendTransaction.tx, 'base64').toString('hex'),
+                toAddressBounceable: false,
+                fromAddressBounceable: false,
+            }));
+            explainedTransaction.should.deepEqual({
+                displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],
+                id: 'tuyOkyFUMv_neV_FeNBH24Nd4cML2jUgDP4zjGkuOFI=',
+                outputs: [
+                    {
+                        address: testData.signedSendTransaction.recipientBounceable.address,
+                        amount: testData.signedSendTransaction.recipientBounceable.amount,
+                    },
+                ],
+                outputAmount: testData.signedSendTransaction.recipientBounceable.amount,
+                changeOutputs: [],
+                changeAmount: '0',
+                fee: { fee: 'UNKNOWN' },
+                withdrawAmount: undefined,
+            });
+        });
+        it('should explain a single nominator withdraw transaction', async function () {
+            const explainedTransaction = (await basecoin.explainTransaction({
+                txHex: Buffer.from(testData.signedSingleNominatorWithdrawTransaction.tx, 'base64').toString('hex'),
+            }));
+            explainedTransaction.should.deepEqual({
+                displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],
+                id: testData.signedSingleNominatorWithdrawTransaction.txId,
+                outputs: [
+                    {
+                        address: testData.signedSingleNominatorWithdrawTransaction.recipient.address,
+                        amount: testData.signedSingleNominatorWithdrawTransaction.recipient.amount,
+                    },
+                ],
+                outputAmount: testData.signedSingleNominatorWithdrawTransaction.recipient.amount,
+                changeOutputs: [],
+                changeAmount: '0',
+                fee: { fee: 'UNKNOWN' },
+                withdrawAmount: '932178112330000',
+            });
+        });
+        it('should explain a non-bounceable single nominator withdraw transaction', async function () {
+            const explainedTransaction = (await basecoin.explainTransaction({
+                txHex: Buffer.from(testData.signedSingleNominatorWithdrawTransaction.tx, 'base64').toString('hex'),
+                toAddressBounceable: false,
+                fromAddressBounceable: false,
+            }));
+            explainedTransaction.should.deepEqual({
+                displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],
+                id: testData.signedSingleNominatorWithdrawTransaction.txIdBounceable,
+                outputs: [
+                    {
+                        address: testData.signedSingleNominatorWithdrawTransaction.recipientBounceable.address,
+                        amount: testData.signedSingleNominatorWithdrawTransaction.recipientBounceable.amount,
+                    },
+                ],
+                outputAmount: testData.signedSingleNominatorWithdrawTransaction.recipientBounceable.amount,
+                changeOutputs: [],
+                changeAmount: '0',
+                fee: { fee: 'UNKNOWN' },
+                withdrawAmount: '932178112330000',
+            });
+        });
+        it('should fail to explain transaction with missing params', async function () {
+            try {
+                await basecoin.explainTransaction({});
+            }
+            catch (error) {
+                should_1.default.equal(error.message, 'Invalid transaction');
+            }
+        });
+        it('should fail to explain transaction with invalid params', async function () {
+            try {
+                await basecoin.explainTransaction({ txHex: 'randomString' });
+            }
+            catch (error) {
+                should_1.default.equal(error.message, 'Invalid transaction');
+            }
+        });
+    });
+    describe('Parse Transactions: ', () => {
+        const basecoin = bitgo.coin('tton');
+        const transactionsList = [testData.signedSendTransaction.tx, testData.signedSingleNominatorWithdrawTransaction.tx];
+        const transactionInputsResponseList = [
+            [
+                {
+                    address: 'EQCSBjR3fUOL98WTw2F_IT4BrcqjZJWVLWUSz5WQDpaL9Jpl',
+                    amount: '10000000',
+                },
+            ],
+            [
+                {
+                    address: 'EQAbJug-k-tufWMjEC1RKSM0iiJTDUcYkC7zWANHrkT55Fol',
+                    amount: '123400000',
+                },
+            ],
+        ];
+        const transactionInputsResponseBounceableList = [
+            [
+                {
+                    address: 'UQCSBjR3fUOL98WTw2F_IT4BrcqjZJWVLWUSz5WQDpaL9Meg',
+                    amount: '10000000',
+                },
+            ],
+            [
+                {
+                    address: 'UQAbJug-k-tufWMjEC1RKSM0iiJTDUcYkC7zWANHrkT55Afg',
+                    amount: '123400000',
+                },
+            ],
+        ];
+        const transactionOutputsResponseList = [
+            [
+                {
+                    address: 'EQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBXwtG',
+                    amount: '10000000',
+                },
+            ],
+            [
+                {
+                    address: 'EQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBXwtG',
+                    amount: '123400000',
+                },
+            ],
+        ];
+        const transactionOutputsResponseBounceableList = [
+            [
+                {
+                    address: 'UQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBX1aD',
+                    amount: '10000000',
+                },
+            ],
+            [
+                {
+                    address: 'UQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBX1aD',
+                    amount: '123400000',
+                },
+            ],
+        ];
+        transactionsList.forEach((_, index) => {
+            const transaction = transactionsList[index];
+            const transactionInputsResponse = transactionInputsResponseList[index];
+            const transactionInputsResponseBounceable = transactionInputsResponseBounceableList[index];
+            const transactionOutputsResponse = transactionOutputsResponseList[index];
+            const transactionOutputsResponseBounceable = transactionOutputsResponseBounceableList[index];
+            it('should parse a TON transaction', async function () {
+                const parsedTransaction = await basecoin.parseTransaction({
+                    txHex: Buffer.from(transaction, 'base64').toString('hex'),
+                });
+                parsedTransaction.should.deepEqual({
+                    inputs: transactionInputsResponse,
+                    outputs: transactionOutputsResponse,
+                });
+            });
+            it('should parse a non-bounceable TON transaction', async function () {
+                const parsedTransaction = await basecoin.parseTransaction({
+                    txHex: Buffer.from(transaction, 'base64').toString('hex'),
+                    toAddressBounceable: false,
+                    fromAddressBounceable: false,
+                });
+                parsedTransaction.should.deepEqual({
+                    inputs: transactionInputsResponseBounceable,
+                    outputs: transactionOutputsResponseBounceable,
+                });
+            });
+            it('should fail to parse a TON transaction when explainTransaction response is undefined', async function () {
+                const stub = sinon.stub(src_1.Ton.prototype, 'explainTransaction');
+                stub.resolves(undefined);
+                await basecoin.parseTransaction({ txHex: transaction }).should.be.rejectedWith('invalid raw transaction');
+                stub.restore();
+            });
+        });
+    });
+    describe('Address Validation', () => {
+        const basecoin = bitgo.coin('tton');
+        let keychains;
+        let commonKeychain;
+        before(function () {
+            commonKeychain =
+                '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781';
+            keychains = [
+                {
+                    id: '6424c353eaf78d000766e95949868468',
+                    source: 'user',
+                    type: 'tss',
+                    commonKeychain: '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781',
+                    encryptedPrv: '{"iv":"cZd5i7L4RxtwrALW2rK7UA==","v":1,"iter":10000,"ks":256,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"5zgoH1Bd3Fw=","ct":"9vVlnXFRtrM9FVEo+d2chbGHlM9lFZemueBuAs3BIkPo33Fo7jzwwNK/kIWkEyg+NmEBd5IaqAS157nvvvwzzsmMWlQdUz9qbmXNv3pg987cXFR08exS+4uhwP1YNOjJTRvRNcO9ZqHb46d4fmyJ/yC9/susCge7r/EsbaN5C3afv1dzybuq912FwaQElZLYYp5BICudFOMZ9k0UDMfKM/PMDkH7WexoGHr9GKq/bgCH2B39TZZyHKU6Uy47lXep2s6h0DrMwHOrnmiL3DZjOj88Ynvphlzxuo4eOlD2UHia2+nvIaISYs29Pr0DAvREutchvcBpExj1kWWPv7hQYrv8F0NAdatsbWl3w+xKyfiMKo1USlrwyJviypGtQtXOJyw0XPN0rv2+L5lW8BbjpzHfYYN13fJTedlGTFhhkzVtbbPAKE02kx7zCJcjYaiexdSTsrDLScYNT9/Jhdt27KpsooehwVohLfSKz4vbFfRu2MPZw3/+c/hfiJNgtz6esWbnxGrcE8U2IwPYCaK+Ghk4DcqWNIni59RI5B5kAsQOToII40qPN510uTgxBSPO7q7MHgkxdd4CqBq+ojr9j0P7oao8E5Y+CBDJrojDoCh1oCCDW9vo2dXlVcD8SIbw7U/9AfvEbA4xyE/5md1M7CIwLnWs2Ynv0YtaKoqhdS9x6FmHlMDhN/DKHinrwmowtrTT82fOkpO5g9saSmgU7Qy3gLt8t+VwdEyeFeQUKRSyci8qgqXQaZIg4+aXgaSOnlCFMtmB8ekYxEhTY5uzRfrNgS4s1QeqFBpNtUF+Ydi297pbVXnJoXAN+SVWd80GCx+yI2dpVC89k3rOWK9WeyqlnzuLJWp2RIOB9cdW8GFv/fN+QAJpYeVxOE4+nZDsKnsj8nKcg9t4Dlx1G6gLM1/Vq9YxNLbuzuRC0asUYvdMnoMvszmpm++TxndYisgNYscpZSoz7wvcazJNEPfhPVjEkd6tUUuN4GM35H0DmKCUQNT+a6B6hmHlTZvjxiyGAg5bY59hdjvJ+22QduazlEEC6LI3HrA7uK0TpplWzS1tCIFvTMUhj65DEZmNJ2+ZY9bQ4vsMf+DRR3OOG4t+DMlNfjOd3zNv3QoY95BjfWpryFwPzDq7bCP67JDsoj7j2TY5FRSrRkD77H0Ewlux2cWfjRTwcMHcdQxxuV0OP0aNjGDjybFN"}',
+                },
+                {
+                    id: '6424c353eaf78d000766e96137d4404b',
+                    source: 'backup',
+                    type: 'tss',
+                    commonKeychain: '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781',
+                    encryptedPrv: '{"iv":"vi0dPef/Rx7kG/pRySQi6Q==","v":1,"iter":10000,"ks":256,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"9efhQsiEvVs=","ct":"Gw6atvf6gxKzsjtl3xseipO3rAxp1mAz7Yu1ihFsi5/lf2vMZegApgZx+pyILFS9KKLHbNF3U6WgSYdrr2t4vzdLsXkH1WIxfHS+cd2C5N59yADZDnPJBT6pv/IRvaYelP0Ck3nIYQ2hSMm8op+VOWC/SzHeh7slYDqwEHTGan0Wigfvk1yRd7CCJTaEAomnc/4eFi2NY3X3gt/3opy9IAgknnwUFohn96EWpEQ0F6pbzH/Z8VF6gF+DUcrrByAxExUPnHQZiFk3YHU/vVV4FxBU/mVAE8xBsBn5ul5e5SUMPfc7TBuJWv4BByTNg9xDShF/91Yx2nbfUm5d9QmM8lpKgzzQvcK8POAPk87gRCuKnsGh5vNS0UppkHc+ocfzRQlGA6jze7QyyQO0rMj5Ly8kWjwk2vISvKYHYS1NR7VU549UIXo7NXjatunKSc3+IreoRUHIshiaLg6hl+pxCCuc0qQ43V0mdIfCjTN8gkGWLNk8R7tAGPz9jyapQPcPEGHgEz0ATIi6yMNWCsibS2eLiE1uVEJONoM4lk6FPl3Q2CHbW2MeEbqjY8hbaw18mNb2xSBH/Fwpiial+Tvi2imqgnCO4ZpO9bllKftZPcQy0stN+eGBlb5ufyflKkDSiChHYroGjEpmiFicdde48cJszF52uKNnf1q67fA9/S2FAHQab3EXojxH2Gbk+kkV2h/TYKFFZSWC3vi4e8mO+vjMUcR0AdsgPFyEIz0SCGuba3CnTLNdEuZwsauAeHkx2vUTnRgJPVgNeeuXmsVG76Sy2ggJHuals0Hj8U2Xda0qO1RuFfoCWfss9wn6HGRwPPkhSB/8oNguAqmRVGKkd8Zwt3IvrTd9fk0/rFFDJKGz7WyNHkYgUmNiGcItD12v0jx7FZ52EJzl3Av1RyJUQK18+8EYPh3SGiU9dt7VX0aF0uo6JouKhOeldUvMP+AugQz8fUclwTQsbboVg27Yxo0DyATVwThW5a56R6Qf5ZiQJluFuzs5y98rq0S5q046lE6o3vVmJpEdwjeSCJoET5CL4nTgkXyWvhm4eB8u/e66l3o0qbaSx8q9YYmT9EpRcl5TP4ThLBKETYdzVvg4exjQfektMatk5EyUpEIhZPXh5vXpJZesdfO9LJ8zTaHBsBjDPU7cdNgQMbebpataRi8A0el2/IJXl+E+olgAz5zC4i2O1Q=="}',
+                },
+                {
+                    id: '6424c353eaf78d000766e9510b125fba',
+                    source: 'bitgo',
+                    type: 'tss',
+                    commonKeychain: '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781',
+                    verifiedVssProof: true,
+                    isBitGo: true,
+                },
+            ];
+        });
+        it('should return true when validating a well formatted address', async function () {
+            const address = 'UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi';
+            basecoin.isValidAddress(address).should.equal(true);
+        });
+        it('should return false when validating an incorrectly formatted', async function () {
+            const address = 'wrongaddress';
+            basecoin.isValidAddress(address).should.equal(false);
+        });
+        it('should return true when validating a non-bounceable address format', async function () {
+            const address = 'UQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBX1aD';
+            basecoin.isValidAddress(address).should.equal(true);
+        });
+        it('should return true when validating addresses with memoIds', async function () {
+            const address1 = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n?memoId=123';
+            const address2 = 'UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi?memoId=123';
+            basecoin.isValidAddress(address1).should.equal(true);
+            basecoin.isValidAddress(address2).should.equal(true);
+        });
+        it('should return true for isWalletAddress with valid address for index 4', async function () {
+            const newAddress = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n';
+            const index = 4;
+            const params = { commonKeychain, address: newAddress, index, keychains };
+            (await basecoin.isWalletAddress(params)).should.equal(true);
+        });
+        it('should return true for isWalletAddress with valid addressand index', async function () {
+            const newAddress = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n?memoId=4';
+            const index = 4;
+            const params = { commonKeychain, address: newAddress, index, keychains };
+            (await basecoin.isWalletAddress(params)).should.equal(true);
+        });
+        it('should return false for isWalletAddress with valid address for index 5 and address is for a different index', async function () {
+            const wrongAddressForIndex5 = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n';
+            const index = 5;
+            const params = { commonKeychain, address: wrongAddressForIndex5, index, keychains };
+            (await basecoin.isWalletAddress(params)).should.equal(false);
+        });
+        it('should throw error for isWalletAddress when keychains is missing', async function () {
+            const address = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n';
+            const index = 0;
+            const params = { commonKeychain, address, index };
+            await assert_1.default.rejects(async () => basecoin.isWalletAddress(params));
+        });
+        it('should throw error for isWalletAddress when new address is invalid', async function () {
+            const wrongAddress = 'badAddress';
+            const index = 0;
+            const params = { commonKeychain, address: wrongAddress, index };
+            await assert_1.default.rejects(async () => basecoin.isWalletAddress(params), {
+                message: `invalid address: ${wrongAddress}`,
+            });
+        });
+    });
+    describe('util class ', () => {
+        let commonKeychain;
+        let derivedPublicKey;
+        before(async function () {
+            commonKeychain =
+                '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781';
+            const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+            derivedPublicKey = MPC.deriveUnhardened(commonKeychain, 'm/' + 0).slice(0, 64);
+        });
+        describe('getAddressFromPublicKey', function () {
+            it('should derive bounceable address by default', async function () {
+                (await utils_1.default.getAddressFromPublicKey(derivedPublicKey)).should.equal('EQDVeyUJOx3AnZGWLtE0l-Vxv7c7uTnD8OXtCFhaO-nvavQ5');
+                (await utils_1.default.getAddressFromPublicKey(derivedPublicKey, true)).should.equal('EQDVeyUJOx3AnZGWLtE0l-Vxv7c7uTnD8OXtCFhaO-nvavQ5');
+            });
+            it('should derive non-bounceable address when requested', async function () {
+                (await utils_1.default.getAddressFromPublicKey(derivedPublicKey, false)).should.equal('UQDVeyUJOx3AnZGWLtE0l-Vxv7c7uTnD8OXtCFhaO-nvaqn8');
+            });
+            it('should derive raw address when requested', async function () {
+                (await utils_1.default.getAddressFromPublicKey(derivedPublicKey, false, false)).should.equal('0:d57b25093b1dc09d91962ed13497e571bfb73bb939c3f0e5ed08585a3be9ef6a');
+            });
+        });
+        describe('getAddress', function () {
+            it('should return address as per bounceable flag', function () {
+                should_1.default.equal(utils_1.default.getAddress('UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi', false), 'UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi');
+                should_1.default.equal(utils_1.default.getAddress('UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi', true), 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n');
+                should_1.default.equal(utils_1.default.getAddress('EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n', true), 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n');
+                should_1.default.equal(utils_1.default.getAddress('EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n', false), 'UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi');
+            });
+        });
+        it('should validate block hash', async function () {
+            should_1.default.equal(utils_1.default.isValidBlockId('MPuOvHdu/z+t2l82YpZtiJQk8+FVKmWuKxd6ubn09fI='), true);
+            should_1.default.equal(utils_1.default.isValidBlockId('MPuOvHdu/z+t2l82YpZtiJQk8+FVKmWuKxd'), false);
+            should_1.default.equal(utils_1.default.isValidBlockId(''), false);
+        });
+        it('should validate transaction id', async function () {
+            should_1.default.equal(utils_1.default.isValidTransactionId('wlTdDOAXwJp8ESRfQAEJQIn0Tci_S5oLbVKBYxDtvpk='), true);
+            should_1.default.equal(utils_1.default.isValidTransactionId('3sykx6Rujy7UtBwHQ/X5kLgvKE0SKLA+ABiCKi7sX8o='), true); // No url friendly txid
+            should_1.default.equal(utils_1.default.isValidTransactionId('3sykx6Rujy7UtBwHQ_X5kLgvKE0SKLA-ABiCKi7sX8o='), true); // Url friendly txid
+            should_1.default.equal(utils_1.default.isValidTransactionId('wlTdDOAXwJp8ESRfQAEJQIn0Tci_S5oLb='), false);
+            should_1.default.equal(utils_1.default.isValidTransactionId('wlTdDOAXwJp8ESRfQAEJQIn0Tci_S5oLbVKBYxDtafdsasdadsfvpk='), false);
+            should_1.default.equal(utils_1.default.isValidTransactionId(''), false);
+        });
+        it('should generate transaction id', async function () {
+            const id = await utils_1.default.getMessageHashFromData('te6cckECCgEAAkoAA7V2k4Vw1nhxr7XcCBjWcFFHKqGwCglPSRuYAkWjWiTVAIAAAPbLgva0G7ytKw/xeE9a3FHK2RM8fgOpGvTpQRseeMer3efRKsiQAADxPhnaQFZWYrlQADRqbCUIAQIDAgHgBAUAgnIAZ0UIwmknkMaW7QboTcq48FfZ1NT5oMUj2VPOBr3zPoxriab4SfV65i6Hd1J2sFsuTcIWUobcKXMcIys+JWknAhMMwSvWBhmTzwRACAkB4YgA0nCuGs8ONfa7gQMazgoo5VQ2AUEp6SNzAEi0a0SaoBAHHgnPJBQQJ/meoCwzK5/PajBSxuJK2Gkva7NmlALNDs2IMEWi4ZRfIV4VeJpKBhzhKjNlFjuz60g+aeT5cNi4CU1NGLsrey/4AAAAGAAcBgEB3wcAaGIAK2cYdYCtxtBaWJ9hi7N+HVzeMsPQxLHSqYn7bfpOcRyh3NZQAAAAAAAAAAAAAAAAAAAAsWgA0nCuGs8ONfa7gQMazgoo5VQ2AUEp6SNzAEi0a0SaoBEAFbOMOsBW42gtLE+wxdm/Dq5vGWHoYljpVMT9tv0nOI5Q7msoAAYUWGAAAB7ZcF7WhMrMVypAAJ1BnYMTiAAAAAAAAAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAG/Jh6EgTBRYQAAAAAAAAgAAAAAAA4E52AP/eAYnVhJkoII4YUrhpLfpDFt6mRKiktbFnqs+QFAWDAAacQ0=\\');
+            should_1.default.equal(id, 'TsVgNKT05cde4Q54sC+RFC7nToTrHk9ppGgE5M0jXtE=');
+        });
+        it('should deserialize a cell to get the address', function () {
+            const data1 = 'te6cckEBAQEAJAAAQ4AaFUTgUQ/k2i+DdAooib0wNVREZQ2z+8R9WQvvFNpUJBARyAgK';
+            const rawAddress1 = '0:d0aa2702887f26d17c1ba051444de981aaa223286d9fde23eac85f78a6d2a120';
+            should_1.default.equal(utils_1.default.getRawWalletAddressFromCell(data1), rawAddress1);
+            const data2 = 'te6cckEBAQEAJAAAQ5/75w034qP9T0ZXY3muM5ouvFlNoNPky2YUs+Hcxd8otjDkIOPq';
+            const rawAddress2 = '-1:df3869bf151fea7a32bb1bcd719cd175e2ca6d069f265b30a59f0ee62ef945b1';
+            should_1.default.equal(utils_1.default.getRawWalletAddressFromCell(data2), rawAddress2);
+        });
+    });
+    describe('Ton recover - Non-BitGo and Unsigned Sweep Transactions', function () {
+        let sandbox;
+        beforeEach(() => {
+            sandbox = sinon.createSandbox(); // Create a new sandbox for each test
+        });
+        afterEach(() => {
+            sandbox.restore(); // Restore all stubs after each test
+        });
+        it('should successfully recover funds for non-BitGo recovery', async function () {
+            // Define recovery parameters
+            const recoveryParams = {
+                bitgoKey: '1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9dae1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857',
+                recoveryDestination: 'UQBL2idCXR4ATdQtaNa4VpofcpSxuxIgHH7_slOZfdOXSadJ',
+                apiKey: 'db2554641c61e60a979cc6c0053f2ec91da9b13e71d287768c93c2fb556be53b',
+                userKey: '1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9dae1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857',
+                walletPassphrase: 'dummyPassphrase',
+            };
+            // Mock the expected result for non-BitGo recovery
+            const mockResult = {
+                serializedTx: 'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=',
+                scanIndex: 0,
+                coin: 'tton',
+            };
+            // Stub the recover function to return the mocked result
+            const sandbox = sinon.createSandbox();
+            sandbox.stub(basecoin, 'recover').resolves(mockResult);
+            // Call the recover function
+            const result = await basecoin.recover(recoveryParams);
+            // Validate the result
+            result.serializedTx.should.equal('te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=');
+            result.scanIndex.should.equal(0);
+            result.coin.should.equal('tton');
+            sandbox.restore(); // Restore the stubbed method
+        });
+        it('should return an unsigned sweep transaction if userKey and backupKey are missing', async function () {
+            // Define recovery parameters
+            const recoveryParams = {
+                bitgoKey: '1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9dae1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857',
+                recoveryDestination: 'UQBL2idCXR4ATdQtaNa4VpofcpSxuxIgHH7_slOZfdOXSadJ',
+                apiKey: 'db2554641c61e60a979cc6c0053f2ec91da9b13e71d287768c93c2fb556be53b',
+            };
+            // Mock the expected result for unsigned sweep transaction
+            const mockUnsignedTx = {
+                serializedTx: 'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=',
+                scanIndex: 0,
+                coin: 'tton',
+                signableHex: 'dd98eb5a3700c0203237095ca1c0d5288bc0d650a9b59f7b81bac552f76137df',
+                derivationPath: 'm/0',
+                parsedTx: {
+                    inputs: [
+                        {
+                            address: 'UQBL2idCXR4ATdQtaNa4VpofcpSxuxIgHH7_slOZfdOXSadJ',
+                            valueString: '1000000000',
+                            value: 1000000000,
+                        },
+                    ],
+                    outputs: [
+                        {
+                            address: 'UQBL2idCXR4ATdQtaNa4VpofcpSxuxIgHH7_slOZfdOXSadJ',
+                            valueString: '999000000',
+                            coinName: 'tton',
+                        },
+                    ],
+                    spendAmount: 999000000,
+                    type: '',
+                },
+                feeInfo: {
+                    fee: 1000000,
+                    feeString: '1000000',
+                },
+                coinSpecific: {
+                    commonKeychain: '1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9dae1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857',
+                },
+            };
+            const mockTxRequest = {
+                transactions: [
+                    {
+                        unsignedTx: mockUnsignedTx,
+                        signatureShares: [],
+                    },
+                ],
+                walletCoin: 'ton',
+            };
+            const mockTxRequests = {
+                txRequests: [mockTxRequest],
+            };
+            // Stub the recover function to return the mocked unsigned sweep transaction
+            const sandbox = sinon.createSandbox();
+            sandbox.stub(basecoin, 'recover').resolves(mockTxRequests);
+            // Call the recover function
+            const result = await basecoin.recover(recoveryParams);
+            // Validate the result
+            result.should.have.property('txRequests');
+            result.txRequests[0].should.have.property('transactions');
+            result.txRequests[0].transactions[0].should.have.property('unsignedTx');
+            result.txRequests[0].transactions[0].unsignedTx.should.equal(mockUnsignedTx);
+        });
+        it('should take OVC output and generate a signed sweep transaction', async function () {
+            // Define the parameters (mock OVC response)
+            const params = {
+                ovcResponse: {
+                    serializedTx: 'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=',
+                    scanIndex: 0,
+                    lastScanIndex: 0,
+                },
+            };
+            // Mock the expected result for the signed sweep transaction
+            const mockSignedSweepTxn = {
+                transactions: [
+                    {
+                        serializedTx: 'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=',
+                        scanIndex: 0,
+                    },
+                ],
+                lastScanIndex: 0,
+            };
+            // Stub the createBroadcastableSweepTransaction function to return the mocked result
+            sandbox.stub(basecoin, 'createBroadcastableSweepTransaction').resolves(mockSignedSweepTxn);
+            // Call the createBroadcastableSweepTransaction function
+            const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);
+            // Validate the result
+            recoveryTxn.transactions[0].serializedTx.should.equal('te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=');
+            recoveryTxn.transactions[0].scanIndex.should.equal(0);
+            recoveryTxn.lastScanIndex.should.equal(0);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ton.js","sourceRoot":"","sources":["../../../test/unit/ton.ts"],"names":[],"mappings":"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","sourcesContent":["import { TestBitGo } from '@bitgo/sdk-test';\nimport { BitGoAPI } from '@bitgo/sdk-api';\nimport { Ton, TonParseTransactionOptions, Tton } from '../../src';\nimport * as sinon from 'sinon';\nimport assert from 'assert';\nimport * as testData from '../resources/ton';\nimport { EDDSAMethods, TransactionExplanation } from '@bitgo/sdk-core';\nimport should from 'should';\nimport utils from '../../src/lib/utils';\nimport Tonweb from 'tonweb';\n\ndescribe('TON:', function () {\n  let basecoin;\n  const bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n  bitgo.safeRegister('ton', Ton.createInstance);\n  bitgo.safeRegister('tton', Tton.createInstance);\n  bitgo.initializeTestVars();\n  const txPrebuildList = [\n    {\n      txHex: Buffer.from(testData.signedSendTransaction.tx, 'base64').toString('hex'),\n      txInfo: {},\n    },\n    {\n      txHex: Buffer.from(testData.signedSingleNominatorWithdrawTransaction.tx, 'base64').toString('hex'),\n      txInfo: {},\n    },\n  ];\n  const txPrebuildBounceableList = [\n    {\n      txHex: Buffer.from(testData.signedSendTransaction.txBounceable, 'base64').toString('hex'),\n      txInfo: {},\n    },\n    {\n      txHex: Buffer.from(testData.signedSingleNominatorWithdrawTransaction.txBounceable, 'base64').toString('hex'),\n      txInfo: {},\n    },\n  ];\n\n  const txParamsList = [\n    {\n      recipients: [testData.signedSendTransaction.recipient],\n    },\n    {\n      recipients: [testData.signedSingleNominatorWithdrawTransaction.recipient],\n    },\n  ];\n\n  const txParamsBounceableList = [\n    {\n      recipients: [testData.signedSendTransaction.recipientBounceable],\n    },\n    {\n      recipients: [testData.signedSingleNominatorWithdrawTransaction.recipientBounceable],\n    },\n  ];\n\n  it('should return the right info', function () {\n    const ton = bitgo.coin('ton');\n    const tton = bitgo.coin('tton');\n\n    ton.getChain().should.equal('ton');\n    ton.getFamily().should.equal('ton');\n    ton.getFullName().should.equal('Ton');\n    ton.getBaseFactor().should.equal(1e9);\n\n    tton.getChain().should.equal('tton');\n    tton.getFamily().should.equal('ton');\n    tton.getFullName().should.equal('Testnet Ton');\n    tton.getBaseFactor().should.equal(1e9);\n  });\n\n  describe('Verify transaction: ', () => {\n    basecoin = bitgo.coin('tton');\n    txParamsList.forEach((_, index) => {\n      const txParams = txParamsList[index];\n      const txPrebuild = txPrebuildList[index];\n      const txParamsBounceable = txParamsBounceableList[index];\n      const txPrebuildBounceable = txPrebuildBounceableList[index];\n\n      it('should succeed to verify transaction', async function () {\n        const verification = {};\n        const isTransactionVerified = await basecoin.verifyTransaction({\n          txParams,\n          txPrebuild,\n          verification,\n        } as any);\n        isTransactionVerified.should.equal(true);\n\n        const isBounceableTransactionVerified = await basecoin.verifyTransaction({\n          txParams: txParamsBounceable,\n          txPrebuild: txPrebuildBounceable,\n          verification: {},\n        } as any);\n        isBounceableTransactionVerified.should.equal(true);\n      });\n\n      it('should succeed to verify transaction when recipients amount are numbers', async function () {\n        const txParamsWithNumberAmounts = JSON.parse(JSON.stringify(txParams));\n        txParamsWithNumberAmounts.recipients[0].amount = 20000000;\n        const verification = {};\n        await basecoin\n          .verifyTransaction({\n            txParams: txParamsWithNumberAmounts,\n            txPrebuild,\n            verification,\n          } as any)\n          .should.rejectedWith('Tx outputs does not match with expected txParams recipients');\n      });\n\n      it('should succeed to verify transaction when recipients amount are strings', async function () {\n        const txParamsWithNumberAmounts = JSON.parse(JSON.stringify(txParams));\n        txParamsWithNumberAmounts.recipients[0].amount = '20000000';\n        const verification = {};\n        await basecoin\n          .verifyTransaction({\n            txParams: txParamsWithNumberAmounts,\n            txPrebuild,\n            verification,\n          } as any)\n          .should.rejectedWith('Tx outputs does not match with expected txParams recipients');\n      });\n\n      it('should succeed to verify transaction when recipients amounts are number and amount is same', async function () {\n        const verification = {};\n        await basecoin\n          .verifyTransaction({\n            txParams,\n            txPrebuild,\n            verification,\n          } as any)\n          .should.resolvedWith(true);\n      });\n\n      it('should succeed to verify transaction when recipients amounts are string and amount is same', async function () {\n        const verification = {};\n        await basecoin\n          .verifyTransaction({\n            txParams,\n            txPrebuild,\n            verification,\n          } as any)\n          .should.resolvedWith(true);\n      });\n\n      it('should succeed to verify transaction when recipient address are non bounceable', async function () {\n        const txParamsWithNumberAmounts = JSON.parse(JSON.stringify(txParams));\n        txParamsWithNumberAmounts.recipients[0].address = new Tonweb.Address(\n          txParamsWithNumberAmounts.recipients[0].address\n        ).toString(true, true, false);\n        const verification = {};\n        const isVerified = await basecoin.verifyTransaction({\n          txParams: txParamsWithNumberAmounts,\n          txPrebuild,\n          verification,\n        } as any);\n        isVerified.should.equal(true);\n      });\n\n      it('should fail to verify transaction with invalid param', async function () {\n        const txPrebuild = {};\n        await basecoin\n          .verifyTransaction({\n            txParams,\n            txPrebuild,\n          } as any)\n          .should.rejectedWith('missing required tx prebuild property txHex');\n      });\n    });\n\n    it('should succeed to verify transaction with recipient having memo', async function () {\n      const txParams = {\n        recipients: [testData.signedSendTransactionForMemoId.recipient],\n      };\n      const txPrebuild = {\n        txHex: Buffer.from(testData.signedSendTransactionForMemoId.tx, 'base64').toString('hex'),\n        txInfo: {},\n      };\n      const verification = {};\n      const isTransactionVerified = await basecoin.verifyTransaction({\n        txParams,\n        txPrebuild,\n        verification,\n      } as any);\n      isTransactionVerified.should.equal(true);\n    });\n  });\n\n  describe('Explain Transaction: ', () => {\n    const basecoin = bitgo.coin('tton');\n    it('should explain a transfer transaction', async function () {\n      const explainedTransaction = (await basecoin.explainTransaction({\n        txHex: Buffer.from(testData.signedSendTransaction.tx, 'base64').toString('hex'),\n      })) as TransactionExplanation;\n      explainedTransaction.should.deepEqual({\n        displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],\n        id: 'tuyOkyFUMv_neV_FeNBH24Nd4cML2jUgDP4zjGkuOFI=',\n        outputs: [\n          {\n            address: testData.signedSendTransaction.recipient.address,\n            amount: testData.signedSendTransaction.recipient.amount,\n          },\n        ],\n        outputAmount: testData.signedSendTransaction.recipient.amount,\n        changeOutputs: [],\n        changeAmount: '0',\n        fee: { fee: 'UNKNOWN' },\n        withdrawAmount: undefined,\n      });\n    });\n\n    it('should explain a non-bounceable transfer transaction', async function () {\n      const explainedTransaction = (await basecoin.explainTransaction({\n        txHex: Buffer.from(testData.signedSendTransaction.tx, 'base64').toString('hex'),\n        toAddressBounceable: false,\n        fromAddressBounceable: false,\n      })) as TransactionExplanation;\n      explainedTransaction.should.deepEqual({\n        displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],\n        id: 'tuyOkyFUMv_neV_FeNBH24Nd4cML2jUgDP4zjGkuOFI=',\n        outputs: [\n          {\n            address: testData.signedSendTransaction.recipientBounceable.address,\n            amount: testData.signedSendTransaction.recipientBounceable.amount,\n          },\n        ],\n        outputAmount: testData.signedSendTransaction.recipientBounceable.amount,\n        changeOutputs: [],\n        changeAmount: '0',\n        fee: { fee: 'UNKNOWN' },\n        withdrawAmount: undefined,\n      });\n    });\n\n    it('should explain a single nominator withdraw transaction', async function () {\n      const explainedTransaction = (await basecoin.explainTransaction({\n        txHex: Buffer.from(testData.signedSingleNominatorWithdrawTransaction.tx, 'base64').toString('hex'),\n      })) as TransactionExplanation;\n      explainedTransaction.should.deepEqual({\n        displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],\n        id: testData.signedSingleNominatorWithdrawTransaction.txId,\n        outputs: [\n          {\n            address: testData.signedSingleNominatorWithdrawTransaction.recipient.address,\n            amount: testData.signedSingleNominatorWithdrawTransaction.recipient.amount,\n          },\n        ],\n        outputAmount: testData.signedSingleNominatorWithdrawTransaction.recipient.amount,\n        changeOutputs: [],\n        changeAmount: '0',\n        fee: { fee: 'UNKNOWN' },\n        withdrawAmount: '932178112330000',\n      });\n    });\n\n    it('should explain a non-bounceable single nominator withdraw transaction', async function () {\n      const explainedTransaction = (await basecoin.explainTransaction({\n        txHex: Buffer.from(testData.signedSingleNominatorWithdrawTransaction.tx, 'base64').toString('hex'),\n        toAddressBounceable: false,\n        fromAddressBounceable: false,\n      })) as TransactionExplanation;\n      explainedTransaction.should.deepEqual({\n        displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],\n        id: testData.signedSingleNominatorWithdrawTransaction.txIdBounceable,\n        outputs: [\n          {\n            address: testData.signedSingleNominatorWithdrawTransaction.recipientBounceable.address,\n            amount: testData.signedSingleNominatorWithdrawTransaction.recipientBounceable.amount,\n          },\n        ],\n        outputAmount: testData.signedSingleNominatorWithdrawTransaction.recipientBounceable.amount,\n        changeOutputs: [],\n        changeAmount: '0',\n        fee: { fee: 'UNKNOWN' },\n        withdrawAmount: '932178112330000',\n      });\n    });\n\n    it('should fail to explain transaction with missing params', async function () {\n      try {\n        await basecoin.explainTransaction({});\n      } catch (error) {\n        should.equal(error.message, 'Invalid transaction');\n      }\n    });\n\n    it('should fail to explain transaction with invalid params', async function () {\n      try {\n        await basecoin.explainTransaction({ txHex: 'randomString' });\n      } catch (error) {\n        should.equal(error.message, 'Invalid transaction');\n      }\n    });\n  });\n\n  describe('Parse Transactions: ', () => {\n    const basecoin = bitgo.coin('tton');\n\n    const transactionsList = [testData.signedSendTransaction.tx, testData.signedSingleNominatorWithdrawTransaction.tx];\n\n    const transactionInputsResponseList = [\n      [\n        {\n          address: 'EQCSBjR3fUOL98WTw2F_IT4BrcqjZJWVLWUSz5WQDpaL9Jpl',\n          amount: '10000000',\n        },\n      ],\n      [\n        {\n          address: 'EQAbJug-k-tufWMjEC1RKSM0iiJTDUcYkC7zWANHrkT55Fol',\n          amount: '123400000',\n        },\n      ],\n    ];\n\n    const transactionInputsResponseBounceableList = [\n      [\n        {\n          address: 'UQCSBjR3fUOL98WTw2F_IT4BrcqjZJWVLWUSz5WQDpaL9Meg',\n          amount: '10000000',\n        },\n      ],\n      [\n        {\n          address: 'UQAbJug-k-tufWMjEC1RKSM0iiJTDUcYkC7zWANHrkT55Afg',\n          amount: '123400000',\n        },\n      ],\n    ];\n\n    const transactionOutputsResponseList = [\n      [\n        {\n          address: 'EQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBXwtG',\n          amount: '10000000',\n        },\n      ],\n      [\n        {\n          address: 'EQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBXwtG',\n          amount: '123400000',\n        },\n      ],\n    ];\n\n    const transactionOutputsResponseBounceableList = [\n      [\n        {\n          address: 'UQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBX1aD',\n          amount: '10000000',\n        },\n      ],\n      [\n        {\n          address: 'UQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBX1aD',\n          amount: '123400000',\n        },\n      ],\n    ];\n\n    transactionsList.forEach((_, index) => {\n      const transaction = transactionsList[index];\n      const transactionInputsResponse = transactionInputsResponseList[index];\n      const transactionInputsResponseBounceable = transactionInputsResponseBounceableList[index];\n      const transactionOutputsResponse = transactionOutputsResponseList[index];\n      const transactionOutputsResponseBounceable = transactionOutputsResponseBounceableList[index];\n\n      it('should parse a TON transaction', async function () {\n        const parsedTransaction = await basecoin.parseTransaction({\n          txHex: Buffer.from(transaction, 'base64').toString('hex'),\n        });\n\n        parsedTransaction.should.deepEqual({\n          inputs: transactionInputsResponse,\n          outputs: transactionOutputsResponse,\n        });\n      });\n\n      it('should parse a non-bounceable TON transaction', async function () {\n        const parsedTransaction = await basecoin.parseTransaction({\n          txHex: Buffer.from(transaction, 'base64').toString('hex'),\n          toAddressBounceable: false,\n          fromAddressBounceable: false,\n        } as TonParseTransactionOptions);\n\n        parsedTransaction.should.deepEqual({\n          inputs: transactionInputsResponseBounceable,\n          outputs: transactionOutputsResponseBounceable,\n        });\n      });\n\n      it('should fail to parse a TON transaction when explainTransaction response is undefined', async function () {\n        const stub = sinon.stub(Ton.prototype, 'explainTransaction');\n        stub.resolves(undefined);\n        await basecoin.parseTransaction({ txHex: transaction }).should.be.rejectedWith('invalid raw transaction');\n        stub.restore();\n      });\n    });\n  });\n\n  describe('Address Validation', () => {\n    const basecoin = bitgo.coin('tton');\n    let keychains;\n    let commonKeychain;\n\n    before(function () {\n      commonKeychain =\n        '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781';\n      keychains = [\n        {\n          id: '6424c353eaf78d000766e95949868468',\n          source: 'user',\n          type: 'tss',\n          commonKeychain:\n            '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781',\n          encryptedPrv:\n            '{\"iv\":\"cZd5i7L4RxtwrALW2rK7UA==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"5zgoH1Bd3Fw=\",\"ct\":\"9vVlnXFRtrM9FVEo+d2chbGHlM9lFZemueBuAs3BIkPo33Fo7jzwwNK/kIWkEyg+NmEBd5IaqAS157nvvvwzzsmMWlQdUz9qbmXNv3pg987cXFR08exS+4uhwP1YNOjJTRvRNcO9ZqHb46d4fmyJ/yC9/susCge7r/EsbaN5C3afv1dzybuq912FwaQElZLYYp5BICudFOMZ9k0UDMfKM/PMDkH7WexoGHr9GKq/bgCH2B39TZZyHKU6Uy47lXep2s6h0DrMwHOrnmiL3DZjOj88Ynvphlzxuo4eOlD2UHia2+nvIaISYs29Pr0DAvREutchvcBpExj1kWWPv7hQYrv8F0NAdatsbWl3w+xKyfiMKo1USlrwyJviypGtQtXOJyw0XPN0rv2+L5lW8BbjpzHfYYN13fJTedlGTFhhkzVtbbPAKE02kx7zCJcjYaiexdSTsrDLScYNT9/Jhdt27KpsooehwVohLfSKz4vbFfRu2MPZw3/+c/hfiJNgtz6esWbnxGrcE8U2IwPYCaK+Ghk4DcqWNIni59RI5B5kAsQOToII40qPN510uTgxBSPO7q7MHgkxdd4CqBq+ojr9j0P7oao8E5Y+CBDJrojDoCh1oCCDW9vo2dXlVcD8SIbw7U/9AfvEbA4xyE/5md1M7CIwLnWs2Ynv0YtaKoqhdS9x6FmHlMDhN/DKHinrwmowtrTT82fOkpO5g9saSmgU7Qy3gLt8t+VwdEyeFeQUKRSyci8qgqXQaZIg4+aXgaSOnlCFMtmB8ekYxEhTY5uzRfrNgS4s1QeqFBpNtUF+Ydi297pbVXnJoXAN+SVWd80GCx+yI2dpVC89k3rOWK9WeyqlnzuLJWp2RIOB9cdW8GFv/fN+QAJpYeVxOE4+nZDsKnsj8nKcg9t4Dlx1G6gLM1/Vq9YxNLbuzuRC0asUYvdMnoMvszmpm++TxndYisgNYscpZSoz7wvcazJNEPfhPVjEkd6tUUuN4GM35H0DmKCUQNT+a6B6hmHlTZvjxiyGAg5bY59hdjvJ+22QduazlEEC6LI3HrA7uK0TpplWzS1tCIFvTMUhj65DEZmNJ2+ZY9bQ4vsMf+DRR3OOG4t+DMlNfjOd3zNv3QoY95BjfWpryFwPzDq7bCP67JDsoj7j2TY5FRSrRkD77H0Ewlux2cWfjRTwcMHcdQxxuV0OP0aNjGDjybFN\"}',\n        },\n        {\n          id: '6424c353eaf78d000766e96137d4404b',\n          source: 'backup',\n          type: 'tss',\n          commonKeychain:\n            '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781',\n          encryptedPrv:\n            '{\"iv\":\"vi0dPef/Rx7kG/pRySQi6Q==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"9efhQsiEvVs=\",\"ct\":\"Gw6atvf6gxKzsjtl3xseipO3rAxp1mAz7Yu1ihFsi5/lf2vMZegApgZx+pyILFS9KKLHbNF3U6WgSYdrr2t4vzdLsXkH1WIxfHS+cd2C5N59yADZDnPJBT6pv/IRvaYelP0Ck3nIYQ2hSMm8op+VOWC/SzHeh7slYDqwEHTGan0Wigfvk1yRd7CCJTaEAomnc/4eFi2NY3X3gt/3opy9IAgknnwUFohn96EWpEQ0F6pbzH/Z8VF6gF+DUcrrByAxExUPnHQZiFk3YHU/vVV4FxBU/mVAE8xBsBn5ul5e5SUMPfc7TBuJWv4BByTNg9xDShF/91Yx2nbfUm5d9QmM8lpKgzzQvcK8POAPk87gRCuKnsGh5vNS0UppkHc+ocfzRQlGA6jze7QyyQO0rMj5Ly8kWjwk2vISvKYHYS1NR7VU549UIXo7NXjatunKSc3+IreoRUHIshiaLg6hl+pxCCuc0qQ43V0mdIfCjTN8gkGWLNk8R7tAGPz9jyapQPcPEGHgEz0ATIi6yMNWCsibS2eLiE1uVEJONoM4lk6FPl3Q2CHbW2MeEbqjY8hbaw18mNb2xSBH/Fwpiial+Tvi2imqgnCO4ZpO9bllKftZPcQy0stN+eGBlb5ufyflKkDSiChHYroGjEpmiFicdde48cJszF52uKNnf1q67fA9/S2FAHQab3EXojxH2Gbk+kkV2h/TYKFFZSWC3vi4e8mO+vjMUcR0AdsgPFyEIz0SCGuba3CnTLNdEuZwsauAeHkx2vUTnRgJPVgNeeuXmsVG76Sy2ggJHuals0Hj8U2Xda0qO1RuFfoCWfss9wn6HGRwPPkhSB/8oNguAqmRVGKkd8Zwt3IvrTd9fk0/rFFDJKGz7WyNHkYgUmNiGcItD12v0jx7FZ52EJzl3Av1RyJUQK18+8EYPh3SGiU9dt7VX0aF0uo6JouKhOeldUvMP+AugQz8fUclwTQsbboVg27Yxo0DyATVwThW5a56R6Qf5ZiQJluFuzs5y98rq0S5q046lE6o3vVmJpEdwjeSCJoET5CL4nTgkXyWvhm4eB8u/e66l3o0qbaSx8q9YYmT9EpRcl5TP4ThLBKETYdzVvg4exjQfektMatk5EyUpEIhZPXh5vXpJZesdfO9LJ8zTaHBsBjDPU7cdNgQMbebpataRi8A0el2/IJXl+E+olgAz5zC4i2O1Q==\"}',\n        },\n        {\n          id: '6424c353eaf78d000766e9510b125fba',\n          source: 'bitgo',\n          type: 'tss',\n          commonKeychain:\n            '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781',\n          verifiedVssProof: true,\n          isBitGo: true,\n        },\n      ];\n    });\n\n    it('should return true when validating a well formatted address', async function () {\n      const address = 'UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi';\n      basecoin.isValidAddress(address).should.equal(true);\n    });\n\n    it('should return false when validating an incorrectly formatted', async function () {\n      const address = 'wrongaddress';\n      basecoin.isValidAddress(address).should.equal(false);\n    });\n\n    it('should return true when validating a non-bounceable address format', async function () {\n      const address = 'UQA0i8-CdGnF_DhUHHf92R1ONH6sIA9vLZ_WLcCIhfBBX1aD';\n      basecoin.isValidAddress(address).should.equal(true);\n    });\n\n    it('should return true when validating addresses with memoIds', async function () {\n      const address1 = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n?memoId=123';\n      const address2 = 'UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi?memoId=123';\n      basecoin.isValidAddress(address1).should.equal(true);\n      basecoin.isValidAddress(address2).should.equal(true);\n    });\n\n    it('should return true for isWalletAddress with valid address for index 4', async function () {\n      const newAddress = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n';\n      const index = 4;\n\n      const params = { commonKeychain, address: newAddress, index, keychains };\n      (await basecoin.isWalletAddress(params)).should.equal(true);\n    });\n\n    it('should return true for isWalletAddress with valid addressand index', async function () {\n      const newAddress = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n?memoId=4';\n      const index = 4;\n\n      const params = { commonKeychain, address: newAddress, index, keychains };\n      (await basecoin.isWalletAddress(params)).should.equal(true);\n    });\n\n    it('should return false for isWalletAddress with valid address for index 5 and address is for a different index', async function () {\n      const wrongAddressForIndex5 = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n';\n      const index = 5;\n\n      const params = { commonKeychain, address: wrongAddressForIndex5, index, keychains };\n      (await basecoin.isWalletAddress(params)).should.equal(false);\n    });\n\n    it('should throw error for isWalletAddress when keychains is missing', async function () {\n      const address = 'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n';\n      const index = 0;\n\n      const params = { commonKeychain, address, index };\n      await assert.rejects(async () => basecoin.isWalletAddress(params));\n    });\n\n    it('should throw error for isWalletAddress when new address is invalid', async function () {\n      const wrongAddress = 'badAddress';\n      const index = 0;\n\n      const params = { commonKeychain, address: wrongAddress, index };\n      await assert.rejects(async () => basecoin.isWalletAddress(params), {\n        message: `invalid address: ${wrongAddress}`,\n      });\n    });\n  });\n\n  describe('util class ', () => {\n    let commonKeychain;\n    let derivedPublicKey;\n    before(async function () {\n      commonKeychain =\n        '19bdfe2a4b498a05511381235a8892d54267807c4a3f654e310b938b8b424ff4adedbe92f4c146de641c67508a961324c8504cdf8e0c0acbb68d6104ccccd781';\n      const MPC = await EDDSAMethods.getInitializedMpcInstance();\n      derivedPublicKey = MPC.deriveUnhardened(commonKeychain, 'm/' + 0).slice(0, 64);\n    });\n\n    describe('getAddressFromPublicKey', function () {\n      it('should derive bounceable address by default', async function () {\n        (await utils.getAddressFromPublicKey(derivedPublicKey)).should.equal(\n          'EQDVeyUJOx3AnZGWLtE0l-Vxv7c7uTnD8OXtCFhaO-nvavQ5'\n        );\n        (await utils.getAddressFromPublicKey(derivedPublicKey, true)).should.equal(\n          'EQDVeyUJOx3AnZGWLtE0l-Vxv7c7uTnD8OXtCFhaO-nvavQ5'\n        );\n      });\n\n      it('should derive non-bounceable address when requested', async function () {\n        (await utils.getAddressFromPublicKey(derivedPublicKey, false)).should.equal(\n          'UQDVeyUJOx3AnZGWLtE0l-Vxv7c7uTnD8OXtCFhaO-nvaqn8'\n        );\n      });\n\n      it('should derive raw address when requested', async function () {\n        (await utils.getAddressFromPublicKey(derivedPublicKey, false, false)).should.equal(\n          '0:d57b25093b1dc09d91962ed13497e571bfb73bb939c3f0e5ed08585a3be9ef6a'\n        );\n      });\n    });\n\n    describe('getAddress', function () {\n      it('should return address as per bounceable flag', function () {\n        should.equal(\n          utils.getAddress('UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi', false),\n          'UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi'\n        );\n        should.equal(\n          utils.getAddress('UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi', true),\n          'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n'\n        );\n        should.equal(\n          utils.getAddress('EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n', true),\n          'EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n'\n        );\n        should.equal(\n          utils.getAddress('EQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFL7n', false),\n          'UQB0Hyt1bTRfI0WK_ULZyKvrvP0PPtpTQFi_jKXVXX6KFOMi'\n        );\n      });\n    });\n\n    it('should validate block hash', async function () {\n      should.equal(utils.isValidBlockId('MPuOvHdu/z+t2l82YpZtiJQk8+FVKmWuKxd6ubn09fI='), true);\n      should.equal(utils.isValidBlockId('MPuOvHdu/z+t2l82YpZtiJQk8+FVKmWuKxd'), false);\n      should.equal(utils.isValidBlockId(''), false);\n    });\n\n    it('should validate transaction id', async function () {\n      should.equal(utils.isValidTransactionId('wlTdDOAXwJp8ESRfQAEJQIn0Tci_S5oLbVKBYxDtvpk='), true);\n      should.equal(utils.isValidTransactionId('3sykx6Rujy7UtBwHQ/X5kLgvKE0SKLA+ABiCKi7sX8o='), true); // No url friendly txid\n      should.equal(utils.isValidTransactionId('3sykx6Rujy7UtBwHQ_X5kLgvKE0SKLA-ABiCKi7sX8o='), true); // Url friendly txid\n      should.equal(utils.isValidTransactionId('wlTdDOAXwJp8ESRfQAEJQIn0Tci_S5oLb='), false);\n      should.equal(utils.isValidTransactionId('wlTdDOAXwJp8ESRfQAEJQIn0Tci_S5oLbVKBYxDtafdsasdadsfvpk='), false);\n      should.equal(utils.isValidTransactionId(''), false);\n    });\n\n    it('should generate transaction id', async function () {\n      const id = await utils.getMessageHashFromData(\n        'te6cckECCgEAAkoAA7V2k4Vw1nhxr7XcCBjWcFFHKqGwCglPSRuYAkWjWiTVAIAAAPbLgva0G7ytKw/xeE9a3FHK2RM8fgOpGvTpQRseeMer3efRKsiQAADxPhnaQFZWYrlQADRqbCUIAQIDAgHgBAUAgnIAZ0UIwmknkMaW7QboTcq48FfZ1NT5oMUj2VPOBr3zPoxriab4SfV65i6Hd1J2sFsuTcIWUobcKXMcIys+JWknAhMMwSvWBhmTzwRACAkB4YgA0nCuGs8ONfa7gQMazgoo5VQ2AUEp6SNzAEi0a0SaoBAHHgnPJBQQJ/meoCwzK5/PajBSxuJK2Gkva7NmlALNDs2IMEWi4ZRfIV4VeJpKBhzhKjNlFjuz60g+aeT5cNi4CU1NGLsrey/4AAAAGAAcBgEB3wcAaGIAK2cYdYCtxtBaWJ9hi7N+HVzeMsPQxLHSqYn7bfpOcRyh3NZQAAAAAAAAAAAAAAAAAAAAsWgA0nCuGs8ONfa7gQMazgoo5VQ2AUEp6SNzAEi0a0SaoBEAFbOMOsBW42gtLE+wxdm/Dq5vGWHoYljpVMT9tv0nOI5Q7msoAAYUWGAAAB7ZcF7WhMrMVypAAJ1BnYMTiAAAAAAAAAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAG/Jh6EgTBRYQAAAAAAAAgAAAAAAA4E52AP/eAYnVhJkoII4YUrhpLfpDFt6mRKiktbFnqs+QFAWDAAacQ0=\\\\'\n      );\n      should.equal(id, 'TsVgNKT05cde4Q54sC+RFC7nToTrHk9ppGgE5M0jXtE=');\n    });\n\n    it('should deserialize a cell to get the address', function () {\n      const data1 = 'te6cckEBAQEAJAAAQ4AaFUTgUQ/k2i+DdAooib0wNVREZQ2z+8R9WQvvFNpUJBARyAgK';\n      const rawAddress1 = '0:d0aa2702887f26d17c1ba051444de981aaa223286d9fde23eac85f78a6d2a120';\n      should.equal(utils.getRawWalletAddressFromCell(data1), rawAddress1);\n\n      const data2 = 'te6cckEBAQEAJAAAQ5/75w034qP9T0ZXY3muM5ouvFlNoNPky2YUs+Hcxd8otjDkIOPq';\n      const rawAddress2 = '-1:df3869bf151fea7a32bb1bcd719cd175e2ca6d069f265b30a59f0ee62ef945b1';\n      should.equal(utils.getRawWalletAddressFromCell(data2), rawAddress2);\n    });\n  });\n\n  describe('Ton recover - Non-BitGo and Unsigned Sweep Transactions', function () {\n    let sandbox: sinon.SinonSandbox;\n    beforeEach(() => {\n      sandbox = sinon.createSandbox(); // Create a new sandbox for each test\n    });\n\n    afterEach(() => {\n      sandbox.restore(); // Restore all stubs after each test\n    });\n\n    it('should successfully recover funds for non-BitGo recovery', async function () {\n      // Define recovery parameters\n      const recoveryParams = {\n        bitgoKey:\n          '1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9dae1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857',\n        recoveryDestination: 'UQBL2idCXR4ATdQtaNa4VpofcpSxuxIgHH7_slOZfdOXSadJ',\n        apiKey: 'db2554641c61e60a979cc6c0053f2ec91da9b13e71d287768c93c2fb556be53b',\n        userKey:\n          '1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9dae1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857',\n        walletPassphrase: 'dummyPassphrase',\n      };\n\n      // Mock the expected result for non-BitGo recovery\n      const mockResult = {\n        serializedTx:\n          'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=',\n        scanIndex: 0,\n        coin: 'tton',\n      };\n\n      // Stub the recover function to return the mocked result\n      const sandbox = sinon.createSandbox();\n      sandbox.stub(basecoin, 'recover').resolves(mockResult);\n\n      // Call the recover function\n      const result = await basecoin.recover(recoveryParams);\n\n      // Validate the result\n      result.serializedTx.should.equal(\n        'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8='\n      );\n      result.scanIndex.should.equal(0);\n      result.coin.should.equal('tton');\n      sandbox.restore(); // Restore the stubbed method\n    });\n\n    it('should return an unsigned sweep transaction if userKey and backupKey are missing', async function () {\n      // Define recovery parameters\n      const recoveryParams = {\n        bitgoKey:\n          '1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9dae1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857',\n        recoveryDestination: 'UQBL2idCXR4ATdQtaNa4VpofcpSxuxIgHH7_slOZfdOXSadJ',\n        apiKey: 'db2554641c61e60a979cc6c0053f2ec91da9b13e71d287768c93c2fb556be53b',\n      };\n\n      // Mock the expected result for unsigned sweep transaction\n      const mockUnsignedTx = {\n        serializedTx:\n          'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=',\n        scanIndex: 0,\n        coin: 'tton',\n        signableHex: 'dd98eb5a3700c0203237095ca1c0d5288bc0d650a9b59f7b81bac552f76137df',\n        derivationPath: 'm/0',\n        parsedTx: {\n          inputs: [\n            {\n              address: 'UQBL2idCXR4ATdQtaNa4VpofcpSxuxIgHH7_slOZfdOXSadJ',\n              valueString: '1000000000',\n              value: 1000000000,\n            },\n          ],\n          outputs: [\n            {\n              address: 'UQBL2idCXR4ATdQtaNa4VpofcpSxuxIgHH7_slOZfdOXSadJ',\n              valueString: '999000000',\n              coinName: 'tton',\n            },\n          ],\n          spendAmount: 999000000,\n          type: '',\n        },\n        feeInfo: {\n          fee: 1000000,\n          feeString: '1000000',\n        },\n        coinSpecific: {\n          commonKeychain:\n            '1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9dae1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857',\n        },\n      };\n\n      const mockTxRequest = {\n        transactions: [\n          {\n            unsignedTx: mockUnsignedTx,\n            signatureShares: [],\n          },\n        ],\n        walletCoin: 'ton',\n      };\n\n      const mockTxRequests = {\n        txRequests: [mockTxRequest],\n      };\n\n      // Stub the recover function to return the mocked unsigned sweep transaction\n      const sandbox = sinon.createSandbox();\n\n      sandbox.stub(basecoin, 'recover').resolves(mockTxRequests);\n\n      // Call the recover function\n      const result = await basecoin.recover(recoveryParams);\n\n      // Validate the result\n      result.should.have.property('txRequests');\n      result.txRequests[0].should.have.property('transactions');\n      result.txRequests[0].transactions[0].should.have.property('unsignedTx');\n      result.txRequests[0].transactions[0].unsignedTx.should.equal(mockUnsignedTx);\n    });\n\n    it('should take OVC output and generate a signed sweep transaction', async function () {\n      // Define the parameters (mock OVC response)\n      const params = {\n        ovcResponse: {\n          serializedTx:\n            'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=',\n          scanIndex: 0,\n          lastScanIndex: 0,\n        },\n      };\n\n      // Mock the expected result for the signed sweep transaction\n      const mockSignedSweepTxn = {\n        transactions: [\n          {\n            serializedTx:\n              'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8=',\n            scanIndex: 0,\n          },\n        ],\n        lastScanIndex: 0,\n      };\n\n      // Stub the createBroadcastableSweepTransaction function to return the mocked result\n      sandbox.stub(basecoin, 'createBroadcastableSweepTransaction').resolves(mockSignedSweepTxn);\n\n      // Call the createBroadcastableSweepTransaction function\n      const recoveryTxn = await basecoin.createBroadcastableSweepTransaction(params);\n\n      // Validate the result\n      recoveryTxn.transactions[0].serializedTx.should.equal(\n        'te6cckEBAgEAqgAB4YgAl7ROhLo8AJuoWtGtcK00PuUpY3YkQDj9/2SnMvunLpIFbl896wlMv7fsUOc+sMHzEl8q3vX5bm6noHginPJKBRznOrO7veIpHIEpiRLbH7/eNdpSsRhvL260JP/fD0vAIU1NGLtABDqAAAAACAAcAQBoQgB/OeiNdLeaL7+O04XuujuChSGrRd7ZnFl2fCd9FXdzAyDOJYCwAAAAAAAAAAAAAAAAAFwXGt8='\n      );\n      recoveryTxn.transactions[0].scanIndex.should.equal(0);\n      recoveryTxn.lastScanIndex.should.equal(0);\n    });\n  });\n});\n"]}