@meow-laika/ton-lite-client 3.2.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright 
+
+(c) 2022-2023 Whales Corp.
+(c) 2023 TrueCarry <truecarry@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+## ton-lite-client
+
+ton-lite-client is a JS library that allows you to get information from TON Blockchain through it's native ADNL protocol.
+
+To get servers list, use official urls:
+- Mainnet: https://ton.org/global.config.json
+- Testnet: https://ton.org/testnet-global.config.json
+
+Example of getting account state:
+```typescript
+import { LiteClient, LiteRoundRobinEngine, LiteSingleEngine, LiteEngine } from "ton-lite-client";
+import { Address } from "@ton/core";
+
+function intToIP(int: number) {
+    var part1 = int & 255;
+    var part2 = ((int >> 8) & 255);
+    var part3 = ((int >> 16) & 255);
+    var part4 = ((int >> 24) & 255);
+
+    return part4 + "." + part3 + "." + part2 + "." + part1;
+}
+
+let server = {
+    "ip": 1097649206,
+    "port": 29296,
+    "id": {
+        "@type": "pub.ed25519",
+        "key": "p2tSiaeSqX978BxE5zLxuTQM06WVDErf5/15QToxMYA="
+    }
+}
+
+async function main() {
+    const engines: LiteEngine[] = [];
+    engines.push(new LiteSingleEngine({
+        host: `tcp://${intToIP(server.ip)}:${server.port}`,
+        publicKey: Buffer.from(server.id.key, 'base64'),
+    }));
+    const engine: LiteEngine = new LiteRoundRobinEngine(engines);
+    const client = new LiteClient({ engine });
+    console.log('get master info')
+    const master = await client.getMasterchainInfo()
+    console.log('master', master)
+
+    const address = Address.parse('kQC2sf_Hy34aMM7n9f9_V-ThHDehjH71LWBETy_JrTirPIHa');
+    const accountState = await client.getAccountState(address, master.last)
+    console.log('Account state:', accountState)
+}
+
+main()
+```
+
+By default, LiteClient uses cache for 4 things: blocks, blockHeaders, shards, account states at given block. All caches are LRU maps with capacity of 1000 elements. If your use case needs different caching strategy - you can bring your own map.
+
+
+For example, you can cap every map at 100 000 elements:
+```typescript
+const client = new LiteClient({
+    engine,
+    cacheMap: 100000,
+});
+```
+
+Or you can cache only account states (not recommended, just example):
+```typescript
+const client = new LiteClient({
+    engine, cacheMap: (kind) => {
+        if (kind === 'accounts') {
+            return new Map()
+        }
+
+        return {
+            get(key) { },
+            set(key, value) { },
+            delete(key: any) { },
+            clear() { },
+        }
+    }
+});
+```
+

package/dist/client.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Copyright
+ *  (c) 2022 Whales Corp.
+ *  (c) 2023 TrueCarry <truecarry@gmail.com>
+ * 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.
+ */
+/// <reference types="node" />
+import { Address, Contract, StateInit } from "@ton/core";
+import { LiteEngine } from "./engines/engine";
+import { liteServer_blockHeader, liteServer_transactionId3 } from "./schema";
+import { AllShardsResponse, BlockID, CacheMap, ClientAccountState, QueryArgs } from "./types";
+type MapKind = 'block' | 'header' | 'shard' | 'account';
+export declare class LiteClient {
+    #private;
+    readonly engine: LiteEngine;
+    constructor(opts: {
+        engine: LiteEngine;
+        batchSize?: number | undefined | null;
+        cacheMap?: number | ((mapKind: MapKind) => CacheMap);
+    });
+    /**
+     * Open a contract
+     * @param contract
+     */
+    open<T extends Contract>(contract: T): import("@ton/core").OpenedContract<T>;
+    /**
+     * Create a new contract provider
+     * @param address
+     * @param init
+     */
+    provider(address: Address, init?: StateInit | null): import("@ton/core").ContractProvider;
+    sendMessage: (src: Buffer) => Promise<{
+        status: number;
+    }>;
+    getMasterchainInfo: (queryArgs?: QueryArgs) => Promise<import("./schema").liteServer_masterchainInfo>;
+    getMasterchainInfoExt: (queryArgs?: QueryArgs) => Promise<import("./schema").liteServer_masterchainInfoExt>;
+    getCurrentTime: (queryArgs?: QueryArgs) => Promise<number>;
+    getVersion: (queryArgs?: QueryArgs) => Promise<import("./schema").liteServer_version>;
+    getConfig: (block: BlockID, queryArgs?: QueryArgs) => Promise<import("@ton/core").MasterchainStateExtra>;
+    getAccountState: (src: Address, block: BlockID) => Promise<ClientAccountState>;
+    getAccountStateRaw: (src: Address, block: BlockID, queryArgs?: QueryArgs) => Promise<ClientAccountState>;
+    getAccountStatePrunned: (src: Address, block: BlockID, queryArgs?: QueryArgs) => Promise<{
+        stateHash: Buffer | null;
+        raw: Buffer;
+        proof: Buffer;
+        block: import("./schema").tonNode_blockIdExt;
+        shardBlock: import("./schema").tonNode_blockIdExt;
+        shardProof: Buffer;
+    }>;
+    getAccountTransaction: (src: Address, lt: string, block: BlockID, queryArgs?: QueryArgs) => Promise<import("./schema").liteServer_transactionInfo>;
+    getAccountTransactions: (src: Address, lt: string, hash: Buffer, count: number, queryArgs?: QueryArgs) => Promise<{
+        ids: import("./schema").tonNode_blockIdExt[];
+        transactions: Buffer;
+    }>;
+    runMethod: (src: Address, method: string, params: Buffer, block: BlockID, queryArgs?: QueryArgs) => Promise<{
+        exitCode: number;
+        result: string | null;
+        block: {
+            seqno: number;
+            shard: string;
+            workchain: number;
+            rootHash: Buffer;
+            fileHash: Buffer;
+        };
+        shardBlock: {
+            seqno: number;
+            shard: string;
+            workchain: number;
+            rootHash: Buffer;
+            fileHash: Buffer;
+        };
+    }>;
+    lookupBlockByID: (block: {
+        seqno: number;
+        shard: string;
+        workchain: number;
+    }) => Promise<liteServer_blockHeader>;
+    lookupBlockByUtime: (block: {
+        shard: string;
+        workchain: number;
+        utime: number;
+    }) => Promise<liteServer_blockHeader>;
+    lookupBlockByLt: (block: {
+        shard: string;
+        workchain: number;
+        lt: bigint;
+    }) => Promise<liteServer_blockHeader>;
+    getBlockHeader: (block: BlockID) => Promise<liteServer_blockHeader>;
+    getAllShardsInfo: (block: BlockID) => Promise<AllShardsResponse>;
+    listBlockTransactions: (block: BlockID, args?: {
+        mode: number;
+        count: number;
+        after?: liteServer_transactionId3 | null | undefined;
+        wantProof?: boolean;
+    }, queryArgs?: QueryArgs) => Promise<import("./schema").liteServer_blockTransactions>;
+    listBlockTransactionsExt: (block: BlockID, args?: {
+        mode: number;
+        count: number;
+        after?: liteServer_transactionId3 | null | undefined;
+        wantProof?: boolean;
+    }, queryArgs?: QueryArgs) => Promise<import("./schema").liteServer_blockTransactionsExt>;
+    getFullBlock: (seqno: number) => Promise<{
+        shards: {
+            rootHash: Buffer;
+            fileHash: Buffer;
+            transactions: {
+                hash: Buffer;
+                lt: string;
+                account: Buffer;
+            }[];
+            workchain: number;
+            seqno: number;
+            shard: string;
+        }[];
+    }>;
+    getLibraries: (hashes: Buffer[], queryArgs?: QueryArgs) => Promise<import("./schema").liteServer_libraryResult>;
+}
+export {};