@meow-laika/ton-lite-client 3.2.0

package/dist/engines/roundRobin.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * 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.
+ */
+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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _LiteRoundRobinEngine_closed, _LiteRoundRobinEngine_counter;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteRoundRobinEngine = void 0;
+const events_1 = __importDefault(require("events"));
+class LiteRoundRobinEngine extends events_1.default {
+    constructor(engines) {
+        super();
+        this.allEngines = [];
+        this.readyEngines = [];
+        _LiteRoundRobinEngine_closed.set(this, false);
+        _LiteRoundRobinEngine_counter.set(this, 0);
+        for (const engine of engines) {
+            this.addSingleEngine(engine);
+        }
+    }
+    addSingleEngine(engine) {
+        const existing = this.allEngines.find(e => e === engine);
+        if (existing) {
+            throw new Error('Engine already exists');
+        }
+        this.allEngines.push(engine);
+        engine.on('ready', () => {
+            this.readyEngines.push(engine);
+        });
+        engine.on('close', () => {
+            this.readyEngines = this.readyEngines.filter(e => e !== engine);
+        });
+        engine.on('error', () => {
+            this.readyEngines = this.readyEngines.filter(e => e !== engine);
+        });
+        if (engine.isReady()) {
+            this.readyEngines.push(engine);
+        }
+    }
+    async query(f, req, args) {
+        var _a, _b;
+        if (__classPrivateFieldGet(this, _LiteRoundRobinEngine_closed, "f")) {
+            throw new Error('Engine is closed');
+        }
+        let attempts = 0;
+        let id = ((__classPrivateFieldSet(this, _LiteRoundRobinEngine_counter, (_b = __classPrivateFieldGet(this, _LiteRoundRobinEngine_counter, "f"), _a = _b++, _b), "f"), _a) % this.readyEngines.length) || 0;
+        let errorsCount = 0;
+        while (true) {
+            if (!this.readyEngines[id]?.isReady()) {
+                id = ((id + 1) % this.readyEngines.length) || 0;
+                attempts++;
+                if (attempts >= this.readyEngines.length) {
+                    await delay(100);
+                }
+                if (attempts > 200) {
+                    throw new Error('No engines are available');
+                }
+                continue;
+            }
+            try {
+                const res = await this.readyEngines[id].query(f, req, args);
+                return res;
+            }
+            catch (e) {
+                id = ((id + 1) % this.readyEngines.length) || 0;
+                if (e instanceof Error && e.message === 'Timeout') {
+                    continue;
+                }
+                errorsCount++;
+                if (errorsCount > 20) {
+                    throw e;
+                }
+                await delay(100);
+            }
+        }
+    }
+    close() {
+        for (let q of this.allEngines) {
+            q.close();
+        }
+        __classPrivateFieldSet(this, _LiteRoundRobinEngine_closed, true, "f");
+    }
+    isClosed() {
+        return __classPrivateFieldGet(this, _LiteRoundRobinEngine_closed, "f");
+    }
+    isReady() {
+        return !__classPrivateFieldGet(this, _LiteRoundRobinEngine_closed, "f");
+    }
+}
+exports.LiteRoundRobinEngine = LiteRoundRobinEngine;
+_LiteRoundRobinEngine_closed = new WeakMap(), _LiteRoundRobinEngine_counter = new WeakMap();
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/engines/single.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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" />
+/// <reference types="node" />
+import { TLFunction } from "ton-tl";
+import { LiteEngine } from "./engine";
+import EventEmitter from "events";
+export declare class LiteSingleEngine extends EventEmitter implements LiteEngine {
+    #private;
+    readonly host: string;
+    readonly publicKey: Buffer;
+    constructor(args: {
+        host: string;
+        publicKey: Buffer;
+        client?: 'tcp' | 'ws';
+        reconnectTimeout?: number;
+    });
+    isClosed(): boolean;
+    isReady(): boolean;
+    query<REQ, RES>(f: TLFunction<REQ, RES>, req: REQ, queryArgs?: {
+        timeout?: number;
+        awaitSeqno?: number;
+    }): Promise<RES>;
+    close(): void;
+    private connect;
+    private onConencted;
+    private onReady;
+    private onData;
+    private onClosed;
+}

package/dist/engines/single.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * 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.
+ */
+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 _LiteSingleEngine_currentClient, _LiteSingleEngine_ready, _LiteSingleEngine_closed, _LiteSingleEngine_queries, _LiteSingleEngine_clientType, _LiteSingleEngine_reconnectTimeout;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteSingleEngine = void 0;
+const tweetnacl_1 = require("tweetnacl");
+const ton_tl_1 = require("ton-tl");
+const adnl_1 = require("adnl");
+const schema_1 = require("../schema");
+const events_1 = __importDefault(require("events"));
+const defaultArgs = { timeout: 5000 };
+class LiteSingleEngine extends events_1.default {
+    constructor(args) {
+        super();
+        _LiteSingleEngine_currentClient.set(this, null);
+        _LiteSingleEngine_ready.set(this, false);
+        _LiteSingleEngine_closed.set(this, true);
+        _LiteSingleEngine_queries.set(this, new Map());
+        _LiteSingleEngine_clientType.set(this, void 0);
+        _LiteSingleEngine_reconnectTimeout.set(this, void 0);
+        this.onConencted = () => {
+            __classPrivateFieldSet(this, _LiteSingleEngine_closed, false, "f");
+        };
+        this.onReady = () => {
+            __classPrivateFieldSet(this, _LiteSingleEngine_ready, true, "f");
+            // Write all pendings
+            for (let q of __classPrivateFieldGet(this, _LiteSingleEngine_queries, "f")) {
+                __classPrivateFieldGet(this, _LiteSingleEngine_currentClient, "f").write(q[1].packet);
+            }
+        };
+        this.onData = (data) => {
+            let answer = schema_1.Codecs.adnl_Message.decode(new ton_tl_1.TLReadBuffer(data));
+            if (answer.kind === 'adnl.message.answer') {
+                let id = answer.queryId.toString('hex');
+                let q = __classPrivateFieldGet(this, _LiteSingleEngine_queries, "f").get(id);
+                if (q) {
+                    __classPrivateFieldGet(this, _LiteSingleEngine_queries, "f").delete(id);
+                    // Decode response
+                    if (answer.answer.readInt32LE(0) === -1146494648) {
+                        q.reject(new Error(schema_1.Codecs.liteServer_Error.decode(new ton_tl_1.TLReadBuffer(answer.answer)).message));
+                    }
+                    else {
+                        try {
+                            let decoded = q.f.decodeResponse(new ton_tl_1.TLReadBuffer(answer.answer));
+                            // Resolve
+                            q.resolver(decoded);
+                        }
+                        catch (e) {
+                            // Reject
+                            q.reject(e);
+                        }
+                    }
+                }
+            }
+        };
+        this.onClosed = () => {
+            __classPrivateFieldSet(this, _LiteSingleEngine_currentClient, null, "f");
+            __classPrivateFieldSet(this, _LiteSingleEngine_ready, false, "f");
+            setTimeout(() => {
+                if (!__classPrivateFieldGet(this, _LiteSingleEngine_closed, "f")) {
+                    this.connect();
+                }
+            }, __classPrivateFieldGet(this, _LiteSingleEngine_reconnectTimeout, "f"));
+        };
+        this.host = args.host;
+        this.publicKey = args.publicKey;
+        __classPrivateFieldSet(this, _LiteSingleEngine_clientType, args.client || 'tcp', "f");
+        __classPrivateFieldSet(this, _LiteSingleEngine_reconnectTimeout, args.reconnectTimeout || 10000, "f");
+        this.connect();
+    }
+    isClosed() {
+        return __classPrivateFieldGet(this, _LiteSingleEngine_closed, "f");
+    }
+    isReady() {
+        return __classPrivateFieldGet(this, _LiteSingleEngine_ready, "f");
+    }
+    async query(f, req, queryArgs) {
+        if (__classPrivateFieldGet(this, _LiteSingleEngine_closed, "f")) {
+            throw new Error('Engine is closed');
+        }
+        const args = { ...defaultArgs, ...queryArgs };
+        let id = Buffer.from((0, tweetnacl_1.randomBytes)(32));
+        // Request
+        let writer = new ton_tl_1.TLWriteBuffer();
+        if (args.awaitSeqno !== undefined) {
+            schema_1.Functions.liteServer_waitMasterchainSeqno.encodeRequest({ kind: 'liteServer.waitMasterchainSeqno', seqno: args.awaitSeqno, timeoutMs: args.timeout }, writer);
+        }
+        f.encodeRequest(req, writer);
+        let body = writer.build();
+        // Lite server query
+        let lsQuery = new ton_tl_1.TLWriteBuffer();
+        schema_1.Functions.liteServer_query.encodeRequest({ kind: 'liteServer.query', data: body }, lsQuery);
+        let lsbody = lsQuery.build();
+        // ADNL body
+        let adnlWriter = new ton_tl_1.TLWriteBuffer();
+        schema_1.Codecs.adnl_Message.encode({ kind: 'adnl.message.query', queryId: id, query: lsbody }, adnlWriter);
+        const packet = adnlWriter.build();
+        return new Promise((resolve, reject) => {
+            // Send
+            if (__classPrivateFieldGet(this, _LiteSingleEngine_ready, "f")) {
+                __classPrivateFieldGet(this, _LiteSingleEngine_currentClient, "f").write(packet);
+            }
+            // Register query
+            __classPrivateFieldGet(this, _LiteSingleEngine_queries, "f").set(id.toString('hex'), { resolver: resolve, reject, f, packet, timeout: args.timeout });
+            // Query timeout
+            setTimeout(() => {
+                let ex = __classPrivateFieldGet(this, _LiteSingleEngine_queries, "f").get(id.toString('hex'));
+                if (ex) {
+                    __classPrivateFieldGet(this, _LiteSingleEngine_queries, "f").delete(id.toString('hex'));
+                    ex.reject(new Error('Timeout'));
+                }
+            }, args.timeout);
+        });
+    }
+    close() {
+        __classPrivateFieldSet(this, _LiteSingleEngine_closed, true, "f");
+        if (__classPrivateFieldGet(this, _LiteSingleEngine_currentClient, "f")) {
+            let c = __classPrivateFieldGet(this, _LiteSingleEngine_currentClient, "f");
+            __classPrivateFieldSet(this, _LiteSingleEngine_ready, false, "f");
+            __classPrivateFieldSet(this, _LiteSingleEngine_currentClient, null, "f");
+            c.end();
+        }
+    }
+    connect() {
+        // Configure new client
+        const client = __classPrivateFieldGet(this, _LiteSingleEngine_clientType, "f") === 'ws' ? new adnl_1.ADNLClientWS(this.host, this.publicKey) : new adnl_1.ADNLClientTCP(this.host, this.publicKey);
+        client.connect();
+        client.on('connect', () => {
+            if (__classPrivateFieldGet(this, _LiteSingleEngine_currentClient, "f") === client) {
+                this.onConencted();
+                this.emit('connect');
+            }
+        });
+        client.on('close', () => {
+            if (__classPrivateFieldGet(this, _LiteSingleEngine_currentClient, "f") === client) {
+                this.onClosed();
+                this.emit('close');
+            }
+        });
+        client.on('data', (data) => {
+            if (__classPrivateFieldGet(this, _LiteSingleEngine_currentClient, "f") === client) {
+                this.onData(data);
+            }
+        });
+        client.on('ready', async () => {
+            if (__classPrivateFieldGet(this, _LiteSingleEngine_currentClient, "f") === client) {
+                this.onReady();
+                this.emit('ready');
+            }
+        });
+        client.on('error', (err) => {
+            this.close();
+            this.emit('error');
+            setTimeout(() => {
+                __classPrivateFieldSet(this, _LiteSingleEngine_closed, false, "f");
+                this.connect();
+            }, 30000);
+        });
+        // Persist client
+        __classPrivateFieldSet(this, _LiteSingleEngine_currentClient, client, "f");
+    }
+}
+exports.LiteSingleEngine = LiteSingleEngine;
+_LiteSingleEngine_currentClient = new WeakMap(), _LiteSingleEngine_ready = new WeakMap(), _LiteSingleEngine_closed = new WeakMap(), _LiteSingleEngine_queries = new WeakMap(), _LiteSingleEngine_clientType = new WeakMap(), _LiteSingleEngine_reconnectTimeout = new WeakMap();

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 { LiteClient } from './client';
+export { LiteEngine } from './engines/engine';
+export { LiteSingleEngine } from './engines/single';
+export { LiteRoundRobinEngine } from './engines/roundRobin';
+export type { AccountsDataLoaderKey, BlockID, BlockLookupIDRequest, BlockLookupUtimeRequest, CacheMap, AllShardsResponse, ClientAccountState, QueryArgs } from './types';

package/dist/index.js

@@ -0,0 +1,16 @@
+"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.LiteRoundRobinEngine = exports.LiteSingleEngine = exports.LiteClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "LiteClient", { enumerable: true, get: function () { return client_1.LiteClient; } });
+var single_1 = require("./engines/single");
+Object.defineProperty(exports, "LiteSingleEngine", { enumerable: true, get: function () { return single_1.LiteSingleEngine; } });
+var roundRobin_1 = require("./engines/roundRobin");
+Object.defineProperty(exports, "LiteRoundRobinEngine", { enumerable: true, get: function () { return roundRobin_1.LiteRoundRobinEngine; } });

package/dist/liteClientProvider.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ */
+import { Address, ContractProvider, StateInit } from '@ton/core';
+import { LiteClient } from './';
+export declare function createLiteClientProvider(client: LiteClient, block: number | null, address: Address, init: StateInit | null): ContractProvider;

package/dist/liteClientProvider.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLiteClientProvider = void 0;
+/* eslint-disable camelcase */
+const core_1 = require("@ton/core");
+const buffer_1 = require("buffer");
+const bigint_1 = require("./utils/bigint");
+function createLiteClientProvider(client, block, address, init) {
+    return {
+        async getState() {
+            // Resolve block
+            let sq; // = block
+            if (block === null) {
+                const res = await client.getMasterchainInfo();
+                sq = res.last;
+            }
+            else {
+                const res = await client.getFullBlock(block);
+                const shard = res.shards.find((s) => s.workchain === -1);
+                sq = {
+                    ...shard,
+                };
+            }
+            // Load state
+            // const state = await client.getAccount(sq, address)
+            const state = await client.getAccountState(address, sq);
+            // Convert state
+            const last = state.lastTx // .account.last
+                ? {
+                    lt: BigInt(state.lastTx.lt),
+                    hash: (0, bigint_1.txHashToBuffer)(state.lastTx.hash),
+                }
+                : null;
+            let storage;
+            if (state.state?.storage.state.type === 'active') {
+                storage = {
+                    type: 'active',
+                    code: state.state?.storage.state.state.code?.toBoc(),
+                    data: state.state?.storage.state.state.data?.toBoc(),
+                };
+            }
+            else if (state.state?.storage.state.type === 'uninit') {
+                storage = {
+                    type: 'uninit',
+                };
+                //
+            }
+            else if (state.state?.storage.state.type === 'frozen') {
+                storage = {
+                    type: 'frozen',
+                    stateHash: (0, bigint_1.txHashToBuffer)(state.state.storage.state.stateHash),
+                };
+            }
+            else {
+                throw Error('Unsupported state');
+            }
+            return {
+                balance: BigInt(state.state.storage.balance.coins),
+                last,
+                state: storage,
+            };
+        },
+        async get(name, args) {
+            let sq; // = block
+            if (block === null) {
+                const res = await client.getMasterchainInfo();
+                sq = res.last;
+            }
+            else {
+                const res = await client.getFullBlock(block);
+                const shard = res.shards.find((s) => s.workchain === -1);
+                sq = {
+                    ...shard,
+                };
+            }
+            // const method = await client.runMethod(address, name, args, sq)c
+            const method = await runMethod(client, 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) {
+            const res = await client.getMasterchainInfo();
+            const sq = res.last;
+            // Resolve init
+            let neededInit = null;
+            if (init &&
+                (await client.getAccountState(address, sq)).state?.storage.state.type !== 'active') {
+                neededInit = init;
+            }
+            const ext = (0, core_1.external)({
+                to: address,
+                init: neededInit ?? null,
+                body: message,
+            });
+            const pkg = (0, core_1.beginCell)().store((0, core_1.storeMessage)(ext)).endCell().toBoc();
+            await client.sendMessage(pkg);
+        },
+        async internal(via, message) {
+            const res = await client.getMasterchainInfo();
+            const sq = res.last;
+            // Resolve init
+            let neededInit = null;
+            if (init &&
+                (await client.getAccountState(address, sq)).state?.storage.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,
+            });
+        },
+        open(contract) {
+            return (0, core_1.openContract)(contract, (args) => createLiteClientProvider(client, block, args.address, args.init));
+        },
+        async getTransactions(address, lt, hash, limit) {
+            // Resolve last
+            const useLimit = typeof limit === 'number';
+            if (useLimit && limit <= 0) {
+                return [];
+            }
+            // Load transactions
+            let transactions = [];
+            do {
+                const result = await client.getAccountTransactions(address, lt.toString(), hash, limit ?? 100);
+                const txs = core_1.Cell.fromBoc(result.transactions).map((tx) => (0, core_1.loadTransaction)(tx.beginParse()));
+                const firstTx = txs[0];
+                const [firstLt, firstHash] = [firstTx.lt, firstTx.hash()];
+                const needSkipFirst = transactions.length > 0 && firstLt === lt && firstHash.equals(hash);
+                if (needSkipFirst) {
+                    txs.shift();
+                }
+                if (txs.length === 0) {
+                    break;
+                }
+                const lastTx = txs[txs.length - 1];
+                const [lastLt, lastHash] = [lastTx.lt, lastTx.hash()];
+                if (lastLt === lt && lastHash.equals(hash)) {
+                    break;
+                }
+                transactions.push(...txs);
+                lt = lastLt;
+                hash = lastHash;
+            } while (useLimit && transactions.length < limit);
+            // Apply limit
+            if (useLimit) {
+                transactions = transactions.slice(0, limit);
+            }
+            // Return transactions
+            return transactions;
+        }
+    };
+}
+exports.createLiteClientProvider = createLiteClientProvider;
+/**
+ * Execute run method
+ * @param seqno block sequence number
+ * @param address account address
+ * @param name method name
+ * @param args method arguments
+ * @returns method result
+ */
+async function runMethod(clinet, seqno, address, name, args) {
+    const tail = args ? (0, core_1.serializeTuple)(args).toBoc({ idx: false, crc32: false }) : buffer_1.Buffer.alloc(0);
+    const res = await clinet.runMethod(address, name, tail, seqno);
+    return {
+        exitCode: res.exitCode,
+        result: res.result ? (0, core_1.parseTuple)(core_1.Cell.fromBoc(buffer_1.Buffer.from(res.result, 'base64'))[0]) : [],
+        resultRaw: res.result,
+        block: res.block,
+        shardBlock: res.shardBlock,
+    };
+}

package/dist/main.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 {};