@ton/ton 13.5.1

package/dist/client/api/HttpApi.js

@@ -0,0 +1,297 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpApi = void 0;
+/**
+ * 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.
+ */
+const TonCache_1 = require("./TonCache");
+const dataloader_1 = __importDefault(require("dataloader"));
+const axios_1 = __importDefault(require("axios"));
+const zod_1 = require("zod");
+const version = require('../../../package.json').version;
+const blockIdExt = zod_1.z.object({
+    '@type': zod_1.z.literal('ton.blockIdExt'),
+    workchain: zod_1.z.number(),
+    shard: zod_1.z.string(),
+    seqno: zod_1.z.number(),
+    root_hash: zod_1.z.string(),
+    file_hash: zod_1.z.string()
+});
+const addressInformation = zod_1.z.object({
+    balance: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]),
+    state: zod_1.z.union([zod_1.z.literal('active'), zod_1.z.literal('uninitialized'), zod_1.z.literal('frozen')]),
+    data: zod_1.z.string(),
+    code: zod_1.z.string(),
+    last_transaction_id: zod_1.z.object({
+        '@type': zod_1.z.literal('internal.transactionId'),
+        lt: zod_1.z.string(),
+        hash: zod_1.z.string()
+    }),
+    block_id: blockIdExt,
+    sync_utime: zod_1.z.number()
+});
+const bocResponse = zod_1.z.object({
+    '@type': zod_1.z.literal('ok')
+});
+const feeResponse = zod_1.z.object({
+    '@type': zod_1.z.literal('query.fees'),
+    source_fees: zod_1.z.object({
+        '@type': zod_1.z.literal('fees'),
+        in_fwd_fee: zod_1.z.number(),
+        storage_fee: zod_1.z.number(),
+        gas_fee: zod_1.z.number(),
+        fwd_fee: zod_1.z.number()
+    })
+});
+const callGetMethod = zod_1.z.object({
+    gas_used: zod_1.z.number(),
+    exit_code: zod_1.z.number(),
+    stack: zod_1.z.array(zod_1.z.unknown())
+});
+const messageData = zod_1.z.union([
+    zod_1.z.object({
+        '@type': zod_1.z.literal('msg.dataRaw'),
+        'body': zod_1.z.string()
+    }),
+    zod_1.z.object({
+        '@type': zod_1.z.literal('msg.dataText'),
+        'text': zod_1.z.string()
+    }),
+    zod_1.z.object({
+        '@type': zod_1.z.literal('msg.dataDecryptedText'),
+        'text': zod_1.z.string()
+    }),
+    zod_1.z.object({
+        '@type': zod_1.z.literal('msg.dataEncryptedText'),
+        'text': zod_1.z.string()
+    })
+]);
+const message = zod_1.z.object({
+    source: zod_1.z.string(),
+    destination: zod_1.z.string(),
+    value: zod_1.z.string(),
+    fwd_fee: zod_1.z.string(),
+    ihr_fee: zod_1.z.string(),
+    created_lt: zod_1.z.string(),
+    body_hash: zod_1.z.string(),
+    msg_data: messageData
+});
+const transaction = zod_1.z.object({
+    data: zod_1.z.string(),
+    utime: zod_1.z.number(),
+    transaction_id: zod_1.z.object({
+        lt: zod_1.z.string(),
+        hash: zod_1.z.string()
+    }),
+    fee: zod_1.z.string(),
+    storage_fee: zod_1.z.string(),
+    other_fee: zod_1.z.string(),
+    in_msg: zod_1.z.union([zod_1.z.undefined(), message]),
+    out_msgs: zod_1.z.array(message)
+});
+const getTransactions = zod_1.z.array(transaction);
+const getMasterchain = zod_1.z.object({
+    state_root_hash: zod_1.z.string(),
+    last: blockIdExt,
+    init: blockIdExt
+});
+const getShards = zod_1.z.object({
+    shards: zod_1.z.array(blockIdExt)
+});
+const blockShortTxt = zod_1.z.object({
+    '@type': zod_1.z.literal('blocks.shortTxId'),
+    mode: zod_1.z.number(),
+    account: zod_1.z.string(),
+    lt: zod_1.z.string(),
+    hash: zod_1.z.string()
+});
+const getBlockTransactions = zod_1.z.object({
+    id: blockIdExt,
+    req_count: zod_1.z.number(),
+    incomplete: zod_1.z.boolean(),
+    transactions: zod_1.z.array(blockShortTxt)
+});
+class TypedCache {
+    constructor(namespace, cache, codec, keyEncoder) {
+        this.namespace = namespace;
+        this.cache = cache;
+        this.codec = codec;
+        this.keyEncoder = keyEncoder;
+    }
+    async get(key) {
+        let ex = await this.cache.get(this.namespace, this.keyEncoder(key));
+        if (ex) {
+            let decoded = this.codec.safeParse(JSON.parse(ex));
+            if (decoded.success) {
+                return decoded.data;
+            }
+        }
+        return null;
+    }
+    async set(key, value) {
+        if (value !== null) {
+            await this.cache.set(this.namespace, this.keyEncoder(key), JSON.stringify(value));
+        }
+        else {
+            await this.cache.set(this.namespace, this.keyEncoder(key), null);
+        }
+    }
+}
+class HttpApi {
+    constructor(endpoint, parameters) {
+        this.endpoint = endpoint;
+        this.cache = new TonCache_1.InMemoryCache();
+        this.parameters = {
+            timeout: parameters?.timeout || 30000,
+            apiKey: parameters?.apiKey
+        };
+        // Shard
+        this.shardCache = new TypedCache('ton-shard', this.cache, zod_1.z.array(blockIdExt), (src) => src + '');
+        this.shardLoader = new dataloader_1.default(async (src) => {
+            return await Promise.all(src.map(async (v) => {
+                const cached = await this.shardCache.get(v);
+                if (cached) {
+                    return cached;
+                }
+                let loaded = (await this.doCall('shards', { seqno: v }, getShards)).shards;
+                await this.shardCache.set(v, loaded);
+                return loaded;
+            }));
+        });
+        // Shard Transactions
+        this.shardTransactionsCache = new TypedCache('ton-shard-tx', this.cache, getBlockTransactions, (src) => src.workchain + ':' + src.shard + ':' + src.seqno);
+        this.shardTransactionsLoader = new dataloader_1.default(async (src) => {
+            return await Promise.all(src.map(async (v) => {
+                const cached = await this.shardTransactionsCache.get(v);
+                if (cached) {
+                    return cached;
+                }
+                let loaded = await this.doCall('getBlockTransactions', { workchain: v.workchain, seqno: v.seqno, shard: v.shard }, getBlockTransactions);
+                await this.shardTransactionsCache.set(v, loaded);
+                return loaded;
+            }));
+        }, { cacheKeyFn: (src) => src.workchain + ':' + src.shard + ':' + src.seqno });
+    }
+    getAddressInformation(address) {
+        return this.doCall('getAddressInformation', { address: address.toString() }, addressInformation);
+    }
+    async getTransactions(address, opts) {
+        const inclusive = opts.inclusive;
+        delete opts.inclusive;
+        // Convert hash
+        let hash = undefined;
+        if (opts.hash) {
+            hash = Buffer.from(opts.hash, 'base64').toString('hex');
+        }
+        // Adjust limit
+        let limit = opts.limit;
+        if (opts.hash && opts.lt && inclusive !== true) {
+            limit++;
+        }
+        // Do request
+        let res = await this.doCall('getTransactions', { address: address.toString(), ...opts, limit, hash }, getTransactions);
+        if (res.length > limit) {
+            res = res.slice(0, limit);
+        }
+        // Adjust result
+        if (opts.hash && opts.lt && inclusive !== true) {
+            res.shift();
+            return res;
+        }
+        else {
+            return res;
+        }
+    }
+    async getMasterchainInfo() {
+        return await this.doCall('getMasterchainInfo', {}, getMasterchain);
+    }
+    async getShards(seqno) {
+        return await this.shardLoader.load(seqno);
+    }
+    async getBlockTransactions(workchain, seqno, shard) {
+        return await this.shardTransactionsLoader.load({ workchain, seqno, shard });
+    }
+    async getTransaction(address, lt, hash) {
+        let convHash = Buffer.from(hash, 'base64').toString('hex');
+        let res = await this.doCall('getTransactions', { address: address.toString(), lt, hash: convHash, limit: 1 }, getTransactions);
+        let ex = res.find((v) => v.transaction_id.lt === lt && v.transaction_id.hash === hash);
+        if (ex) {
+            return ex;
+        }
+        else {
+            return null;
+        }
+    }
+    async callGetMethod(address, method, stack) {
+        return await this.doCall('runGetMethod', { address: address.toString(), method, stack: serializeStack(stack) }, callGetMethod);
+    }
+    async sendBoc(body) {
+        await this.doCall('sendBoc', { boc: body.toString('base64') }, bocResponse);
+    }
+    async estimateFee(address, args) {
+        return await this.doCall('estimateFee', {
+            address: address.toString(),
+            body: args.body.toBoc().toString('base64'),
+            'init_data': args.initData ? args.initData.toBoc().toString('base64') : '',
+            'init_code': args.initCode ? args.initCode.toBoc().toString('base64') : '',
+            ignore_chksig: args.ignoreSignature
+        }, feeResponse);
+    }
+    async doCall(method, body, codec) {
+        let headers = {
+            'Content-Type': 'application/json',
+            'X-Ton-Client-Version': version,
+        };
+        if (this.parameters.apiKey) {
+            headers['X-API-Key'] = this.parameters.apiKey;
+        }
+        let res = await axios_1.default.post(this.endpoint, JSON.stringify({
+            id: '1',
+            jsonrpc: '2.0',
+            method: method,
+            params: body
+        }), {
+            headers,
+            timeout: this.parameters.timeout,
+        });
+        if (res.status !== 200 || !res.data.ok) {
+            throw Error('Received error: ' + JSON.stringify(res.data));
+        }
+        let decoded = codec.safeParse(res.data.result);
+        if (decoded.success) {
+            return decoded.data;
+        }
+        else {
+            throw Error('Malformed response: ' + decoded.error.format()._errors.join(', '));
+        }
+    }
+}
+exports.HttpApi = HttpApi;
+function serializeStack(src) {
+    let stack = [];
+    for (let s of src) {
+        if (s.type === 'int') {
+            stack.push(['num', s.value.toString()]);
+        }
+        else if (s.type === 'cell') {
+            stack.push(['tvm.Cell', s.cell.toBoc().toString('base64')]);
+        }
+        else if (s.type === 'slice') {
+            stack.push(['tvm.Slice', s.cell.toBoc().toString('base64')]);
+        }
+        else if (s.type === 'builder') {
+            stack.push(['tvm.Builder', s.cell.toBoc().toString('base64')]);
+        }
+        else {
+            throw Error('Unsupported stack item type: ' + s.type);
+        }
+    }
+    return stack;
+}

package/dist/client/api/TonCache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 interface TonCache {
+    set(namespace: string, key: string, value: string | null): Promise<void>;
+    get(namespace: string, key: string): Promise<string | null>;
+}
+export declare class InMemoryCache implements TonCache {
+    private cache;
+    set: (namespace: string, key: string, value: string | null) => Promise<void>;
+    get: (namespace: string, key: string) => Promise<string | null>;
+}

package/dist/client/api/TonCache.js

@@ -0,0 +1,33 @@
+"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.InMemoryCache = void 0;
+class InMemoryCache {
+    constructor() {
+        this.cache = new Map();
+        this.set = async (namespace, key, value) => {
+            if (value !== null) {
+                this.cache.set(namespace + '$$' + key, value);
+            }
+            else {
+                this.cache.delete(namespace + '$$' + key);
+            }
+        };
+        this.get = async (namespace, key) => {
+            let res = this.cache.get(namespace + '$$' + key);
+            if (res !== undefined) {
+                return res;
+            }
+            else {
+                return null;
+            }
+        };
+    }
+}
+exports.InMemoryCache = InMemoryCache;

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 * from '@ton/core';
+export { HttpApi } from './client/api/HttpApi';
+export { TonClient } from './client/TonClient';
+export { TonClient4, TonClient4Parameters } from './client/TonClient4';
+export { WalletContractV1R1 } from './wallets/WalletContractV1R1';
+export { WalletContractV1R2 } from './wallets/WalletContractV1R2';
+export { WalletContractV1R3 } from './wallets/WalletContractV1R3';
+export { WalletContractV2R1 } from './wallets/WalletContractV2R1';
+export { WalletContractV2R2 } from './wallets/WalletContractV2R2';
+export { WalletContractV3R1 } from './wallets/WalletContractV3R1';
+export { WalletContractV3R2 } from './wallets/WalletContractV3R2';
+export { WalletContractV4 } from './wallets/WalletContractV4';
+export { JettonMaster } from './jetton/JettonMaster';
+export { JettonWallet } from './jetton/JettonWallet';
+export { MultisigOrder } from './multisig/MultisigOrder';
+export { MultisigOrderBuilder } from './multisig/MultisigOrderBuilder';
+export { MultisigWallet } from './multisig/MultisigWallet';

package/dist/index.js

@@ -0,0 +1,68 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultisigWallet = exports.MultisigOrderBuilder = exports.MultisigOrder = exports.JettonWallet = exports.JettonMaster = exports.WalletContractV4 = exports.WalletContractV3R2 = exports.WalletContractV3R1 = exports.WalletContractV2R2 = exports.WalletContractV2R1 = exports.WalletContractV1R3 = exports.WalletContractV1R2 = exports.WalletContractV1R1 = exports.TonClient4 = exports.TonClient = exports.HttpApi = void 0;
+__exportStar(require("@ton/core"), exports);
+//
+// toncenter Client
+//
+var HttpApi_1 = require("./client/api/HttpApi");
+Object.defineProperty(exports, "HttpApi", { enumerable: true, get: function () { return HttpApi_1.HttpApi; } });
+var TonClient_1 = require("./client/TonClient");
+Object.defineProperty(exports, "TonClient", { enumerable: true, get: function () { return TonClient_1.TonClient; } });
+//
+// API V4 Client
+//
+var TonClient4_1 = require("./client/TonClient4");
+Object.defineProperty(exports, "TonClient4", { enumerable: true, get: function () { return TonClient4_1.TonClient4; } });
+//
+// Wallets
+//
+var WalletContractV1R1_1 = require("./wallets/WalletContractV1R1");
+Object.defineProperty(exports, "WalletContractV1R1", { enumerable: true, get: function () { return WalletContractV1R1_1.WalletContractV1R1; } });
+var WalletContractV1R2_1 = require("./wallets/WalletContractV1R2");
+Object.defineProperty(exports, "WalletContractV1R2", { enumerable: true, get: function () { return WalletContractV1R2_1.WalletContractV1R2; } });
+var WalletContractV1R3_1 = require("./wallets/WalletContractV1R3");
+Object.defineProperty(exports, "WalletContractV1R3", { enumerable: true, get: function () { return WalletContractV1R3_1.WalletContractV1R3; } });
+var WalletContractV2R1_1 = require("./wallets/WalletContractV2R1");
+Object.defineProperty(exports, "WalletContractV2R1", { enumerable: true, get: function () { return WalletContractV2R1_1.WalletContractV2R1; } });
+var WalletContractV2R2_1 = require("./wallets/WalletContractV2R2");
+Object.defineProperty(exports, "WalletContractV2R2", { enumerable: true, get: function () { return WalletContractV2R2_1.WalletContractV2R2; } });
+var WalletContractV3R1_1 = require("./wallets/WalletContractV3R1");
+Object.defineProperty(exports, "WalletContractV3R1", { enumerable: true, get: function () { return WalletContractV3R1_1.WalletContractV3R1; } });
+var WalletContractV3R2_1 = require("./wallets/WalletContractV3R2");
+Object.defineProperty(exports, "WalletContractV3R2", { enumerable: true, get: function () { return WalletContractV3R2_1.WalletContractV3R2; } });
+var WalletContractV4_1 = require("./wallets/WalletContractV4");
+Object.defineProperty(exports, "WalletContractV4", { enumerable: true, get: function () { return WalletContractV4_1.WalletContractV4; } });
+//
+// Jettons
+//
+var JettonMaster_1 = require("./jetton/JettonMaster");
+Object.defineProperty(exports, "JettonMaster", { enumerable: true, get: function () { return JettonMaster_1.JettonMaster; } });
+var JettonWallet_1 = require("./jetton/JettonWallet");
+Object.defineProperty(exports, "JettonWallet", { enumerable: true, get: function () { return JettonWallet_1.JettonWallet; } });
+//
+// Multisig
+//
+var MultisigOrder_1 = require("./multisig/MultisigOrder");
+Object.defineProperty(exports, "MultisigOrder", { enumerable: true, get: function () { return MultisigOrder_1.MultisigOrder; } });
+var MultisigOrderBuilder_1 = require("./multisig/MultisigOrderBuilder");
+Object.defineProperty(exports, "MultisigOrderBuilder", { enumerable: true, get: function () { return MultisigOrderBuilder_1.MultisigOrderBuilder; } });
+var MultisigWallet_1 = require("./multisig/MultisigWallet");
+Object.defineProperty(exports, "MultisigWallet", { enumerable: true, get: function () { return MultisigWallet_1.MultisigWallet; } });

package/dist/jetton/JettonMaster.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { Address, Contract, ContractProvider } from "@ton/core";
+export declare class JettonMaster implements Contract {
+    static create(address: Address): JettonMaster;
+    readonly address: Address;
+    constructor(address: Address);
+    getWalletAddress(provider: ContractProvider, owner: Address): Promise<Address>;
+    getJettonData(provider: ContractProvider): Promise<{
+        totalSupply: bigint;
+        mintable: boolean;
+        adminAddress: Address;
+        content: import("@ton/core").Cell;
+        walletCode: import("@ton/core").Cell;
+    }>;
+}

package/dist/jetton/JettonMaster.js

@@ -0,0 +1,39 @@
+"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.JettonMaster = void 0;
+const core_1 = require("@ton/core");
+class JettonMaster {
+    constructor(address) {
+        this.address = address;
+    }
+    static create(address) {
+        return new JettonMaster(address);
+    }
+    async getWalletAddress(provider, owner) {
+        let res = await provider.get('get_wallet_address', [{ type: 'slice', cell: (0, core_1.beginCell)().storeAddress(owner).endCell() }]);
+        return res.stack.readAddress();
+    }
+    async getJettonData(provider) {
+        let res = await provider.get('get_jetton_data', []);
+        let totalSupply = res.stack.readBigNumber();
+        let mintable = res.stack.readBoolean();
+        let adminAddress = res.stack.readAddress();
+        let content = res.stack.readCell();
+        let walletCode = res.stack.readCell();
+        return {
+            totalSupply,
+            mintable,
+            adminAddress,
+            content,
+            walletCode
+        };
+    }
+}
+exports.JettonMaster = JettonMaster;

package/dist/jetton/JettonMaster.spec.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 {};

package/dist/jetton/JettonMaster.spec.js

@@ -0,0 +1,27 @@
+"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 });
+const core_1 = require("@ton/core");
+const createTestClient_1 = require("../utils/createTestClient");
+const JettonMaster_1 = require("./JettonMaster");
+const JettonWallet_1 = require("./JettonWallet");
+describe('JettonMaster', () => {
+    it('should resolve jetton wallet address', async () => {
+        let client = (0, createTestClient_1.createTestClient)('mainnet');
+        let master = client.open(JettonMaster_1.JettonMaster.create(core_1.Address.parse('EQDQoc5M3Bh8eWFephi9bClhevelbZZvWhkqdo80XuY_0qXv')));
+        let walletAddress = await master.getWalletAddress(core_1.Address.parse('EQCo6VT63H1vKJTiUo6W4M8RrTURCyk5MdbosuL5auEqpz-C'));
+        let jettonData = await master.getJettonData();
+        expect(walletAddress.equals(core_1.Address.parse('EQDslTlGmbLTFi0j4MPT7UVggWR7XRDI2bW6vmNG6Tc_FBDE'))).toBe(true);
+        expect(jettonData.mintable).toBe(true);
+        expect(jettonData.adminAddress.equals(core_1.Address.parse('EQCppzUtmGSMg3FIRlFLzhToqbaC0xjmjzOn0o7H4M8Aua1t'))).toBe(true);
+        let wallet = client.open(JettonWallet_1.JettonWallet.create(walletAddress));
+        let balance = await wallet.getBalance();
+        expect(balance).toBe(0n);
+    });
+});

package/dist/jetton/JettonWallet.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 { Address, Contract, ContractProvider } from "@ton/core";
+export declare class JettonWallet implements Contract {
+    static create(address: Address): JettonWallet;
+    readonly address: Address;
+    private constructor();
+    getBalance(provider: ContractProvider): Promise<bigint>;
+}

package/dist/jetton/JettonWallet.js

@@ -0,0 +1,27 @@
+"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.JettonWallet = void 0;
+class JettonWallet {
+    constructor(address) {
+        this.address = address;
+    }
+    static create(address) {
+        return new JettonWallet(address);
+    }
+    async getBalance(provider) {
+        let state = await provider.getState();
+        if (state.state.type !== 'active') {
+            return 0n;
+        }
+        let res = await provider.get('get_wallet_data', []);
+        return res.stack.readBigNumber();
+    }
+}
+exports.JettonWallet = JettonWallet;

package/dist/multisig/MultisigOrder.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import { Cell } from '@ton/core';
+import { MultisigWallet } from './MultisigWallet';
+export declare class MultisigOrder {
+    readonly payload: Cell;
+    signatures: {
+        [key: number]: Buffer;
+    };
+    private constructor();
+    static fromCell(cell: Cell): MultisigOrder;
+    static fromPayload(payload: Cell): MultisigOrder;
+    addSignature(ownerId: number, signature: Buffer, multisig: MultisigWallet): void;
+    sign(ownerId: number, secretKey: Buffer): Buffer;
+    unionSignatures(other: MultisigOrder): void;
+    clearSignatures(): void;
+    toCell(ownerId: number): Cell;
+}

package/dist/multisig/MultisigOrder.js

@@ -0,0 +1,73 @@
+"use strict";
+/* Made by @Gusarich and @Miandic */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultisigOrder = void 0;
+const crypto_1 = require("@ton/crypto");
+const core_1 = require("@ton/core");
+class MultisigOrder {
+    constructor(payload) {
+        this.signatures = {};
+        this.payload = payload;
+    }
+    static fromCell(cell) {
+        let s = cell.beginParse();
+        let signatures = s.loadMaybeRef()?.beginParse();
+        const messagesCell = s.asCell();
+        let order = new MultisigOrder(messagesCell);
+        if (signatures) {
+            while (signatures.remainingBits > 0) {
+                const signature = signatures.loadBuffer(64);
+                const ownerId = signatures.loadUint(8);
+                order.signatures[ownerId] = signature;
+                if (signatures.remainingRefs > 0) {
+                    signatures = signatures.loadRef().asSlice();
+                }
+                else {
+                    signatures.skip(1);
+                }
+            }
+            signatures.endParse();
+        }
+        return order;
+    }
+    static fromPayload(payload) {
+        return new MultisigOrder(payload);
+    }
+    addSignature(ownerId, signature, multisig) {
+        const signingHash = this.payload.hash();
+        if (!(0, crypto_1.signVerify)(signingHash, signature, multisig.owners.get(ownerId).slice(0, -1))) {
+            throw Error('invalid signature');
+        }
+        this.signatures[ownerId] = signature;
+    }
+    sign(ownerId, secretKey) {
+        const signingHash = this.payload.hash();
+        this.signatures[ownerId] = (0, crypto_1.sign)(signingHash, secretKey);
+        return signingHash;
+    }
+    unionSignatures(other) {
+        this.signatures = Object.assign({}, this.signatures, other.signatures);
+    }
+    clearSignatures() {
+        this.signatures = {};
+    }
+    toCell(ownerId) {
+        let b = (0, core_1.beginCell)().storeBit(0);
+        for (const ownerId in this.signatures) {
+            const signature = this.signatures[ownerId];
+            b = (0, core_1.beginCell)()
+                .storeBit(1)
+                .storeRef((0, core_1.beginCell)()
+                .storeBuffer(signature)
+                .storeUint(parseInt(ownerId), 8)
+                .storeBuilder(b)
+                .endCell());
+        }
+        return (0, core_1.beginCell)()
+            .storeUint(ownerId, 8)
+            .storeBuilder(b)
+            .storeBuilder(this.payload.asBuilder())
+            .endCell();
+    }
+}
+exports.MultisigOrder = MultisigOrder;

package/dist/multisig/MultisigOrder.spec.d.ts

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