@ton-wallet/create 14.0.6 → 14.0.7

package/dist/multisig/MultisigWallet.spec.js

@@ -0,0 +1,248 @@
+"use strict";
+/* Made by @Gusarich and @Miandic */
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@ton/core");
+const crypto_1 = require("@ton/crypto");
+const emulator_1 = require("@ton/emulator");
+const MultisigWallet_1 = require("./MultisigWallet");
+const MultisigOrderBuilder_1 = require("./MultisigOrderBuilder");
+const createTestClient_1 = require("../utils/createTestClient");
+function createInternalMessage(bounce, dest, value, body, mode = 3) {
+    return {
+        info: {
+            bounce,
+            bounced: false,
+            createdAt: 0,
+            createdLt: 0n,
+            dest,
+            forwardFee: 0n,
+            ihrDisabled: true,
+            ihrFee: 0n,
+            type: 'internal',
+            value: {
+                coins: value,
+            },
+        },
+        body,
+    };
+}
+describe('MultisigWallet', () => {
+    var publicKeys;
+    var secretKeys;
+    var system;
+    var treasure;
+    var client;
+    function createProvider(multisig) {
+        const stateInit = multisig.init;
+        return system.provider({
+            address: multisig.address,
+            init: {
+                code: stateInit.code,
+                data: stateInit.data,
+            },
+        });
+    }
+    function signOrder(order) {
+        for (let i = 0; i < 3; i++) {
+            order.sign(i, secretKeys[i]);
+        }
+        return order;
+    }
+    beforeAll(async () => {
+        publicKeys = [];
+        secretKeys = [];
+        for (let i = 0; i < 10; i += 1) {
+            let kp = (0, crypto_1.keyPairFromSeed)(await (0, crypto_1.getSecureRandomBytes)(32));
+            publicKeys.push(kp.publicKey);
+            secretKeys.push(kp.secretKey);
+        }
+        client = (0, createTestClient_1.createTestClient)('mainnet');
+    });
+    beforeEach(async () => {
+        system = await emulator_1.ContractSystem.create();
+        treasure = system.treasure('my-treasure');
+    });
+    it('should create MultisigWallet object', () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+    });
+    it('should create MultisigWallet object from client', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2, { client });
+    });
+    it('should throw in fromAddress if no provider and no client', async () => {
+        expect(MultisigWallet_1.MultisigWallet.fromAddress(core_1.Address.parse('EQADBXugwmn4YvWsQizHdWGgfCTN_s3qFP0Ae0pzkU-jwzoE'), {})).rejects.toThrowError('Either provider or client must be specified');
+    });
+    it('should throw in fromAddress if the contract is inactive', async () => {
+        expect(MultisigWallet_1.MultisigWallet.fromAddress(core_1.Address.parse('EQCzD8HVMlGCbXf3oOBxXBt5AfjhmmWKAC9fsJvJLFEO0SQt'), { client })).rejects.toThrowError('Contract must be active');
+    });
+    it('should deploy via internal message', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        let provider = createProvider(multisig);
+        await multisig.deployInternal(treasure);
+        let txs = await system.run();
+        expect(txs).toHaveLength(2);
+        expect(txs[1].endStatus).toEqual('active');
+    });
+    it('should deploy via external message', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        let provider = createProvider(multisig);
+        await treasure.send({
+            sendMode: 0,
+            to: multisig.address,
+            value: 1000000000n,
+            body: core_1.Cell.EMPTY,
+            bounce: false,
+        });
+        await system.run();
+        await multisig.deployExternal(provider);
+        let txs = await system.run();
+        expect(txs).toHaveLength(1);
+        expect(txs[0].endStatus).toEqual('active');
+    });
+    it('should throw in deployExternal if there is no provider', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        expect(multisig.deployExternal()).rejects.toThrowError('you must specify provider if there is no such property in MultisigWallet instance');
+    });
+    it('should deploy via external message with provider from property', async () => {
+        let multisigTmp = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        let provider = createProvider(multisigTmp);
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2, { provider });
+        await treasure.send({
+            sendMode: 0,
+            to: multisig.address,
+            value: 1000000000n,
+            body: core_1.Cell.EMPTY,
+            bounce: false,
+        });
+        await system.run();
+        await multisig.deployExternal();
+        let txs = await system.run();
+        expect(txs).toHaveLength(1);
+        expect(txs[0].endStatus).toEqual('active');
+    });
+    it('should load contract from address', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        let provider = createProvider(multisig);
+        await multisig.deployInternal(treasure);
+        await system.run();
+        let multisigFromProvider = await MultisigWallet_1.MultisigWallet.fromAddress(multisig.address, { provider });
+        expect(multisig.address.toRawString()).toEqual(multisigFromProvider.address.toRawString());
+        expect(multisig.owners.keys().toString()).toEqual(multisigFromProvider.owners.keys().toString());
+        expect(multisig.owners.values().toString()).toEqual(multisigFromProvider.owners.values().toString());
+        const testMultisigAddress = core_1.Address.parse('EQADBXugwmn4YvWsQizHdWGgfCTN_s3qFP0Ae0pzkU-jwzoE');
+        let multisigFromClient = await MultisigWallet_1.MultisigWallet.fromAddress(testMultisigAddress, { client });
+        expect(testMultisigAddress.toRawString()).toEqual(multisigFromClient.address.toRawString());
+        expect(multisigFromClient.owners.keys().toString()).toEqual('0,1,2');
+        expect(multisigFromClient.owners.values().toString()).toEqual([
+            Buffer.from('51ce50ebcced0fdcc7520a2cacf653c81fb49f34f9c570a9e1bb23c7f7186d8d00', 'hex'),
+            Buffer.from('f7a92e5a7b97b81fdc366c4c77298cfd1e9b97ba04feecf0c1d85d63d16d9f2000', 'hex'),
+            Buffer.from('6ec29f8fd53761b94291d5801cda5d0d00c48d78dc6c147ec4c6e088c3d93d8400', 'hex'),
+        ].toString());
+    });
+    it('should find order by public key', () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        for (let i = 0; i < publicKeys.length; i += 1) {
+            expect(multisig.getOwnerIdByPubkey(publicKeys[i])).toEqual(i);
+        }
+    });
+    it('should accept orders', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        let provider = createProvider(multisig);
+        await multisig.deployInternal(treasure, 10000000000n);
+        await system.run();
+        let orderBuilder = new MultisigOrderBuilder_1.MultisigOrderBuilder(123);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 1000000000n, core_1.Cell.EMPTY), 3);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address2'), 0n, (0, core_1.beginCell)().storeUint(3, 123).endCell()), 3);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 2000000000n, core_1.Cell.EMPTY), 3);
+        await multisig.sendOrder(orderBuilder.build(), secretKeys[3], provider);
+        let txs = await system.run();
+        expect(txs).toHaveLength(1);
+        if (txs[0].description.type == 'generic') {
+            expect(txs[0].description.aborted).toBeFalsy;
+        }
+    });
+    it('should accept orders sent by `sendWithoutSecretKey` method', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        let provider = createProvider(multisig);
+        await multisig.deployInternal(treasure, 10000000000n);
+        await system.run();
+        let orderBuilder = new MultisigOrderBuilder_1.MultisigOrderBuilder(123);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 1000000000n, core_1.Cell.EMPTY), 3);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address2'), 0n, (0, core_1.beginCell)().storeUint(3, 123).endCell()), 3);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 2000000000n, core_1.Cell.EMPTY), 3);
+        const order = orderBuilder.build();
+        const signature = (0, crypto_1.sign)(order.toCell(3).hash(), secretKeys[3]);
+        await multisig.sendOrderWithoutSecretKey(orderBuilder.build(), signature, 3, provider);
+        let txs = await system.run();
+        expect(txs).toHaveLength(1);
+        if (txs[0].description.type == 'generic') {
+            expect(txs[0].description.aborted).toBeFalsy;
+        }
+    });
+    it('should throw in sendOrder if there is no provider', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        let provider = createProvider(multisig);
+        await multisig.deployInternal(treasure, 10000000000n);
+        await system.run();
+        let order = new MultisigOrderBuilder_1.MultisigOrderBuilder(123);
+        order.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 1000000000n, core_1.Cell.EMPTY), 3);
+        order.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address2'), 0n, (0, core_1.beginCell)().storeUint(3, 123).endCell()), 3);
+        order.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 2000000000n, core_1.Cell.EMPTY), 3);
+        expect(multisig.sendOrder(order.build(), secretKeys[3]))
+            .rejects.toThrowError('you must specify provider if there is no such property in MultisigWallet instance');
+    });
+    it('should accept orders with provider from property', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        multisig.provider = createProvider(multisig);
+        await multisig.deployInternal(treasure, 10000000000n);
+        await system.run();
+        let orderBuilder = new MultisigOrderBuilder_1.MultisigOrderBuilder(123);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 1000000000n, core_1.Cell.EMPTY), 3);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address2'), 0n, (0, core_1.beginCell)().storeUint(3, 123).endCell()), 3);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 2000000000n, core_1.Cell.EMPTY), 3);
+        await multisig.sendOrder(orderBuilder.build(), secretKeys[3]);
+        let txs = await system.run();
+        expect(txs).toHaveLength(1);
+        if (txs[0].description.type == 'generic') {
+            expect(txs[0].description.aborted).toBeFalsy();
+        }
+    });
+    it('should accept multiple orders and send messages', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 5);
+        let provider = createProvider(multisig);
+        await multisig.deployInternal(treasure, 10000000000n);
+        await system.run();
+        let orderBuilder = new MultisigOrderBuilder_1.MultisigOrderBuilder(123);
+        orderBuilder.addMessage(createInternalMessage(false, (0, emulator_1.testAddress)('address1'), 1000000000n, core_1.Cell.EMPTY), 3);
+        orderBuilder.addMessage(createInternalMessage(false, (0, emulator_1.testAddress)('address2'), 0n, (0, core_1.beginCell)().storeUint(3, 123).endCell()), 3);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 2000000000n, core_1.Cell.EMPTY), 3);
+        let order = orderBuilder.build();
+        for (let i = 0; i < 4; i += 1) {
+            await multisig.sendOrder(order, secretKeys[i], provider);
+            await system.run();
+        }
+        await multisig.sendOrder(order, secretKeys[7], provider);
+        let txs = await system.run();
+        expect(txs).toHaveLength(5);
+    });
+    it('should accept orders with multiple signatures and send messages', async () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 5);
+        let provider = createProvider(multisig);
+        await multisig.deployInternal(treasure, 10000000000n);
+        await system.run();
+        let orderBuilder = new MultisigOrderBuilder_1.MultisigOrderBuilder(123);
+        orderBuilder.addMessage(createInternalMessage(false, (0, emulator_1.testAddress)('address1'), 1000000000n, core_1.Cell.EMPTY), 3);
+        orderBuilder.addMessage(createInternalMessage(false, (0, emulator_1.testAddress)('address2'), 0n, (0, core_1.beginCell)().storeUint(3, 123).endCell()), 3);
+        orderBuilder.addMessage(createInternalMessage(true, (0, emulator_1.testAddress)('address1'), 2000000000n, core_1.Cell.EMPTY), 3);
+        let order = orderBuilder.build();
+        for (let i = 0; i < 5; i += 1) {
+            order.sign(i, secretKeys[i]);
+        }
+        await multisig.sendOrder(order, secretKeys[0], provider);
+        let txs = await system.run();
+        expect(txs).toHaveLength(5);
+    });
+    it('should throw in getOwnerIdByPubkey on invalid public key', () => {
+        let multisig = new MultisigWallet_1.MultisigWallet(publicKeys, 0, 123, 2);
+        expect(() => multisig.getOwnerIdByPubkey(Buffer.alloc(32))).toThrow('public key is not an owner');
+    });
+});

package/dist/utils/createTestClient.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { TonClient } from "../client/TonClient";
+export declare function createTestClient(net?: 'testnet' | 'mainnet'): TonClient;

package/dist/utils/createTestClient.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestClient = void 0;
+const TonClient_1 = require("../client/TonClient");
+function createTestClient(net) {
+    return new TonClient_1.TonClient({
+        endpoint: net === 'mainnet' ? 'https://mainnet.tonhubapi.com/jsonRPC' : 'https://testnet.toncenter.com/api/v2/jsonRPC',
+        apiKey: net !== 'mainnet' ? '32df40f4ffc11053334bcdf09c7d3a9e6487ee0cb715edf8cf667c543edb10ca' : undefined
+    });
+}
+exports.createTestClient = createTestClient;

package/dist/utils/createTestClient4.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { TonClient4 } from "../client/TonClient4";
+export declare function createTestClient4(net?: 'testnet' | 'mainnet'): TonClient4;

package/dist/utils/createTestClient4.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestClient4 = void 0;
+const TonClient4_1 = require("../client/TonClient4");
+function createTestClient4(net) {
+    return new TonClient4_1.TonClient4({ endpoint: net === 'mainnet' ? 'https://mainnet-v4.tonhubapi.com' : 'https://testnet-v4.tonhubapi.com' });
+}
+exports.createTestClient4 = createTestClient4;

package/dist/utils/fees.d.ts

@@ -0,0 +1,25 @@
+import { Cell } from '@ton/core';
+import { MsgPrices, StoragePrices } from '../config/ConfigParser';
+export declare function computeStorageFees(data: {
+    now: number;
+    lastPaid: number;
+    storagePrices: StoragePrices[];
+    storageStat: {
+        cells: number;
+        bits: number;
+        publicCells: number;
+    };
+    special: boolean;
+    masterchain: boolean;
+}): bigint;
+export declare function computeFwdFees(msgPrices: MsgPrices, cells: bigint, bits: bigint): bigint;
+export declare function computeGasPrices(gasUsed: bigint, prices: {
+    flatLimit: bigint;
+    flatPrice: bigint;
+    price: bigint;
+}): bigint;
+export declare function computeExternalMessageFees(msgPrices: MsgPrices, cell: Cell): bigint;
+export declare function computeMessageForwardFees(msgPrices: MsgPrices, cell: Cell): {
+    fees: bigint;
+    remaining: bigint;
+};

package/dist/utils/fees.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeMessageForwardFees = exports.computeExternalMessageFees = exports.computeGasPrices = exports.computeFwdFees = exports.computeStorageFees = void 0;
+const core_1 = require("@ton/core");
+//
+// Source: https://github.com/ton-foundation/ton/blob/ae5c0720143e231c32c3d2034cfe4e533a16d969/crypto/block/transaction.cpp#L425
+//
+function computeStorageFees(data) {
+    const { lastPaid, now, storagePrices, storageStat, special, masterchain } = data;
+    if (now <= lastPaid || storagePrices.length === 0 || now < storagePrices[0].utime_since || special) {
+        return BigInt(0);
+    }
+    let upto = Math.max(lastPaid, storagePrices[0].utime_since);
+    let total = BigInt(0);
+    for (let i = 0; i < storagePrices.length && upto < now; i++) {
+        let valid_until = (i < storagePrices.length - 1 ? Math.min(now, storagePrices[i + 1].utime_since) : now);
+        let payment = BigInt(0);
+        if (upto < valid_until) {
+            let delta = valid_until - upto;
+            payment += (BigInt(storageStat.cells) * (masterchain ? storagePrices[i].mc_cell_price_ps : storagePrices[i].cell_price_ps));
+            payment += (BigInt(storageStat.bits) * (masterchain ? storagePrices[i].mc_bit_price_ps : storagePrices[i].bit_price_ps));
+            payment = payment * BigInt(delta);
+        }
+        upto = valid_until;
+        total += payment;
+    }
+    return shr16ceil(total);
+}
+exports.computeStorageFees = computeStorageFees;
+//
+// Source: https://github.com/ton-foundation/ton/blob/ae5c0720143e231c32c3d2034cfe4e533a16d969/crypto/block/transaction.cpp#L1218
+//
+function computeFwdFees(msgPrices, cells, bits) {
+    return msgPrices.lumpPrice + (shr16ceil(msgPrices.bitPrice * bits + (msgPrices.cellPrice * cells)));
+}
+exports.computeFwdFees = computeFwdFees;
+//
+// Source: https://github.com/ton-foundation/ton/blob/ae5c0720143e231c32c3d2034cfe4e533a16d969/crypto/block/transaction.cpp#L761
+//
+function computeGasPrices(gasUsed, prices) {
+    if (gasUsed <= prices.flatLimit) {
+        return prices.flatPrice;
+    }
+    else {
+        //  td::rshift(gas_price256 * (gas_used - cfg.flat_gas_limit), 16, 1) + cfg.flat_gas_price
+        return prices.flatPrice + ((prices.price * (gasUsed - prices.flatLimit)) >> 16n);
+    }
+}
+exports.computeGasPrices = computeGasPrices;
+//
+// Source: https://github.com/ton-foundation/ton/blob/ae5c0720143e231c32c3d2034cfe4e533a16d969/crypto/block/transaction.cpp#L530
+//
+function computeExternalMessageFees(msgPrices, cell) {
+    // Collect stats
+    let storageStats = collectCellStats(cell);
+    storageStats.bits -= cell.bits.length;
+    storageStats.cells -= 1;
+    return computeFwdFees(msgPrices, BigInt(storageStats.cells), BigInt(storageStats.bits));
+}
+exports.computeExternalMessageFees = computeExternalMessageFees;
+function computeMessageForwardFees(msgPrices, cell) {
+    let msg = (0, core_1.loadMessageRelaxed)(cell.beginParse());
+    let storageStats = { bits: 0, cells: 0 };
+    // Init
+    if (msg.init) {
+        const rawBuilder = new core_1.Cell().asBuilder();
+        (0, core_1.storeStateInit)(msg.init)(rawBuilder);
+        const raw = rawBuilder.endCell();
+        let c = collectCellStats(raw);
+        c.bits -= raw.bits.length;
+        c.cells -= 1;
+        storageStats.bits += c.bits;
+        storageStats.cells += c.cells;
+    }
+    // Body
+    let bc = collectCellStats(msg.body);
+    bc.bits -= msg.body.bits.length;
+    bc.cells -= 1;
+    storageStats.bits += bc.bits;
+    storageStats.cells += bc.cells;
+    // NOTE: Extra currencies are ignored for now
+    let fees = computeFwdFees(msgPrices, BigInt(storageStats.cells), BigInt(storageStats.bits));
+    let res = (fees * BigInt(msgPrices.firstFrac)) >> 16n;
+    let remaining = fees - res;
+    return { fees: res, remaining };
+}
+exports.computeMessageForwardFees = computeMessageForwardFees;
+function collectCellStats(cell) {
+    let bits = cell.bits.length;
+    let cells = 1;
+    for (let ref of cell.refs) {
+        let r = collectCellStats(ref);
+        cells += r.cells;
+        bits += r.bits;
+    }
+    return { bits, cells };
+}
+function shr16ceil(src) {
+    let rem = src % 65536n;
+    let res = src >> 16n;
+    if (rem !== 0n) {
+        res += 1n;
+    }
+    return res;
+}

package/dist/utils/fees.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/fees.spec.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fees_1 = require("./fees");
+const core_1 = require("@ton/core");
+const WalletContractV4_1 = require("../wallets/WalletContractV4");
+describe('estimateFees', () => {
+    it('should estimate fees correctly', () => {
+        const config = {
+            storage: [{ utime_since: 0, bit_price_ps: BigInt(1), cell_price_ps: BigInt(500), mc_bit_price_ps: BigInt(1000), mc_cell_price_ps: BigInt(500000) }],
+            workchain: {
+                gas: { flatLimit: BigInt(100), flatGasPrice: BigInt(100000), price: BigInt(65536000) },
+                message: { lumpPrice: BigInt(1000000), bitPrice: BigInt(65536000), cellPrice: BigInt(6553600000), firstFrac: 21845 }
+            },
+        };
+        const storageStats = [{
+                lastPaid: 1696792239, duePayment: null,
+                used: { bits: 6888, cells: 14, publicCells: 0 }
+            }];
+        const gasUsageByOutMsgs = { 1: 3308, 2: 3950, 3: 4592, 4: 5234 };
+        const contract = WalletContractV4_1.WalletContractV4.create({ workchain: 0, publicKey: Buffer.from('MUP3GpbKCQu64L4PIU0QprZxmSUygHcaYKuo2tZYA1c=', 'base64') });
+        const body = (0, core_1.comment)('Test message fees estimation');
+        const testAddress = core_1.Address.parse('EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N');
+        // Create transfer
+        let intMessage = (0, core_1.internal)({
+            to: testAddress,
+            value: 1400000000n,
+            bounce: true,
+            body,
+        });
+        let transfer = contract.createTransfer({
+            seqno: 14,
+            secretKey: Buffer.alloc(64),
+            sendMode: core_1.SendMode.IGNORE_ERRORS | core_1.SendMode.PAY_GAS_SEPARATELY,
+            messages: [intMessage]
+        });
+        const externalMessage = (0, core_1.external)({
+            to: contract.address,
+            body: transfer,
+            init: null
+        });
+        let inMsg = new core_1.Cell().asBuilder();
+        (0, core_1.storeMessage)(externalMessage)(inMsg);
+        let outMsg = new core_1.Cell().asBuilder();
+        (0, core_1.storeMessageRelaxed)(intMessage)(outMsg);
+        // Storage fees
+        let storageFees = BigInt(0);
+        for (let storageStat of storageStats) {
+            if (storageStat) {
+                const computed = (0, fees_1.computeStorageFees)({
+                    lastPaid: storageStat.lastPaid,
+                    masterchain: false,
+                    now: 1697445678,
+                    special: false,
+                    storagePrices: config.storage,
+                    storageStat: {
+                        bits: storageStat.used.bits,
+                        cells: storageStat.used.cells,
+                        publicCells: storageStat.used.publicCells
+                    }
+                });
+                storageFees = storageFees + computed;
+            }
+        }
+        expect((0, core_1.fromNano)(storageFees)).toBe('0.000138473');
+        // Calculate import fees
+        let importFees = (0, fees_1.computeExternalMessageFees)(config.workchain.message, inMsg.endCell());
+        expect((0, core_1.fromNano)(importFees)).toBe('0.001772');
+        // Any transaction use this amount of gas
+        const gasUsed = gasUsageByOutMsgs[1];
+        let gasFees = (0, fees_1.computeGasPrices)(BigInt(gasUsed), { flatLimit: config.workchain.gas.flatLimit, flatPrice: config.workchain.gas.flatGasPrice, price: config.workchain.gas.price });
+        expect((0, core_1.fromNano)(gasFees)).toBe('0.003308');
+        // Total
+        let total = BigInt(0);
+        total += storageFees;
+        total += importFees;
+        total += gasFees;
+        // Forward fees
+        let fwdFees = (0, fees_1.computeMessageForwardFees)(config.workchain.message, outMsg.endCell());
+        expect((0, core_1.fromNano)(fwdFees.fees)).toBe('0.000333328');
+        total += fwdFees.fees;
+        expect((0, core_1.fromNano)(total)).toBe('0.005551801');
+    });
+});

package/dist/utils/maybe.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export type Maybe<T> = T | null | undefined;

package/dist/utils/maybe.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/randomTestKey.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare function randomTestKey(seed: string): import("@ton/crypto").KeyPair;

package/dist/utils/randomTestKey.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomTestKey = void 0;
+const prando_1 = __importDefault(require("prando"));
+const crypto_1 = require("@ton/crypto");
+function randomTestKey(seed) {
+    let random = new prando_1.default(seed);
+    let res = Buffer.alloc(32);
+    for (let i = 0; i < res.length; i++) {
+        res[i] = random.nextInt(0, 256);
+    }
+    return (0, crypto_1.keyPairFromSeed)(res);
+}
+exports.randomTestKey = randomTestKey;

package/dist/utils/time.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare function exponentialBackoffDelay(currentFailureCount: number, minDelay: number, maxDelay: number, maxFailureCount: number): number;
+export declare function delay(ms: number): Promise<unknown>;
+export declare function delayBreakable(ms: number): {
+    promise: Promise<unknown>;
+    resolver: () => void;
+};
+export declare function forever(): Promise<unknown>;
+export declare function backoff<T>(callback: () => Promise<T>, log: boolean): Promise<T>;

package/dist/utils/time.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backoff = exports.forever = exports.delayBreakable = exports.delay = exports.exponentialBackoffDelay = void 0;
+function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
+    let maxDelayRet = minDelay + ((maxDelay - minDelay) / maxFailureCount) * Math.max(currentFailureCount, maxFailureCount);
+    return Math.round(Math.random() * maxDelayRet);
+}
+exports.exponentialBackoffDelay = exponentialBackoffDelay;
+async function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.delay = delay;
+function delayBreakable(ms) {
+    // We can cancel delay from outer code
+    let promiseResolver = null;
+    let resolver = () => {
+        if (promiseResolver) {
+            promiseResolver();
+        }
+    };
+    let promise = new Promise(resolve => {
+        promiseResolver = resolve;
+        setTimeout(resolve, ms);
+    });
+    return { promise, resolver };
+}
+exports.delayBreakable = delayBreakable;
+const promise = new Promise(() => { });
+function forever() {
+    return promise;
+}
+exports.forever = forever;
+async function backoff(callback, log) {
+    let currentFailureCount = 0;
+    const minDelay = 500;
+    const maxDelay = 15000;
+    const maxFailureCount = 50;
+    while (true) {
+        try {
+            return await callback();
+        }
+        catch (e) {
+            if (currentFailureCount > 3) {
+                if (log) {
+                    console.warn(e);
+                }
+            }
+            if (currentFailureCount < maxFailureCount) {
+                currentFailureCount++;
+            }
+            let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
+            await delay(waitForRequest);
+        }
+    }
+}
+exports.backoff = backoff;

package/dist/utils/toUrlSafe.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Whales Corp.
+ * All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare function toUrlSafe(src: string): string;