@bitgo/sdk-coin-ton 4.0.4 → 4.0.6

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

@@ -0,0 +1,341 @@
+"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 tonweb_1 = __importDefault(require("tonweb"));
+const should_1 = __importDefault(require("should"));
+const sinon = __importStar(require("sinon"));
+const sdk_test_1 = require("@bitgo/sdk-test");
+const sdk_api_1 = require("@bitgo/sdk-api");
+const src_1 = require("../../src");
+const testData = __importStar(require("../resources/ton"));
+describe('Jetton Tokens', function () {
+    let bitgo;
+    let testnetJettonToken;
+    let mainnetJettonToken;
+    const testnetTokenName = 'tton:ukwny-us';
+    const mainnetTokenName = 'ton:usdt';
+    const txPrebuildList = [
+        {
+            txHex: Buffer.from(testData.signedTokenSendTransaction.tx, 'base64').toString('hex'),
+            txInfo: {},
+        },
+    ];
+    const txPrebuildBounceableList = [
+        {
+            txHex: Buffer.from(testData.signedTokenSendTransaction.txBounceable, 'base64').toString('hex'),
+            txInfo: {},
+        },
+    ];
+    const txParamsList = [
+        {
+            recipients: [testData.signedTokenSendTransaction.recipient],
+        },
+    ];
+    const txParamsBounceableList = [
+        {
+            recipients: [testData.signedTokenSendTransaction.recipientBounceable],
+        },
+    ];
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        src_1.JettonToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {
+            bitgo.safeRegister(name, coinConstructor);
+        });
+        bitgo.initializeTestVars();
+        testnetJettonToken = bitgo.coin(testnetTokenName);
+        mainnetJettonToken = bitgo.coin(mainnetTokenName);
+    });
+    it('should return constants for Testnet Ton token', function () {
+        testnetJettonToken.getChain().should.equal(testnetTokenName);
+        testnetJettonToken.getBaseChain().should.equal('tton');
+        testnetJettonToken.getFullName().should.equal('Ton Token');
+        testnetJettonToken.getBaseFactor().should.equal(1e9);
+        testnetJettonToken.type.should.equal(testnetTokenName);
+        testnetJettonToken.name.should.equal('Test Unknown TokenY-US');
+        testnetJettonToken.coin.should.equal('tton');
+        testnetJettonToken.network.should.equal('Testnet');
+        testnetJettonToken.contractAddress.should.equal('kQD8EQMavE1w6gvgMXUhN8hi7pSk4bKYM-W2dgkNqV54Y16Y');
+        testnetJettonToken.decimalPlaces.should.equal(9);
+    });
+    it('should return constants for Mainnet Ton token', function () {
+        mainnetJettonToken.getChain().should.equal(mainnetTokenName);
+        mainnetJettonToken.getBaseChain().should.equal('ton');
+        mainnetJettonToken.getFullName().should.equal('Ton Token');
+        mainnetJettonToken.getBaseFactor().should.equal(1e6);
+        mainnetJettonToken.type.should.equal(mainnetTokenName);
+        mainnetJettonToken.name.should.equal('Tether USD');
+        mainnetJettonToken.coin.should.equal('ton');
+        mainnetJettonToken.network.should.equal('Mainnet');
+        mainnetJettonToken.contractAddress.should.equal('EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs');
+        mainnetJettonToken.decimalPlaces.should.equal(6);
+    });
+    describe('Verify Jetton transaction: ', () => {
+        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 testnetJettonToken.verifyTransaction({
+                    txParams,
+                    txPrebuild,
+                    verification,
+                });
+                isTransactionVerified.should.equal(true);
+                const isBounceableTransactionVerified = await testnetJettonToken.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 testnetJettonToken
+                    .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 testnetJettonToken
+                    .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 testnetJettonToken
+                    .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 testnetJettonToken
+                    .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 testnetJettonToken.verifyTransaction({
+                    txParams: txParamsWithNumberAmounts,
+                    txPrebuild,
+                    verification,
+                });
+                isVerified.should.equal(true);
+            });
+            it('should fail to verify transaction with invalid param', async function () {
+                const txPrebuild = {};
+                await testnetJettonToken
+                    .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.signedTokenSendTransactionForMemoId.recipient],
+            };
+            const txPrebuild = {
+                txHex: Buffer.from(testData.signedTokenSendTransactionForMemoId.tx, 'base64').toString('hex'),
+                txInfo: {},
+            };
+            const verification = {};
+            const isTransactionVerified = await testnetJettonToken.verifyTransaction({
+                txParams,
+                txPrebuild,
+                verification,
+            });
+            isTransactionVerified.should.equal(true);
+        });
+    });
+    describe('Explain Jetton Transaction: ', () => {
+        it('should explain a jetton transfer transaction', async function () {
+            const explainedTransaction = (await testnetJettonToken.explainTransaction({
+                txHex: Buffer.from(testData.signedTokenSendTransaction.tx, 'base64').toString('hex'),
+            }));
+            explainedTransaction.should.deepEqual({
+                displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],
+                id: testData.signedTokenSendTransaction.txId,
+                outputs: [
+                    {
+                        address: testData.signedTokenSendTransaction.recipient.address,
+                        amount: testData.signedTokenSendTransaction.recipient.amount,
+                    },
+                ],
+                outputAmount: testData.signedTokenSendTransaction.recipient.amount,
+                changeOutputs: [],
+                changeAmount: '0',
+                fee: { fee: 'UNKNOWN' },
+                withdrawAmount: undefined,
+            });
+        });
+        it('should explain a non-bounceable jetton transfer transaction', async function () {
+            const explainedTransaction = (await testnetJettonToken.explainTransaction({
+                txHex: Buffer.from(testData.signedTokenSendTransaction.txBounceable, 'base64').toString('hex'),
+                toAddressBounceable: false,
+                fromAddressBounceable: false,
+            }));
+            explainedTransaction.should.deepEqual({
+                displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],
+                id: testData.signedTokenSendTransaction.txIdBounceable,
+                outputs: [
+                    {
+                        address: testData.signedTokenSendTransaction.recipientBounceable.address,
+                        amount: testData.signedTokenSendTransaction.recipientBounceable.amount,
+                    },
+                ],
+                outputAmount: testData.signedTokenSendTransaction.recipientBounceable.amount,
+                changeOutputs: [],
+                changeAmount: '0',
+                fee: { fee: 'UNKNOWN' },
+                withdrawAmount: undefined,
+            });
+        });
+        it('should fail to explain transaction with missing params', async function () {
+            try {
+                await testnetJettonToken.explainTransaction({});
+            }
+            catch (error) {
+                should_1.default.equal(error.message, 'Invalid transaction');
+            }
+        });
+        it('should fail to explain transaction with invalid params', async function () {
+            try {
+                await testnetJettonToken.explainTransaction({ txHex: 'randomString' });
+            }
+            catch (error) {
+                should_1.default.equal(error.message, 'Invalid transaction');
+            }
+        });
+    });
+    describe('Parse Jetton Transactions: ', () => {
+        const transactionsList = [testData.signedTokenSendTransaction.tx];
+        const transactionInputsResponseList = [
+            [
+                {
+                    address: 'EQCqQzfyg0cZ-8t9v2YoHmFFxG5jgjvQRTZ2yeDjO5z5ZRy9',
+                    amount: testData.tokenRecipients[0].amount,
+                },
+            ],
+        ];
+        const transactionInputsResponseBounceableList = [
+            [
+                {
+                    address: testData.tokenSender.address,
+                    amount: testData.tokenRecipients[0].amount,
+                },
+            ],
+        ];
+        const transactionOutputsResponseList = [
+            [
+                {
+                    address: 'EQB-CM6DF-jpq9XVdiSdefAMU5KC1gpZuYBFp-Q65aUhnx5K',
+                    amount: testData.tokenRecipients[0].amount,
+                },
+            ],
+        ];
+        const transactionOutputsResponseBounceableList = [
+            [
+                {
+                    address: testData.tokenRecipients[0].address,
+                    amount: testData.tokenRecipients[0].amount,
+                },
+            ],
+        ];
+        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 testnetJettonToken.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 testnetJettonToken.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 testnetJettonToken
+                    .parseTransaction({ txHex: transaction })
+                    .should.be.rejectedWith('invalid raw transaction');
+                stub.restore();
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jettonToken.js","sourceRoot":"","sources":["../../../../test/unit/jettonToken.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,oDAA4B;AAC5B,oDAA4B;AAC5B,6CAA+B;AAE/B,8CAA0D;AAC1D,4CAA0C;AAC1C,mCAAyE;AACzE,2DAA6C;AAE7C,QAAQ,CAAC,eAAe,EAAE;IACxB,IAAI,KAAmB,CAAC;IACxB,IAAI,kBAAkB,CAAC;IACvB,IAAI,kBAAkB,CAAC;IACvB,MAAM,gBAAgB,GAAG,eAAe,CAAC;IACzC,MAAM,gBAAgB,GAAG,UAAU,CAAC;IAEpC,MAAM,cAAc,GAAG;QACrB;YACE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,0BAA0B,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YACpF,MAAM,EAAE,EAAE;SACX;KACF,CAAC;IACF,MAAM,wBAAwB,GAAG;QAC/B;YACE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,0BAA0B,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;YAC9F,MAAM,EAAE,EAAE;SACX;KACF,CAAC;IAEF,MAAM,YAAY,GAAG;QACnB;YACE,UAAU,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC,SAAS,CAAC;SAC5D;KACF,CAAC;IAEF,MAAM,sBAAsB,GAAG;QAC7B;YACE,UAAU,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC,mBAAmB,CAAC;SACtE;KACF,CAAC;IAEF,MAAM,CAAC;QACL,KAAK,GAAG,oBAAS,CAAC,QAAQ,CAAC,kBAAQ,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;QACtD,iBAAW,CAAC,uBAAuB,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,EAAE,EAAE;YAC1E,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;QACH,KAAK,CAAC,kBAAkB,EAAE,CAAC;QAC3B,kBAAkB,GAAG,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAClD,kBAAkB,GAAG,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE;QAClD,kBAAkB,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAC7D,kBAAkB,CAAC,YAAY,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACvD,kBAAkB,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAC3D,kBAAkB,CAAC,aAAa,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrD,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QACvD,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAC/D,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC7C,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACnD,kBAAkB,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACpG,kBAAkB,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE;QAClD,kBAAkB,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAC7D,kBAAkB,CAAC,YAAY,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACtD,kBAAkB,CAAC,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAC3D,kBAAkB,CAAC,aAAa,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrD,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QACvD,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACnD,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC5C,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACnD,kBAAkB,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACpG,kBAAkB,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACnD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,6BAA6B,EAAE,GAAG,EAAE;QAC3C,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;YAChC,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;YACrC,MAAM,UAAU,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,kBAAkB,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC;YACzD,MAAM,oBAAoB,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAAC;YAE7D,EAAE,CAAC,sCAAsC,EAAE,KAAK;gBAC9C,MAAM,YAAY,GAAG,EAAE,CAAC;gBACxB,MAAM,qBAAqB,GAAG,MAAM,kBAAkB,CAAC,iBAAiB,CAAC;oBACvE,QAAQ;oBACR,UAAU;oBACV,YAAY;iBACN,CAAC,CAAC;gBACV,qBAAqB,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAEzC,MAAM,+BAA+B,GAAG,MAAM,kBAAkB,CAAC,iBAAiB,CAAC;oBACjF,QAAQ,EAAE,kBAAkB;oBAC5B,UAAU,EAAE,oBAAoB;oBAChC,YAAY,EAAE,EAAE;iBACV,CAAC,CAAC;gBACV,+BAA+B,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACrD,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,yEAAyE,EAAE,KAAK;gBACjF,MAAM,yBAAyB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACvE,yBAAyB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,QAAQ,CAAC;gBAC1D,MAAM,YAAY,GAAG,EAAE,CAAC;gBACxB,MAAM,kBAAkB;qBACrB,iBAAiB,CAAC;oBACjB,QAAQ,EAAE,yBAAyB;oBACnC,UAAU;oBACV,YAAY;iBACN,CAAC;qBACR,MAAM,CAAC,YAAY,CAAC,6DAA6D,CAAC,CAAC;YACxF,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,yEAAyE,EAAE,KAAK;gBACjF,MAAM,yBAAyB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACvE,yBAAyB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,UAAU,CAAC;gBAC5D,MAAM,YAAY,GAAG,EAAE,CAAC;gBACxB,MAAM,kBAAkB;qBACrB,iBAAiB,CAAC;oBACjB,QAAQ,EAAE,yBAAyB;oBACnC,UAAU;oBACV,YAAY;iBACN,CAAC;qBACR,MAAM,CAAC,YAAY,CAAC,6DAA6D,CAAC,CAAC;YACxF,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,4FAA4F,EAAE,KAAK;gBACpG,MAAM,YAAY,GAAG,EAAE,CAAC;gBACxB,MAAM,kBAAkB;qBACrB,iBAAiB,CAAC;oBACjB,QAAQ;oBACR,UAAU;oBACV,YAAY;iBACN,CAAC;qBACR,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YAC/B,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,4FAA4F,EAAE,KAAK;gBACpG,MAAM,YAAY,GAAG,EAAE,CAAC;gBACxB,MAAM,kBAAkB;qBACrB,iBAAiB,CAAC;oBACjB,QAAQ;oBACR,UAAU;oBACV,YAAY;iBACN,CAAC;qBACR,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YAC/B,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,gFAAgF,EAAE,KAAK;gBACxF,MAAM,yBAAyB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACvE,yBAAyB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,IAAI,gBAAM,CAAC,OAAO,CAClE,yBAAyB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,CAChD,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;gBAC9B,MAAM,YAAY,GAAG,EAAE,CAAC;gBACxB,MAAM,UAAU,GAAG,MAAM,kBAAkB,CAAC,iBAAiB,CAAC;oBAC5D,QAAQ,EAAE,yBAAyB;oBACnC,UAAU;oBACV,YAAY;iBACN,CAAC,CAAC;gBACV,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAChC,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,sDAAsD,EAAE,KAAK;gBAC9D,MAAM,UAAU,GAAG,EAAE,CAAC;gBACtB,MAAM,kBAAkB;qBACrB,iBAAiB,CAAC;oBACjB,QAAQ;oBACR,UAAU;iBACJ,CAAC;qBACR,MAAM,CAAC,YAAY,CAAC,6CAA6C,CAAC,CAAC;YACxE,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,iEAAiE,EAAE,KAAK;YACzE,MAAM,QAAQ,GAAG;gBACf,UAAU,EAAE,CAAC,QAAQ,CAAC,mCAAmC,CAAC,SAAS,CAAC;aACrE,CAAC;YACF,MAAM,UAAU,GAAG;gBACjB,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,mCAAmC,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;gBAC7F,MAAM,EAAE,EAAE;aACX,CAAC;YACF,MAAM,YAAY,GAAG,EAAE,CAAC;YACxB,MAAM,qBAAqB,GAAG,MAAM,kBAAkB,CAAC,iBAAiB,CAAC;gBACvE,QAAQ;gBACR,UAAU;gBACV,YAAY;aACN,CAAC,CAAC;YACV,qBAAqB,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,8BAA8B,EAAE,GAAG,EAAE;QAC5C,EAAE,CAAC,8CAA8C,EAAE,KAAK;YACtD,MAAM,oBAAoB,GAAG,CAAC,MAAM,kBAAkB,CAAC,kBAAkB,CAAC;gBACxE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,0BAA0B,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;aACrF,CAAC,CAA2B,CAAC;YAC9B,oBAAoB,CAAC,MAAM,CAAC,SAAS,CAAC;gBACpC,YAAY,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,KAAK,EAAE,gBAAgB,CAAC;gBACzG,EAAE,EAAE,QAAQ,CAAC,0BAA0B,CAAC,IAAI;gBAC5C,OAAO,EAAE;oBACP;wBACE,OAAO,EAAE,QAAQ,CAAC,0BAA0B,CAAC,SAAS,CAAC,OAAO;wBAC9D,MAAM,EAAE,QAAQ,CAAC,0BAA0B,CAAC,SAAS,CAAC,MAAM;qBAC7D;iBACF;gBACD,YAAY,EAAE,QAAQ,CAAC,0BAA0B,CAAC,SAAS,CAAC,MAAM;gBAClE,aAAa,EAAE,EAAE;gBACjB,YAAY,EAAE,GAAG;gBACjB,GAAG,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE;gBACvB,cAAc,EAAE,SAAS;aAC1B,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,6DAA6D,EAAE,KAAK;YACrE,MAAM,oBAAoB,GAAG,CAAC,MAAM,kBAAkB,CAAC,kBAAkB,CAAC;gBACxE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,0BAA0B,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;gBAC9F,mBAAmB,EAAE,KAAK;gBAC1B,qBAAqB,EAAE,KAAK;aAC7B,CAAC,CAA2B,CAAC;YAC9B,oBAAoB,CAAC,MAAM,CAAC,SAAS,CAAC;gBACpC,YAAY,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,cAAc,EAAE,KAAK,EAAE,gBAAgB,CAAC;gBACzG,EAAE,EAAE,QAAQ,CAAC,0BAA0B,CAAC,cAAc;gBACtD,OAAO,EAAE;oBACP;wBACE,OAAO,EAAE,QAAQ,CAAC,0BAA0B,CAAC,mBAAmB,CAAC,OAAO;wBACxE,MAAM,EAAE,QAAQ,CAAC,0BAA0B,CAAC,mBAAmB,CAAC,MAAM;qBACvE;iBACF;gBACD,YAAY,EAAE,QAAQ,CAAC,0BAA0B,CAAC,mBAAmB,CAAC,MAAM;gBAC5E,aAAa,EAAE,EAAE;gBACjB,YAAY,EAAE,GAAG;gBACjB,GAAG,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE;gBACvB,cAAc,EAAE,SAAS;aAC1B,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wDAAwD,EAAE,KAAK;YAChE,IAAI,CAAC;gBACH,MAAM,kBAAkB,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;YAClD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,gBAAM,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,qBAAqB,CAAC,CAAC;YACrD,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wDAAwD,EAAE,KAAK;YAChE,IAAI,CAAC;gBACH,MAAM,kBAAkB,CAAC,kBAAkB,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAAC;YACzE,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,gBAAM,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,qBAAqB,CAAC,CAAC;YACrD,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,6BAA6B,EAAE,GAAG,EAAE;QAC3C,MAAM,gBAAgB,GAAG,CAAC,QAAQ,CAAC,0BAA0B,CAAC,EAAE,CAAC,CAAC;QAClE,MAAM,6BAA6B,GAAG;YACpC;gBACE;oBACE,OAAO,EAAE,kDAAkD;oBAC3D,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,MAAM;iBAC3C;aACF;SACF,CAAC;QAEF,MAAM,uCAAuC,GAAG;YAC9C;gBACE;oBACE,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,OAAO;oBACrC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,MAAM;iBAC3C;aACF;SACF,CAAC;QAEF,MAAM,8BAA8B,GAAG;YACrC;gBACE;oBACE,OAAO,EAAE,kDAAkD;oBAC3D,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,MAAM;iBAC3C;aACF;SACF,CAAC;QAEF,MAAM,wCAAwC,GAAG;YAC/C;gBACE;oBACE,OAAO,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,OAAO;oBAC5C,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,MAAM;iBAC3C;aACF;SACF,CAAC;QAEF,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;YACpC,MAAM,WAAW,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;YAC5C,MAAM,yBAAyB,GAAG,6BAA6B,CAAC,KAAK,CAAC,CAAC;YACvE,MAAM,mCAAmC,GAAG,uCAAuC,CAAC,KAAK,CAAC,CAAC;YAC3F,MAAM,0BAA0B,GAAG,8BAA8B,CAAC,KAAK,CAAC,CAAC;YACzE,MAAM,oCAAoC,GAAG,wCAAwC,CAAC,KAAK,CAAC,CAAC;YAE7F,EAAE,CAAC,gCAAgC,EAAE,KAAK;gBACxC,MAAM,iBAAiB,GAAG,MAAM,kBAAkB,CAAC,gBAAgB,CAAC;oBAClE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;iBAC1D,CAAC,CAAC;gBAEH,iBAAiB,CAAC,MAAM,CAAC,SAAS,CAAC;oBACjC,MAAM,EAAE,yBAAyB;oBACjC,OAAO,EAAE,0BAA0B;iBACpC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,+CAA+C,EAAE,KAAK;gBACvD,MAAM,iBAAiB,GAAG,MAAM,kBAAkB,CAAC,gBAAgB,CAAC;oBAClE,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;oBACzD,mBAAmB,EAAE,KAAK;oBAC1B,qBAAqB,EAAE,KAAK;iBACC,CAAC,CAAC;gBAEjC,iBAAiB,CAAC,MAAM,CAAC,SAAS,CAAC;oBACjC,MAAM,EAAE,mCAAmC;oBAC3C,OAAO,EAAE,oCAAoC;iBAC9C,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,sFAAsF,EAAE,KAAK;gBAC9F,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,SAAG,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAC;gBAC7D,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;gBACzB,MAAM,kBAAkB;qBACrB,gBAAgB,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;qBACxC,MAAM,CAAC,EAAE,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAC;gBACrD,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import Tonweb from 'tonweb';\nimport should from 'should';\nimport * as sinon from 'sinon';\nimport { TransactionExplanation } from '@bitgo/sdk-core';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';\nimport { BitGoAPI } from '@bitgo/sdk-api';\nimport { JettonToken, Ton, TonParseTransactionOptions } from '../../src';\nimport * as testData from '../resources/ton';\n\ndescribe('Jetton Tokens', function () {\n  let bitgo: TestBitGoAPI;\n  let testnetJettonToken;\n  let mainnetJettonToken;\n  const testnetTokenName = 'tton:ukwny-us';\n  const mainnetTokenName = 'ton:usdt';\n\n  const txPrebuildList = [\n    {\n      txHex: Buffer.from(testData.signedTokenSendTransaction.tx, 'base64').toString('hex'),\n      txInfo: {},\n    },\n  ];\n  const txPrebuildBounceableList = [\n    {\n      txHex: Buffer.from(testData.signedTokenSendTransaction.txBounceable, 'base64').toString('hex'),\n      txInfo: {},\n    },\n  ];\n\n  const txParamsList = [\n    {\n      recipients: [testData.signedTokenSendTransaction.recipient],\n    },\n  ];\n\n  const txParamsBounceableList = [\n    {\n      recipients: [testData.signedTokenSendTransaction.recipientBounceable],\n    },\n  ];\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    JettonToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {\n      bitgo.safeRegister(name, coinConstructor);\n    });\n    bitgo.initializeTestVars();\n    testnetJettonToken = bitgo.coin(testnetTokenName);\n    mainnetJettonToken = bitgo.coin(mainnetTokenName);\n  });\n\n  it('should return constants for Testnet Ton token', function () {\n    testnetJettonToken.getChain().should.equal(testnetTokenName);\n    testnetJettonToken.getBaseChain().should.equal('tton');\n    testnetJettonToken.getFullName().should.equal('Ton Token');\n    testnetJettonToken.getBaseFactor().should.equal(1e9);\n    testnetJettonToken.type.should.equal(testnetTokenName);\n    testnetJettonToken.name.should.equal('Test Unknown TokenY-US');\n    testnetJettonToken.coin.should.equal('tton');\n    testnetJettonToken.network.should.equal('Testnet');\n    testnetJettonToken.contractAddress.should.equal('kQD8EQMavE1w6gvgMXUhN8hi7pSk4bKYM-W2dgkNqV54Y16Y');\n    testnetJettonToken.decimalPlaces.should.equal(9);\n  });\n\n  it('should return constants for Mainnet Ton token', function () {\n    mainnetJettonToken.getChain().should.equal(mainnetTokenName);\n    mainnetJettonToken.getBaseChain().should.equal('ton');\n    mainnetJettonToken.getFullName().should.equal('Ton Token');\n    mainnetJettonToken.getBaseFactor().should.equal(1e6);\n    mainnetJettonToken.type.should.equal(mainnetTokenName);\n    mainnetJettonToken.name.should.equal('Tether USD');\n    mainnetJettonToken.coin.should.equal('ton');\n    mainnetJettonToken.network.should.equal('Mainnet');\n    mainnetJettonToken.contractAddress.should.equal('EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs');\n    mainnetJettonToken.decimalPlaces.should.equal(6);\n  });\n\n  describe('Verify Jetton transaction: ', () => {\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 testnetJettonToken.verifyTransaction({\n          txParams,\n          txPrebuild,\n          verification,\n        } as any);\n        isTransactionVerified.should.equal(true);\n\n        const isBounceableTransactionVerified = await testnetJettonToken.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 testnetJettonToken\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 testnetJettonToken\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 testnetJettonToken\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 testnetJettonToken\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 testnetJettonToken.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 testnetJettonToken\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.signedTokenSendTransactionForMemoId.recipient],\n      };\n      const txPrebuild = {\n        txHex: Buffer.from(testData.signedTokenSendTransactionForMemoId.tx, 'base64').toString('hex'),\n        txInfo: {},\n      };\n      const verification = {};\n      const isTransactionVerified = await testnetJettonToken.verifyTransaction({\n        txParams,\n        txPrebuild,\n        verification,\n      } as any);\n      isTransactionVerified.should.equal(true);\n    });\n  });\n\n  describe('Explain Jetton Transaction: ', () => {\n    it('should explain a jetton transfer transaction', async function () {\n      const explainedTransaction = (await testnetJettonToken.explainTransaction({\n        txHex: Buffer.from(testData.signedTokenSendTransaction.tx, 'base64').toString('hex'),\n      })) as TransactionExplanation;\n      explainedTransaction.should.deepEqual({\n        displayOrder: ['id', 'outputs', 'outputAmount', 'changeOutputs', 'changeAmount', 'fee', 'withdrawAmount'],\n        id: testData.signedTokenSendTransaction.txId,\n        outputs: [\n          {\n            address: testData.signedTokenSendTransaction.recipient.address,\n            amount: testData.signedTokenSendTransaction.recipient.amount,\n          },\n        ],\n        outputAmount: testData.signedTokenSendTransaction.recipient.amount,\n        changeOutputs: [],\n        changeAmount: '0',\n        fee: { fee: 'UNKNOWN' },\n        withdrawAmount: undefined,\n      });\n    });\n\n    it('should explain a non-bounceable jetton transfer transaction', async function () {\n      const explainedTransaction = (await testnetJettonToken.explainTransaction({\n        txHex: Buffer.from(testData.signedTokenSendTransaction.txBounceable, '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.signedTokenSendTransaction.txIdBounceable,\n        outputs: [\n          {\n            address: testData.signedTokenSendTransaction.recipientBounceable.address,\n            amount: testData.signedTokenSendTransaction.recipientBounceable.amount,\n          },\n        ],\n        outputAmount: testData.signedTokenSendTransaction.recipientBounceable.amount,\n        changeOutputs: [],\n        changeAmount: '0',\n        fee: { fee: 'UNKNOWN' },\n        withdrawAmount: undefined,\n      });\n    });\n\n    it('should fail to explain transaction with missing params', async function () {\n      try {\n        await testnetJettonToken.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 testnetJettonToken.explainTransaction({ txHex: 'randomString' });\n      } catch (error) {\n        should.equal(error.message, 'Invalid transaction');\n      }\n    });\n  });\n\n  describe('Parse Jetton Transactions: ', () => {\n    const transactionsList = [testData.signedTokenSendTransaction.tx];\n    const transactionInputsResponseList = [\n      [\n        {\n          address: 'EQCqQzfyg0cZ-8t9v2YoHmFFxG5jgjvQRTZ2yeDjO5z5ZRy9',\n          amount: testData.tokenRecipients[0].amount,\n        },\n      ],\n    ];\n\n    const transactionInputsResponseBounceableList = [\n      [\n        {\n          address: testData.tokenSender.address,\n          amount: testData.tokenRecipients[0].amount,\n        },\n      ],\n    ];\n\n    const transactionOutputsResponseList = [\n      [\n        {\n          address: 'EQB-CM6DF-jpq9XVdiSdefAMU5KC1gpZuYBFp-Q65aUhnx5K',\n          amount: testData.tokenRecipients[0].amount,\n        },\n      ],\n    ];\n\n    const transactionOutputsResponseBounceableList = [\n      [\n        {\n          address: testData.tokenRecipients[0].address,\n          amount: testData.tokenRecipients[0].amount,\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 testnetJettonToken.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 testnetJettonToken.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 testnetJettonToken\n          .parseTransaction({ txHex: transaction })\n          .should.be.rejectedWith('invalid raw transaction');\n        stub.restore();\n      });\n    });\n  });\n});\n"]}

package/dist/{test → cjs/test}/unit/keyPair.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyPair.d.ts","sourceRoot":"","sources":["../../../test/unit/keyPair.ts"],"names":[],"mappings":""}
+{"version":3,"file":"keyPair.d.ts","sourceRoot":"","sources":["../../../../test/unit/keyPair.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const src_1 = require("../../src");
+const utils_1 = __importDefault(require("../../src/lib/utils"));
+const should_1 = __importDefault(require("should"));
+const sdk_core_1 = require("@bitgo/sdk-core");
+const sdk_lib_mpc_1 = require("@bitgo/sdk-lib-mpc");
+describe('Ton KeyPair', function () {
+    let rootKeychain;
+    let rootPublicKey;
+    let MPC;
+    let hdTree;
+    before(async () => {
+        hdTree = await sdk_lib_mpc_1.Ed25519Bip32HdTree.initialize();
+        MPC = await sdk_core_1.Eddsa.initialize(hdTree);
+        const A = MPC.keyShare(1, 2, 3);
+        const B = MPC.keyShare(2, 2, 3);
+        const C = MPC.keyShare(3, 2, 3);
+        const A_combine = MPC.keyCombine(A.uShare, [B.yShares[1], C.yShares[1]]);
+        const commonKeychain = A_combine.pShare.y + A_combine.pShare.chaincode;
+        rootKeychain = MPC.deriveUnhardened(commonKeychain, 'm/0');
+        rootPublicKey = Buffer.from(rootKeychain, 'hex').slice(0, 32).toString('hex');
+    });
+    describe('should create a valid KeyPair', () => {
+        it('from an empty value', async () => {
+            const keyPair = new src_1.KeyPair();
+            should_1.default.exists(keyPair.getKeys().prv);
+            should_1.default.exists(keyPair.getKeys().pub);
+            const address = await utils_1.default.getAddressFromPublicKey(keyPair.getKeys().pub);
+            should_1.default.exists(address);
+        });
+    });
+    describe('Keypair from derived Public Key', () => {
+        it('should create keypair with just derived public key', () => {
+            const keyPair = new src_1.KeyPair({ pub: rootPublicKey });
+            keyPair.getKeys().pub.should.equal(rootPublicKey);
+        });
+        it('should derived ed25519 public key should be valid', () => {
+            utils_1.default.isValidPublicKey(rootPublicKey).should.be.true();
+        });
+    });
+    describe('should fail to create a KeyPair', function () {
+        it('from an invalid public key', () => {
+            const source = {
+                pub: '01D63D',
+            };
+            assert_1.default.throws(() => new src_1.KeyPair(source));
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/test/unit/singleNominatorWithdrawBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleNominatorWithdrawBuilder.d.ts","sourceRoot":"","sources":["../../../../test/unit/singleNominatorWithdrawBuilder.ts"],"names":[],"mappings":""}