wan-ton-sdk 0.0.7 → 0.0.9

package/dist/db/DbAccess.d.ts

@@ -0,0 +1,24 @@
+import { TonTransaction } from "./Db";
+export declare class DBAccess {
+    private dbs;
+    private inited;
+    private scanTran;
+    constructor();
+    init(scanTran: boolean): Promise<void>;
+    clear(): Promise<void>;
+    static getDBAccess(): DBAccess;
+    addDbByName(dbName: string): Promise<void>;
+    removeDbByName(dbName: string): Promise<void>;
+    setTranHandleFlag(dbName: string, tran: TonTransaction, finishOrNot: boolean): Promise<void>;
+    getTxByTxHash(dbName: string, txHash: string): Promise<import("@ton/core").Transaction>;
+    getTxByHashLt(dbName: string, txHash: string, lt: string): Promise<import("@ton/core").Transaction>;
+    getTxByMsg(dbName: string, msgHash: string, bodyHash: string, lt: bigint): Promise<import("@ton/core").Transaction>;
+    getTxsByLtRange(dbName: string, lt: bigint, to_lt: bigint): Promise<import("@ton/core").Transaction[]>;
+    getParentTx(dbName: string, tran: TonTransaction): Promise<import("@ton/core").Transaction>;
+    getChildTxs(dbName: string, tran: TonTransaction): Promise<import("@ton/core").Transaction[]>;
+    getAllTransNotHandled(dbName: string): Promise<import("@ton/core").Transaction[]>;
+    getAllTransNotHandledByRange(dbName: string, lt: bigint, to_lt: bigint): Promise<import("@ton/core").Transaction[]>;
+    getTxByOnlyMsgHash(dbName: string, msgCellHash: string): Promise<import("@ton/core").Transaction[]>;
+    getDbNameFinal(dbName: string): string;
+    has(dbName: string): boolean;
+}

package/dist/db/DbAccess.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBAccess = void 0;
+const DB = require("../db/Db").DB;
+const RangeOpen = require("../db/Db").RangeOpen;
+const common_1 = require("./common");
+const common_2 = require("./common");
+const core_1 = require("@ton/core");
+const client_1 = require("../client/client");
+const utils_1 = require("../utils/utils");
+const logger_1 = require("../utils/logger");
+let dbAccess = null;
+async function runAsyncTask(db, scanTran = true) {
+    logger_1.logger.info("DbAccess runAsyncTask......", "dbName", db.getDbName(), "scanTran", scanTran);
+    if (scanTran) {
+        await db.feedTrans();
+    }
+}
+class DBAccess {
+    constructor() {
+        this.dbs = new Map();
+        this.inited = false;
+        this.scanTran = true;
+    }
+    async init(scanTran) {
+        logger_1.logger.info("begin DbAccess init", "scanTran", scanTran);
+        if (this.inited) {
+            return;
+        }
+        let dbNames = [];
+        await (0, utils_1.ensureDirectoryExists)((0, client_1.getDBDataDir)());
+        (0, common_2.listJsonFiles)((0, client_1.getDBDataDir)(), dbNames);
+        for (let dbName of dbNames) {
+            let db = new DB(dbName);
+            await db.init(dbName);
+            this.dbs.set(dbName, db);
+            await runAsyncTask(db, scanTran);
+        }
+        this.inited = true;
+        this.scanTran = scanTran;
+        logger_1.logger.info("end DbAccess init");
+    }
+    async clear() {
+        for (let key of this.dbs.keys()) {
+            let db = this.dbs.get(key);
+            await db.stopFeedTrans();
+            await db.clearDb();
+            db = null;
+        }
+        this.dbs.clear();
+    }
+    static getDBAccess() {
+        if (!(0, client_1.getGlobalTonConfig)().usingDbCache) {
+            return null;
+        }
+        if (dbAccess == null) {
+            dbAccess = new DBAccess();
+            return dbAccess;
+        }
+        else {
+            return dbAccess;
+        }
+    }
+    async addDbByName(dbName) {
+        logger_1.logger.info("before addDbByName", "dbName", dbName, "dbs.length", this.dbs.size);
+        if (this.has(dbName)) {
+            throw new Error(`db ${dbName} already exists`);
+        }
+        let dbNameFinal = this.getDbNameFinal(dbName);
+        let db = new DB(dbNameFinal);
+        await db.init(dbNameFinal);
+        this.dbs.set(db.getDbName(), db);
+        logger_1.logger.info("after addDbByName", "dbName", dbName, "dbNameFinal", dbNameFinal, "dbs.length", this.dbs.size);
+        await runAsyncTask(db, this.scanTran);
+    }
+    async removeDbByName(dbName) {
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        await (this.dbs.get(this.getDbNameFinal(dbName))).stopFeedTrans();
+        this.dbs.delete(this.getDbNameFinal(dbName));
+    }
+    async setTranHandleFlag(dbName, tran, finishOrNot) {
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        await this.dbs.get(this.getDbNameFinal(dbName)).setTranHandleFlag(tran, finishOrNot);
+    }
+    async getTxByTxHash(dbName, txHash) {
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        let tonTran = await this.dbs.get(this.getDbNameFinal(dbName)).getTxByTxHash(txHash);
+        if (!tonTran || (tonTran.length == 0)) {
+            return null;
+        }
+        return ((0, common_1.convertTonTransToTrans)(tonTran))[0];
+    }
+    async getTxByHashLt(dbName, txHash, lt) {
+        logger_1.logger.info("Entering getTxByHashLt........", "dbName", dbName, "txHash", txHash, "lt", lt);
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        let tonTran = await this.dbs.get(this.getDbNameFinal(dbName)).getTxByHashLt(txHash, lt);
+        if (!tonTran || (tonTran.length == 0)) {
+            return null;
+        }
+        logger_1.logger.info("Entering getTxByHashLt before convertTonTransToTrans........", "dbName", dbName, "txHash", txHash, "lt", lt, "tonTran.length", tonTran.length);
+        return ((0, common_1.convertTonTransToTrans)(tonTran))[0];
+    }
+    async getTxByMsg(dbName, msgHash, bodyHash, lt) {
+        logger_1.logger.info("Entering getTxByMsg........", "dbName", dbName, "msgHash", msgHash, "bodyHash", bodyHash, "lt", lt.toString(10));
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        let tonTran = await this.dbs.get(this.getDbNameFinal(dbName)).getTxByMsg(msgHash, bodyHash, lt);
+        if (!tonTran || (tonTran.length == 0)) {
+            return null;
+        }
+        logger_1.logger.info("Ending getTxByMsg success........", "dbName", dbName, "msgHash", msgHash, "bodyHash", bodyHash, "lt", lt.toString(10), "tonTran.length", tonTran.length);
+        return ((0, common_1.convertTonTransToTrans)([tonTran[0]]))[0];
+    }
+    async getTxsByLtRange(dbName, lt, to_lt) {
+        logger_1.logger.info("Entering getTxsByLtRange........", "dbName", dbName, "lt", lt, "to_lt", to_lt);
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        let tonTran = await this.dbs.get(this.getDbNameFinal(dbName)).getTxsByLtRange(lt, to_lt);
+        if (!tonTran || (tonTran.length == 0)) {
+            return null;
+        }
+        return (0, common_1.convertTonTransToTrans)(tonTran);
+    }
+    async getParentTx(dbName, tran) {
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        let ret = await this.dbs.get(this.getDbNameFinal(dbName)).getParentTx(tran);
+        if (!ret || ret.length == 0) {
+            return null;
+        }
+        else {
+            return (0, common_1.convertTonTransToTrans)(ret)[0];
+        }
+    }
+    async getChildTxs(dbName, tran) {
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        let ret = await this.dbs.get(this.getDbNameFinal(dbName)).getChildTxs(tran);
+        if (!ret || ret.length == 0) {
+            return null;
+        }
+        else {
+            return (0, common_1.convertTonTransToTrans)(ret);
+        }
+    }
+    async getAllTransNotHandled(dbName) {
+        logger_1.logger.info("begin getAllTransNotHandled", "dbName", dbName);
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        let ret = await this.dbs.get(this.getDbNameFinal(dbName)).getAllTransNotHandled();
+        if (!ret || ret.length == 0) {
+            return null;
+        }
+        else {
+            logger_1.logger.info("end getAllTransNotHandled", "dbName", dbName);
+            logger_1.logger.info("begin convertTonTransToTrans", "dbName", dbName, "tran.length", ret.length);
+            let finalRet = (0, common_1.convertTonTransToTrans)(ret);
+            logger_1.logger.info("end convertTonTransToTrans", "dbName", dbName, "tran.length", ret.length);
+            return finalRet;
+        }
+    }
+    async getAllTransNotHandledByRange(dbName, lt, to_lt) {
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        let ret = await this.dbs.get(this.getDbNameFinal(dbName)).getAllTransNotHandledByRange(lt, to_lt);
+        if (!ret || ret.length == 0) {
+            return null;
+        }
+        else {
+            return (0, common_1.convertTonTransToTrans)(ret);
+        }
+    }
+    async getTxByOnlyMsgHash(dbName, msgCellHash) {
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        let ret = await this.dbs.get(this.getDbNameFinal(dbName)).getTxByOnlyMsgHash(msgCellHash);
+        if (!ret || ret.length == 0) {
+            return null;
+        }
+        else {
+            return (0, common_1.convertTonTransToTrans)(ret);
+        }
+    }
+    getDbNameFinal(dbName) {
+        let dbNameFinal = dbName;
+        if (core_1.Address.parse(dbName).toString() != dbName) {
+            dbNameFinal = core_1.Address.parse(dbName).toString();
+        }
+        return dbNameFinal;
+    }
+    has(dbName) {
+        let dbAliasName = core_1.Address.parse(dbName).toString();
+        return this.dbs.has(dbName) || this.dbs.has(dbAliasName);
+    }
+}
+exports.DBAccess = DBAccess;

package/dist/db/common.d.ts

@@ -0,0 +1,5 @@
+import { Transaction } from "@ton/core";
+import { TonTransaction } from "./Db";
+export declare function listJsonFiles(dir: string, fileList?: string[]): string[];
+export declare function convertTranToTonTrans(trans: Transaction[]): TonTransaction[];
+export declare function convertTonTransToTrans(tonTrans: TonTransaction[]): Transaction[];

package/dist/db/common.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listJsonFiles = listJsonFiles;
+exports.convertTranToTonTrans = convertTranToTonTrans;
+exports.convertTonTransToTrans = convertTonTransToTrans;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("@ton/core");
+const core_2 = require("@ton/core");
+const utils_1 = require("../utils/utils");
+const logger_1 = require("../utils/logger");
+function listJsonFiles(dir, fileList = []) {
+    const files = fs.readdirSync(dir);
+    logger_1.logger.info("files", files);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            listJsonFiles(filePath, fileList);
+        }
+        else if (path.extname(filePath) === '.json') {
+            fileList.push(file.slice(0, file.length - 5));
+        }
+    }
+    return fileList;
+}
+function convertTranToTonTrans(trans) {
+    let tonTrans = [];
+    for (let tran of trans) {
+        const inMessageCell = (0, core_1.beginCell)().store((0, core_1.storeMessage)(tran.inMessage)).endCell();
+        let inMessageHash = inMessageCell.hash().toString('hex');
+        let inMessageBodyCellHash = tran.inMessage.body.hash().toString('hex');
+        let cii = tran.inMessage.info;
+        let outMsgs = [];
+        for (let key of tran.outMessages.keys()) {
+            let om = tran.outMessages.get(key);
+            let ciiOut = om.info;
+            const outMessageCell = (0, core_1.beginCell)().store((0, core_1.storeMessage)(om)).endCell();
+            let outMessageHash = outMessageCell.hash().toString('hex');
+            let outMessageBodyCellHash = om.body.hash().toString('hex');
+            let outMsg = {
+                dst: ciiOut.dest.toString(),
+                outMsgHash: outMessageHash,
+                outBodyHash: outMessageBodyCellHash,
+                createdLt: ciiOut.createdLt,
+                createAt: BigInt(ciiOut.createdAt),
+            };
+            outMsgs.push(outMsg);
+        }
+        let tonTranTemp = {
+            hash: tran.hash().toString('base64'),
+            lt: tran.lt,
+            raw: tran.raw.toBoc().toString('base64'),
+            in: {
+                src: cii?.src?.toString(),
+                inMsgHash: inMessageHash,
+                inBodyHash: inMessageBodyCellHash,
+                createdLt: cii.createdLt,
+                createAt: cii?.createdAt ? BigInt(cii.createdAt) : BigInt(0),
+            },
+            out: outMsgs,
+            emitEventOrNot: false,
+        };
+        tonTrans.push(tonTranTemp);
+    }
+    return tonTrans;
+}
+function convertTonTransToTrans(tonTrans) {
+    let trans = [];
+    for (let tonTran of tonTrans) {
+        try {
+            let tranCell = core_1.Cell.fromBase64(tonTran.raw);
+            let tranTemp = (0, core_2.loadTransaction)(tranCell.asSlice());
+            trans.push(tranTemp);
+        }
+        catch (err) {
+            logger_1.logger.error("convertTonTransToTrans", "tonTran", tonTran, "err", (0, utils_1.formatError)(err));
+        }
+    }
+    return trans;
+}

package/dist/event/getEvents.d.ts

@@ -0,0 +1,17 @@
+import { Cell, Transaction } from "@ton/core";
+import { WanTonClient } from "../client/client-interface";
+export declare function getEvents(client: WanTonClient, scAddress: string, limit: number, lt?: string, to_lt?: string, eventName?: string, hash?: string): Promise<any>;
+export declare function getTransactions(client: WanTonClient, scAddress: string, opts: {
+    limit: number;
+    lt?: string;
+    hash?: string;
+    to_lt?: string;
+    inclusive?: boolean;
+    archival?: boolean;
+}): Promise<any>;
+export declare function getAllTransactions(client: WanTonClient, scAddress: string, limit: number, retry: number): Promise<any[]>;
+export declare function getEventFromTran(client: WanTonClient, tran: Transaction, scAddress: string): Promise<any>;
+export declare function getTransaction(client: WanTonClient, scAddress: string, lt: string, tranHash: string): Promise<any>;
+export declare function getTransactionFromDb(client: WanTonClient, scAddress: string, lt: string, tranHash: string): Promise<any>;
+export declare function getEventByTranHash(client: WanTonClient, scAddress: string, lt: string, tranHash: string): Promise<any>;
+export declare function getOpCodeFromCell(cell: Cell): Promise<number>;