@ton/ton 13.5.1

package/dist/client/TonClient4.js

@@ -0,0 +1,514 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _TonClient4_endpoint, _TonClient4_timeout, _TonClient4_adapter;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonClient4 = void 0;
+const axios_1 = __importDefault(require("axios"));
+const core_1 = require("@ton/core");
+const toUrlSafe_1 = require("../utils/toUrlSafe");
+const zod_1 = require("zod");
+class TonClient4 {
+    constructor(args) {
+        _TonClient4_endpoint.set(this, void 0);
+        _TonClient4_timeout.set(this, void 0);
+        _TonClient4_adapter.set(this, void 0);
+        __classPrivateFieldSet(this, _TonClient4_endpoint, args.endpoint, "f");
+        __classPrivateFieldSet(this, _TonClient4_timeout, args.timeout || 5000, "f");
+        __classPrivateFieldSet(this, _TonClient4_adapter, args.httpAdapter, "f");
+    }
+    /**
+     * Get Last Block
+     * @returns last block info
+     */
+    async getLastBlock() {
+        let res = await axios_1.default.get(__classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/block/latest', { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let lastBlock = lastBlockCodec.safeParse(res.data);
+        if (!lastBlock.success) {
+            throw Error('Mailformed response: ' + lastBlock.error.format()._errors.join(', '));
+        }
+        return lastBlock.data;
+    }
+    /**
+     * Get block info
+     * @param seqno block sequence number
+     * @returns block info
+     */
+    async getBlock(seqno) {
+        let res = await axios_1.default.get(__classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/block/' + seqno, { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let block = blockCodec.safeParse(res.data);
+        if (!block.success) {
+            throw Error('Mailformed response');
+        }
+        if (!block.data.exist) {
+            throw Error('Block is out of scope');
+        }
+        return block.data.block;
+    }
+    /**
+     * Get block info by unix timestamp
+     * @param ts unix timestamp
+     * @returns block info
+     */
+    async getBlockByUtime(ts) {
+        let res = await axios_1.default.get(__classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/block/utime/' + ts, { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let block = blockCodec.safeParse(res.data);
+        if (!block.success) {
+            throw Error('Mailformed response');
+        }
+        if (!block.data.exist) {
+            throw Error('Block is out of scope');
+        }
+        return block.data.block;
+    }
+    /**
+     * Get block info by unix timestamp
+     * @param seqno block sequence number
+     * @param address account address
+     * @returns account info
+     */
+    async getAccount(seqno, address) {
+        let res = await axios_1.default.get(__classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/block/' + seqno + '/' + address.toString({ urlSafe: true }), { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let account = accountCodec.safeParse(res.data);
+        if (!account.success) {
+            throw Error('Mailformed response');
+        }
+        return account.data;
+    }
+    /**
+     * Get account lite info (without code and data)
+     * @param seqno block sequence number
+     * @param address account address
+     * @returns account lite info
+     */
+    async getAccountLite(seqno, address) {
+        let res = await axios_1.default.get(__classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/block/' + seqno + '/' + address.toString({ urlSafe: true }) + '/lite', { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let account = accountLiteCodec.safeParse(res.data);
+        if (!account.success) {
+            throw Error('Mailformed response');
+        }
+        return account.data;
+    }
+    /**
+     * Check if contract is deployed
+     * @param address addres to check
+     * @returns true if contract is in active state
+     */
+    async isContractDeployed(seqno, address) {
+        let account = await this.getAccountLite(seqno, address);
+        return account.account.state.type === 'active';
+    }
+    /**
+     * Check if account was updated since
+     * @param seqno block sequence number
+     * @param address account address
+     * @param lt account last transaction lt
+     * @returns account change info
+     */
+    async isAccountChanged(seqno, address, lt) {
+        let res = await axios_1.default.get(__classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/block/' + seqno + '/' + address.toString({ urlSafe: true }) + '/changed/' + lt.toString(10), { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let changed = changedCodec.safeParse(res.data);
+        if (!changed.success) {
+            throw Error('Mailformed response');
+        }
+        return changed.data;
+    }
+    /**
+     * Load unparsed account transactions
+     * @param address address
+     * @param lt last transaction lt
+     * @param hash last transaction hash
+     * @returns unparsed transactions
+     */
+    async getAccountTransactions(address, lt, hash) {
+        let res = await axios_1.default.get(__classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/account/' + address.toString({ urlSafe: true }) + '/tx/' + lt.toString(10) + '/' + (0, toUrlSafe_1.toUrlSafe)(hash.toString('base64')), { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let transactions = transactionsCodec.safeParse(res.data);
+        if (!transactions.success) {
+            throw Error('Mailformed response');
+        }
+        let data = transactions.data;
+        let tx = [];
+        let cells = core_1.Cell.fromBoc(Buffer.from(data.boc, 'base64'));
+        for (let i = 0; i < data.blocks.length; i++) {
+            tx.push({
+                block: data.blocks[i],
+                tx: (0, core_1.loadTransaction)(cells[i].beginParse())
+            });
+        }
+        return tx;
+    }
+    /**
+     * Get network config
+     * @param seqno block sequence number
+     * @param ids optional config ids
+     * @returns network config
+     */
+    async getConfig(seqno, ids) {
+        let tail = '';
+        if (ids && ids.length > 0) {
+            tail = '/' + [...ids].sort().join(',');
+        }
+        let res = await axios_1.default.get(__classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/block/' + seqno + '/config' + tail, { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let config = configCodec.safeParse(res.data);
+        if (!config.success) {
+            throw Error('Mailformed response');
+        }
+        return config.data;
+    }
+    /**
+     * Execute run method
+     * @param seqno block sequence number
+     * @param address account address
+     * @param name method name
+     * @param args method arguments
+     * @returns method result
+     */
+    async runMethod(seqno, address, name, args) {
+        let tail = args && args.length > 0 ? '/' + (0, toUrlSafe_1.toUrlSafe)((0, core_1.serializeTuple)(args).toBoc({ idx: false, crc32: false }).toString('base64')) : '';
+        let url = __classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/block/' + seqno + '/' + address.toString({ urlSafe: true }) + '/run/' + name + tail;
+        let res = await axios_1.default.get(url, { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let runMethod = runMethodCodec.safeParse(res.data);
+        if (!runMethod.success) {
+            throw Error('Mailformed response');
+        }
+        let resultTuple = runMethod.data.resultRaw ? (0, core_1.parseTuple)(core_1.Cell.fromBoc(Buffer.from(runMethod.data.resultRaw, 'base64'))[0]) : [];
+        return {
+            exitCode: runMethod.data.exitCode,
+            result: resultTuple,
+            resultRaw: runMethod.data.resultRaw,
+            block: runMethod.data.block,
+            shardBlock: runMethod.data.shardBlock,
+            reader: new core_1.TupleReader(resultTuple),
+        };
+    }
+    /**
+     * Send external message
+     * @param message message boc
+     * @returns message status
+     */
+    async sendMessage(message) {
+        let res = await axios_1.default.post(__classPrivateFieldGet(this, _TonClient4_endpoint, "f") + '/send', { boc: message.toString('base64') }, { adapter: __classPrivateFieldGet(this, _TonClient4_adapter, "f"), timeout: __classPrivateFieldGet(this, _TonClient4_timeout, "f") });
+        let send = sendCodec.safeParse(res.data);
+        if (!send.success) {
+            throw Error('Mailformed response');
+        }
+        return { status: res.data.status };
+    }
+    /**
+     * Open smart contract
+     * @param contract contract
+     * @returns opened contract
+     */
+    open(contract) {
+        return (0, core_1.openContract)(contract, (args) => createProvider(this, null, args.address, args.init));
+    }
+    /**
+     * Open smart contract
+     * @param block block number
+     * @param contract contract
+     * @returns opened contract
+     */
+    openAt(block, contract) {
+        return (0, core_1.openContract)(contract, (args) => createProvider(this, block, args.address, args.init));
+    }
+    /**
+     * Create provider
+     * @param address address
+     * @param init optional init data
+     * @returns provider
+     */
+    provider(address, init) {
+        return createProvider(this, null, address, init ? init : null);
+    }
+    /**
+     * Create provider at specified block number
+     * @param block block number
+     * @param address address
+     * @param init optional init data
+     * @returns provider
+     */
+    providerAt(block, address, init) {
+        return createProvider(this, block, address, init ? init : null);
+    }
+}
+exports.TonClient4 = TonClient4;
+_TonClient4_endpoint = new WeakMap(), _TonClient4_timeout = new WeakMap(), _TonClient4_adapter = new WeakMap();
+function createProvider(client, block, address, init) {
+    return {
+        async getState() {
+            // Resolve block
+            let sq = block;
+            if (sq === null) {
+                let res = await client.getLastBlock();
+                sq = res.last.seqno;
+            }
+            // Load state
+            let state = await client.getAccount(sq, address);
+            // Convert state
+            let last = state.account.last ? { lt: BigInt(state.account.last.lt), hash: Buffer.from(state.account.last.hash, 'base64') } : null;
+            let storage;
+            if (state.account.state.type === 'active') {
+                storage = {
+                    type: 'active',
+                    code: state.account.state.code ? Buffer.from(state.account.state.code, 'base64') : null,
+                    data: state.account.state.data ? Buffer.from(state.account.state.data, 'base64') : null,
+                };
+            }
+            else if (state.account.state.type === 'uninit') {
+                storage = {
+                    type: 'uninit',
+                };
+            }
+            else if (state.account.state.type === 'frozen') {
+                storage = {
+                    type: 'frozen',
+                    stateHash: Buffer.from(state.account.state.stateHash, 'base64'),
+                };
+            }
+            else {
+                throw Error('Unsupported state');
+            }
+            return {
+                balance: BigInt(state.account.balance.coins),
+                last: last,
+                state: storage
+            };
+        },
+        async get(name, args) {
+            let sq = block;
+            if (sq === null) {
+                let res = await client.getLastBlock();
+                sq = res.last.seqno;
+            }
+            let method = await client.runMethod(sq, address, name, args);
+            if (method.exitCode !== 0 && method.exitCode !== 1) {
+                throw Error('Exit code: ' + method.exitCode);
+            }
+            return {
+                stack: new core_1.TupleReader(method.result),
+            };
+        },
+        async external(message) {
+            // Resolve last
+            let last = await client.getLastBlock();
+            // Resolve init
+            let neededInit = null;
+            if (init && (await client.getAccountLite(last.last.seqno, address)).account.state.type !== 'active') {
+                neededInit = init;
+            }
+            // Send with state init
+            const ext = (0, core_1.external)({
+                to: address,
+                init: neededInit ? { code: neededInit.code, data: neededInit.data } : null,
+                body: message
+            });
+            let pkg = (0, core_1.beginCell)()
+                .store((0, core_1.storeMessage)(ext))
+                .endCell()
+                .toBoc();
+            await client.sendMessage(pkg);
+        },
+        async internal(via, message) {
+            // Resolve last
+            let last = await client.getLastBlock();
+            // Resolve init
+            let neededInit = null;
+            if (init && (await client.getAccountLite(last.last.seqno, address)).account.state.type !== 'active') {
+                neededInit = init;
+            }
+            // Resolve bounce
+            let bounce = true;
+            if (message.bounce !== null && message.bounce !== undefined) {
+                bounce = message.bounce;
+            }
+            // Resolve value
+            let value;
+            if (typeof message.value === 'string') {
+                value = (0, core_1.toNano)(message.value);
+            }
+            else {
+                value = message.value;
+            }
+            // Resolve body
+            let body = null;
+            if (typeof message.body === 'string') {
+                body = (0, core_1.comment)(message.body);
+            }
+            else if (message.body) {
+                body = message.body;
+            }
+            // Send internal message
+            await via.send({
+                to: address,
+                value,
+                bounce,
+                sendMode: message.sendMode,
+                init: neededInit,
+                body
+            });
+        }
+    };
+}
+//
+// Codecs
+//
+const lastBlockCodec = zod_1.z.object({
+    last: zod_1.z.object({
+        seqno: zod_1.z.number(),
+        shard: zod_1.z.string(),
+        workchain: zod_1.z.number(),
+        fileHash: zod_1.z.string(),
+        rootHash: zod_1.z.string()
+    }),
+    init: zod_1.z.object({
+        fileHash: zod_1.z.string(),
+        rootHash: zod_1.z.string()
+    }),
+    stateRootHash: zod_1.z.string(),
+    now: zod_1.z.number()
+});
+const blockCodec = zod_1.z.union([zod_1.z.object({
+        exist: zod_1.z.literal(false)
+    }), zod_1.z.object({
+        exist: zod_1.z.literal(true),
+        block: zod_1.z.object({
+            shards: zod_1.z.array(zod_1.z.object({
+                workchain: zod_1.z.number(),
+                seqno: zod_1.z.number(),
+                shard: zod_1.z.string(),
+                rootHash: zod_1.z.string(),
+                fileHash: zod_1.z.string(),
+                transactions: zod_1.z.array(zod_1.z.object({
+                    account: zod_1.z.string(),
+                    hash: zod_1.z.string(),
+                    lt: zod_1.z.string()
+                }))
+            }))
+        })
+    })]);
+// {"lastPaid":1653099243,"duePayment":null,"used":{"bits":119,"cells":1,"publicCells":0}}
+const storageStatCodec = zod_1.z.object({
+    lastPaid: zod_1.z.number(),
+    duePayment: zod_1.z.union([zod_1.z.null(), zod_1.z.string()]),
+    used: zod_1.z.object({
+        bits: zod_1.z.number(),
+        cells: zod_1.z.number(),
+        publicCells: zod_1.z.number()
+    })
+});
+const accountCodec = zod_1.z.object({
+    account: zod_1.z.object({
+        state: zod_1.z.union([
+            zod_1.z.object({ type: zod_1.z.literal('uninit') }),
+            zod_1.z.object({ type: zod_1.z.literal('active'), code: zod_1.z.union([zod_1.z.string(), zod_1.z.null()]), data: zod_1.z.union([zod_1.z.string(), zod_1.z.null()]) }),
+            zod_1.z.object({ type: zod_1.z.literal('frozen'), stateHash: zod_1.z.string() })
+        ]),
+        balance: zod_1.z.object({
+            coins: zod_1.z.string()
+        }),
+        last: zod_1.z.union([
+            zod_1.z.null(),
+            zod_1.z.object({
+                lt: zod_1.z.string(),
+                hash: zod_1.z.string()
+            })
+        ]),
+        storageStat: zod_1.z.union([zod_1.z.null(), storageStatCodec])
+    }),
+    block: zod_1.z.object({
+        workchain: zod_1.z.number(),
+        seqno: zod_1.z.number(),
+        shard: zod_1.z.string(),
+        rootHash: zod_1.z.string(),
+        fileHash: zod_1.z.string()
+    })
+});
+const accountLiteCodec = zod_1.z.object({
+    account: zod_1.z.object({
+        state: zod_1.z.union([
+            zod_1.z.object({ type: zod_1.z.literal('uninit') }),
+            zod_1.z.object({ type: zod_1.z.literal('active'), codeHash: zod_1.z.string(), dataHash: zod_1.z.string() }),
+            zod_1.z.object({ type: zod_1.z.literal('frozen'), stateHash: zod_1.z.string() })
+        ]),
+        balance: zod_1.z.object({
+            coins: zod_1.z.string()
+        }),
+        last: zod_1.z.union([
+            zod_1.z.null(),
+            zod_1.z.object({
+                lt: zod_1.z.string(),
+                hash: zod_1.z.string()
+            })
+        ]),
+        storageStat: zod_1.z.union([zod_1.z.null(), storageStatCodec])
+    })
+});
+const changedCodec = zod_1.z.object({
+    changed: zod_1.z.boolean(),
+    block: zod_1.z.object({
+        workchain: zod_1.z.number(),
+        seqno: zod_1.z.number(),
+        shard: zod_1.z.string(),
+        rootHash: zod_1.z.string(),
+        fileHash: zod_1.z.string()
+    })
+});
+const runMethodCodec = zod_1.z.object({
+    exitCode: zod_1.z.number(),
+    resultRaw: zod_1.z.union([zod_1.z.string(), zod_1.z.null()]),
+    block: zod_1.z.object({
+        workchain: zod_1.z.number(),
+        seqno: zod_1.z.number(),
+        shard: zod_1.z.string(),
+        rootHash: zod_1.z.string(),
+        fileHash: zod_1.z.string()
+    }),
+    shardBlock: zod_1.z.object({
+        workchain: zod_1.z.number(),
+        seqno: zod_1.z.number(),
+        shard: zod_1.z.string(),
+        rootHash: zod_1.z.string(),
+        fileHash: zod_1.z.string()
+    })
+});
+const configCodec = zod_1.z.object({
+    config: zod_1.z.object({
+        cell: zod_1.z.string(),
+        address: zod_1.z.string(),
+        globalBalance: zod_1.z.object({
+            coins: zod_1.z.string()
+        })
+    })
+});
+const sendCodec = zod_1.z.object({
+    status: zod_1.z.number()
+});
+const transactionsCodec = zod_1.z.object({
+    blocks: zod_1.z.array(zod_1.z.object({
+        workchain: zod_1.z.number(),
+        seqno: zod_1.z.number(),
+        shard: zod_1.z.string(),
+        rootHash: zod_1.z.string(),
+        fileHash: zod_1.z.string()
+    })),
+    boc: zod_1.z.string()
+});

package/dist/client/TonClient4.spec.d.ts

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

package/dist/client/TonClient4.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@ton/core");
+const TonClient4_1 = require("./TonClient4");
+let describeConditional = process.env.TEST_CLIENTS ? describe : describe.skip;
+describeConditional('TonClient', () => {
+    let client = new TonClient4_1.TonClient4({
+        endpoint: 'https://mainnet-v4.tonhubapi.com',
+    });
+    const testAddress = core_1.Address.parse('EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N');
+    let seqno;
+    beforeAll(async () => {
+        let last = await client.getLastBlock();
+        seqno = last.last.seqno;
+    });
+    it('should get account with transactions', async () => {
+        let account = await client.getAccount(seqno, testAddress);
+        let accountLite = await client.getAccountLite(seqno, testAddress);
+        let transactions = await client.getAccountTransactions(testAddress, BigInt(accountLite.account.last.lt), Buffer.from(accountLite.account.last.hash, 'base64'));
+        let result = await client.isAccountChanged(seqno, testAddress, BigInt(accountLite.account.last.lt));
+        console.log(transactions, result);
+        console.log(account, accountLite);
+    });
+    it('should get config', async () => {
+        let config = await client.getConfig(seqno);
+        console.log(config);
+    });
+    it('should get block', async () => {
+        let result = await client.getBlock(seqno);
+        console.log(result);
+    });
+    it('should run method', async () => {
+        let result = await client.runMethod(seqno, testAddress, 'seqno');
+        console.log(result);
+    });
+});