wan-ton-sdk 0.0.7 → 0.0.9

package/dist/event/getEvents.js

@@ -0,0 +1,387 @@
+"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.getEvents = getEvents;
+exports.getTransactions = getTransactions;
+exports.getAllTransactions = getAllTransactions;
+exports.getEventFromTran = getEventFromTran;
+exports.getTransaction = getTransaction;
+exports.getTransactionFromDb = getTransactionFromDb;
+exports.getEventByTranHash = getEventByTranHash;
+exports.getOpCodeFromCell = getOpCodeFromCell;
+const core_1 = require("@ton/core");
+const encode_decode_1 = require("../code/encode-decode");
+const logger_1 = require("../utils/logger");
+const transResult_1 = require("../transResult/transResult");
+const formatUtil = require('util');
+const opcodes = __importStar(require("../opcodes"));
+const utils_1 = require("../utils/utils");
+const const_value_1 = require("../const/const-value");
+const DbAccess_1 = require("../db/DbAccess");
+const client_interface_1 = require("../client/client-interface");
+async function getEvents(client, scAddress, limit, lt, to_lt, eventName, hash) {
+    logger_1.logger.info("scAddress:%s,limit:%s,lt:%s,to_lt:%s,eventName:%s", scAddress, limit, lt, to_lt, eventName);
+    if (!client) {
+        throw new Error("client does not exist");
+    }
+    if (!core_1.Address.isAddress(core_1.Address.parse(scAddress))) {
+        throw new Error("scAddress is invalid");
+    }
+    if (limit > const_value_1.MAX_LIMIT) {
+        throw new Error("limit is more than MAX_LIMIT(1000)");
+    }
+    let events = [];
+    let trans = [];
+    trans = await getTransactions(client, scAddress, { limit, lt, to_lt, archival: true });
+    for (let tran of trans) {
+        logger_1.logger.info(formatUtil.format("tran=>", tran.hash().toString('base64')));
+        let event = await getEventFromTran(client, tran, scAddress);
+        if (event != null) {
+            logger_1.logger.info("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!==found event==!!!!!!!!!!!!!!!!!!!!!!!!!!!", event);
+            if (eventName && event.eventName.toLowerCase() != eventName.toLowerCase()) {
+                continue;
+            }
+            events.push(event);
+        }
+    }
+    return events;
+}
+async function getTransactions(client, scAddress, opts) {
+    logger_1.logger.info("getTransactions opts = %s", opts);
+    let ret = await getTransactionsFromDb(client, scAddress, opts);
+    if (ret && ret.length != 0) {
+        return ret;
+    }
+    logger_1.logger.info("getTransactions from RPC server opts = %s", opts);
+    let scAddr = core_1.Address.parse(scAddress);
+    logger_1.logger.info(formatUtil.format("contractAddr=>", scAddress));
+    try {
+        ret = await client.getTransactions(scAddr, opts);
+    }
+    catch (err) {
+        logger_1.logger.error((0, utils_1.formatError)(err));
+    }
+    return ret;
+}
+async function getTransactionsFromDb(client, scAddress, opts) {
+    logger_1.logger.info("getTransactionsFromDb opts = %s", opts);
+    let scAddr = core_1.Address.parse(scAddress);
+    logger_1.logger.info(formatUtil.format("contractAddr=>", scAddress));
+    let dbAccess = await DbAccess_1.DBAccess.getDBAccess();
+    if (!dbAccess) {
+        logger_1.logger.error("not using db cache");
+        return null;
+    }
+    let retTx = null;
+    let retry = const_value_1.MAX_RETRY;
+    while (retry-- > 0 && !retTx) {
+        try {
+            if (!dbAccess?.has(scAddress)) {
+                await dbAccess.addDbByName(scAddress);
+            }
+            retTx = await dbAccess?.getTxsByLtRange(scAddress, opts.lt ? BigInt(opts.lt) : BigInt(0), opts.to_lt ? BigInt(opts.to_lt) : BigInt(0));
+        }
+        catch (err) {
+            logger_1.logger.error("getTxsByLtRange err", (0, utils_1.formatError)(err), "retry", retry, "dbName", "scAddress", scAddress, "opts", opts);
+        }
+        await (0, utils_1.sleep)(10000);
+    }
+    logger_1.logger.info("getTransactionsFromDb success", "scAddress", scAddress, "lt", opts.lt, "tranHash", opts.hash, "retTx", retTx);
+    return retTx;
+}
+async function getAllTransactions(client, scAddress, limit, retry) {
+    let trans = [];
+    let transCount = limit;
+    let opts = {
+        limit,
+        archival: true,
+    };
+    let maxRetry = retry;
+    while (transCount) {
+        let getSuccess = false;
+        while (maxRetry-- > 0 && (!getSuccess)) {
+            try {
+                logger_1.logger.info("maxRetry = %s, getSuccess = %s, transCount = %s, scAddress = %s opts = %s", maxRetry, getSuccess, transCount, scAddress, JSON.stringify(opts, utils_1.bigIntReplacer));
+                let ret = await client.getTransactions(core_1.Address.parse(scAddress), opts);
+                transCount = ret.length;
+                logger_1.logger.info("getAllTransactions getTransactions success from rpc", "opts", JSON.stringify(opts, utils_1.bigIntReplacer), "len of getTransactions", transCount, "scAddress", scAddress);
+                for (let tran of ret) {
+                    logger_1.logger.info("=====> tranHash = %s lt = %s", tran.hash().toString('base64'), tran.lt.toString(10));
+                    trans.push(tran);
+                }
+                if (ret.length) {
+                    opts.lt = ret[ret.length - 1].lt.toString(10);
+                    opts.hash = ret[ret.length - 1].hash().toString('base64');
+                }
+                getSuccess = true;
+                maxRetry = retry;
+            }
+            catch (e) {
+                logger_1.logger.error("err ", (0, utils_1.formatError)(e));
+                await (0, utils_1.sleep)(2000);
+            }
+        }
+        if (maxRetry == 0) {
+            throw (new Error(formatUtil("getTransactions failed after %d retry. opts is %s", retry, JSON.stringify(opts))));
+        }
+        await (0, utils_1.sleep)(2000);
+    }
+    logger_1.logger.info("getAllTransactions success");
+    return trans;
+}
+async function getEventFromTran(client, tran, scAddress) {
+    logger_1.logger.info("getEventFromTran entering", "client is WanTonClient", (0, client_interface_1.IsWanTonClient)(client));
+    let bodyCell = tran.inMessage?.body;
+    if (!bodyCell) {
+        logger_1.logger.error("body is empty", "tran", tran.hash().toString("base64"));
+        return null;
+    }
+    try {
+        let opCode = await getOpCodeFromCell(bodyCell);
+        logger_1.logger.info(formatUtil.format("opCode=>", opCode.toString(16)));
+        logger_1.logger.info(formatUtil.format("codeTable[opCode]=>", encode_decode_1.codeTable[opCode]));
+        if (!encode_decode_1.codeTable[opCode]) {
+            logger_1.logger.error("opCode is empty", "tran", "opCode", opCode.toString(16));
+            return null;
+        }
+        logger_1.logger.info("before decode bodyCell");
+        let decoded = await encode_decode_1.codeTable[opCode]["deCode"](bodyCell);
+        logger_1.logger.info("after decode bodyCell");
+        decoded.txHashBase64 = tran.hash().toString("base64");
+        decoded.txHash = tran.hash().toString("hex");
+        decoded.lt = tran.lt;
+        decoded.prevTransactionHash = tran.prevTransactionHash;
+        decoded.prevTransactionLt = tran.prevTransactionLt;
+        // handle userLock
+        if (opCode == opcodes.OP_CROSS_UserLock) {
+            logger_1.logger.info(formatUtil.format("getEventFromTran OP_CROSS_UserLock"));
+            logger_1.logger.info("getEventFromTran before handleUserLockEvent", "client is WanTonClient", (0, client_interface_1.IsWanTonClient)(client));
+            let handleResult = await handleUserLockEvent(client, core_1.Address.parse(scAddress), tran);
+            if (!handleResult.valid) {
+                logger_1.logger.error(formatUtil.format("handleResult OP_CROSS_UserLock is not valid"));
+                return null;
+            }
+            decoded.origin = handleResult.origin;
+        }
+        else {
+            let handleResult = await handleCommonEvent(client, core_1.Address.parse(scAddress), tran);
+            if (!handleResult.valid) {
+                logger_1.logger.error(formatUtil.format("handleResult handleCommonEvent is not valid"));
+                return null;
+            }
+            decoded.origin = handleResult.origin;
+        }
+        return await encode_decode_1.codeTable[opCode]["emitEvent"](decoded);
+    }
+    catch (err) {
+        logger_1.logger.error(formatUtil.format("getEventFromTran err", (0, utils_1.formatError)(err)));
+        return null;
+    }
+}
+async function getTransaction(client, scAddress, lt, tranHash) {
+    logger_1.logger.info("Entering getTransaction", "scAddress", scAddress, "lt", lt, "hash", tranHash, "hash(base64)", (0, utils_1.toBase64)(tranHash));
+    let retTranFromDb = await getTransactionFromDb(client, scAddress, lt, (0, utils_1.toBase64)(tranHash));
+    if (retTranFromDb) {
+        logger_1.logger.info("getTransaction success", "getTransactionFromDb", "retTranFromDb", retTranFromDb.hash().toString("base64"));
+        return retTranFromDb;
+    }
+    logger_1.logger.info("getTransaction", "getTransaction from rpc", "scAddress", scAddress, "lt", lt, "hash", tranHash, "hash(base64)", (0, utils_1.toBase64)(tranHash));
+    let tran;
+    let trans = [];
+    let retry = 2;
+    let status = false;
+    let foundTran = false;
+    let maxTrans = 1000;
+    let transChecked = 0;
+    while (retry-- > 0) {
+        try {
+            logger_1.logger.info("before client.getTransaction", "scAddress", scAddress, "lt", lt, "hash", tranHash, "hash(base64)", (0, utils_1.toBase64)(tranHash));
+            tran = await client.getTransaction(core_1.Address.parse(scAddress), lt, (0, utils_1.toBase64)(tranHash)); //  cannot compute block with specified transaction: cannot find block (0,e56031f43e6493da) lt=33028010000003: lt not in db'
+            logger_1.logger.info("client.getTransaction success", "scAddress", scAddress, "lt", lt, "hash", tranHash, "hash(base64)", (0, utils_1.toBase64)(tranHash), "tran = > ", tran);
+            return tran;
+        }
+        catch (err) {
+            logger_1.logger.error("getTransaction", "client.getTransaction error", (0, utils_1.formatError)(err), "scAddress", scAddress, "lt", lt, "hash", tranHash, "hash(base64)", (0, utils_1.toBase64)(tranHash));
+            await (0, utils_1.sleep)(2000);
+        }
+    }
+    retry = const_value_1.MAX_RETRY;
+    let opts = {
+        limit: const_value_1.MAX_LIMIT,
+        archival: true,
+    };
+    while (transChecked < maxTrans && !foundTran) {
+        status = false;
+        while (--retry > 0 && !status) {
+            try {
+                logger_1.logger.info("getTransactions", "scAddress", scAddress, "opts", opts);
+                trans = await client.getTransactions(core_1.Address.parse(scAddress), opts);
+                status = true;
+                retry = const_value_1.MAX_RETRY;
+            }
+            catch (err) {
+                //logger.error(err.message,err.response?.data?.error,err);
+                logger_1.logger.error((0, utils_1.formatError)(err));
+                await (0, utils_1.sleep)(2000);
+            }
+        }
+        if (retry == 0) {
+            throw (new Error(formatUtil.format("getTransactions ", "scAddress", scAddress, "opts", opts)));
+        }
+        if (trans.length == 0) {
+            break;
+        }
+        for (let i = 0; i < trans.length; i++) {
+            let tx = trans[i];
+            if (i == trans.length - 1) {
+                opts.lt = tx.lt.toString(10);
+                opts.hash = tx.hash().toString('base64');
+            }
+            logger_1.logger.info("getTransactions from rpc", "i", i, "txHash", tx.hash().toString("base64"));
+            if (tx.hash().toString('base64') == (0, utils_1.toBase64)(tranHash)) {
+                tran = tx;
+                foundTran = true;
+                break;
+            }
+        }
+        await (0, utils_1.sleep)(2000);
+        transChecked += trans.length;
+    }
+    if (foundTran) {
+        return tran;
+    }
+    throw (new Error(formatUtil.format("can not getTransactions ", "scAddress", scAddress, "opts", opts)), "hash", tranHash, "hash(bse64)", (0, utils_1.toBase64)(tranHash));
+}
+// tranHash: base64
+async function getTransactionFromDb(client, scAddress, lt, tranHash) {
+    logger_1.logger.info("Entering getTransactionFromDb", "scAddress", scAddress, "lt", lt, "tranHash", tranHash);
+    let dbAccess = await DbAccess_1.DBAccess.getDBAccess();
+    if (!dbAccess) {
+        logger_1.logger.error("not using db cache");
+        return null;
+    }
+    let retTx = null;
+    let retry = const_value_1.MAX_RETRY;
+    while (retry-- > 0 && !retTx) {
+        try {
+            if (!dbAccess?.has(scAddress)) {
+                await dbAccess.addDbByName(scAddress);
+            }
+            retTx = await dbAccess?.getTxByHashLt(scAddress, tranHash, lt);
+        }
+        catch (err) {
+            logger_1.logger.error("getTxByHashLt err", (0, utils_1.formatError)(err), "retry", retry, "dbName", "scAddress", scAddress, "hash", tranHash);
+        }
+        await (0, utils_1.sleep)(10000);
+    }
+    logger_1.logger.info("getTransactionFromDb success", "scAddress", scAddress, "lt", lt, "tranHash", tranHash, "retTx", retTx);
+    return retTx;
+}
+async function getEventByTranHash(client, scAddress, lt, tranHash) {
+    logger_1.logger.info("entering getEventByTranHash getTransaction success", "tranHash ", tranHash, "lt", lt, "dbName", scAddress);
+    let tran = await getTransaction(client, scAddress, lt, tranHash);
+    logger_1.logger.info("getEventByTranHash getTransaction success", tran, "tranHash ", tran.hash().toString('hex'));
+    logger_1.logger.info("getEventByTranHash before getEventFromTran", "client is WanTonClient", (0, client_interface_1.IsWanTonClient)(client));
+    return await getEventFromTran(client, tran, scAddress);
+}
+async function getOpCodeFromCell(cell) {
+    if (cell.equals(core_1.Cell.EMPTY)) {
+        throw new Error("empty cell");
+    }
+    let slice = cell.beginParse();
+    try {
+        return slice.preloadUint(32);
+    }
+    catch (err) {
+        logger_1.logger.error(formatUtil.format("getOpCodeFromCell(err)=>", (0, utils_1.formatError)(err)));
+        throw new Error("no opCode find");
+    }
+}
+/*
+{
+    valid: true|false,  // used the trans tree is valid
+    origin: Address,    // from address, who trigger the lock event.
+}
+ */
+async function handleUserLockEvent(client, scAddr, tran) {
+    return handleCommonEvent(client, scAddr, tran);
+}
+async function handleCommonEvent(client, scAddr, tran) {
+    logger_1.logger.info(formatUtil.format("Entering handleCommonEvent"));
+    let transResult = await getTransResult(client, scAddr, tran);
+    if (!transResult.success) {
+        logger_1.logger.error("the trans tree is not success");
+        return {
+            valid: false,
+            origin: transResult.originAddr.toString()
+        };
+    }
+    logger_1.logger.info(formatUtil.format("Ending handleCommonEvent"));
+    return {
+        valid: true,
+        origin: transResult.originAddr.toString()
+    };
+}
+async function decodeUserLock(bodyCell) {
+    let bodySlice = bodyCell.asSlice();
+    let queryId, dstUserAccount, addrTokenAccount, jwAddrSrc, jwAddrBridgeSc, opCode, smgID, tokenPairID, crossValue;
+    opCode = bodySlice.loadUint(32);
+    queryId = bodySlice.loadUint(64);
+    smgID = bodySlice.loadUintBig(256);
+    tokenPairID = bodySlice.loadUint(32);
+    crossValue = bodySlice.loadUintBig(256);
+    let dstUserAccountBufferLen = bodySlice.loadUint(8);
+    let dstUserAccountBuffer = bodySlice.loadBuffer(dstUserAccountBufferLen);
+    let extraSlice = bodySlice.loadRef().beginParse();
+    addrTokenAccount = extraSlice.loadAddress();
+    jwAddrSrc = extraSlice.loadAddress();
+    jwAddrBridgeSc = extraSlice.loadAddress();
+    extraSlice.endParse();
+    dstUserAccount = "0x" + dstUserAccountBuffer.toString('hex');
+    return {
+        opCode,
+        queryId,
+        smgID,
+        tokenPairID,
+        crossValue,
+        dstUserAccount,
+        addrTokenAccount,
+        jwAddrSrc,
+        jwAddrBridgeSc
+    };
+}
+async function getTransResult(client, scAddr, tran) {
+    return await (0, transResult_1.getTranResultByTran)(client, scAddr, tran);
+}

package/dist/example/db/createDb-ex.d.ts

@@ -0,0 +1 @@
+declare function main(): Promise<void>;

package/{example/createDb-ex.ts → dist/example/db/createDb-ex.js}

@@ -1,8 +1,7 @@
-async function main(){
-    const DB = require('../db/Db').DB;
+async function main() {
+    const DB = require('../../db/Db').DB;
     console.log("Entering main function");
     let db = new DB('test');
     await db.init('test');
 }
-
-main();
+main();

package/dist/example/db/dbFeedTrans-ex.d.ts

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

package/{example/dbFeedTrans-ex.ts → dist/example/db/dbFeedTrans-ex.js}

@@ -1,20 +1,18 @@
-import {getClient} from "../client/client";
-
-const DBAccess = require("../db/DbAccess").DBAccess;
-const scAddress = require('../testData/contractAddress.json');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DBAccess = require("../../db/DbAccess").DBAccess;
+const scAddress = require('../../testData/contractAddress.json');
 let scBridgeAddr = scAddress.bridgeAddress;
-
-async function main(){
+async function main() {
     console.log("Entering main function");
     let dbAccess = await DBAccess.getDBAccess();
-    if(!dbAccess){
-        console.error("not using db cache.")
+    if (!dbAccess) {
+        console.error("not using db cache.");
         return;
     }
     await dbAccess.addDbByName(scBridgeAddr);
     await dbAccess.addDbByName("EQCABVjsQnmRELMK6vjwGbYNRzHXoTd2hvSX6v_VmVrrJNjW");
-};
-
+}
+;
 main();
-
 // ts-node dbFeedTrans-ex.ts

package/dist/example/event/getAllEvents-ex.d.ts

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

package/dist/example/event/getAllEvents-ex.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils/utils");
+const config_ex_1 = require("../../config/config-ex");
+const client_1 = require("../../client/client");
+const getEvents_1 = require("../../event/getEvents");
+const DbAccess_1 = require("../../db/DbAccess");
+const core_1 = require("@ton/core");
+const common_1 = require("../../db/common");
+const args = process.argv.slice(2);
+async function main() {
+    //await wanTonSdkInit(configMainnet);
+    //await wanTonSdkInit(configTestnet);
+    await (0, client_1.wanTonSdkInit)(config_ex_1.configTestTonApi);
+    //await wanTonSdkInit(configTestTonApiNoDb);
+    let scBridgeAddr = args[0];
+    let dbAcces = await DbAccess_1.DBAccess.getDBAccess();
+    if (!dbAcces) {
+        console.error("not using db cache");
+        return;
+    }
+    console.log("scBridgeAddr", scBridgeAddr);
+    console.log("scBridgeAddr final address", core_1.Address.parse(scBridgeAddr).toString());
+    let client = await (0, client_1.getClient)();
+    let scanEvent = async () => {
+        console.log("\n\n\n===================================getAllEvents===================================\n");
+        console.log("\n===================================getAllEvents===================================\n\n\n");
+        let tonTrans = [];
+        if (!dbAcces?.has(scBridgeAddr)) {
+            await dbAcces.addDbByName(scBridgeAddr);
+            await (0, utils_1.sleep)(2000);
+        }
+        try {
+            tonTrans = await dbAcces.getAllTransNotHandled(args[0]);
+            console.log("getAllTransNotHandled tonTrans.length", tonTrans.length);
+        }
+        catch (err) {
+            console.error(err.code, err.response?.data?.error);
+        }
+        if (!tonTrans) {
+            return;
+        }
+        for (let tonTran of tonTrans) {
+            try {
+                console.log("begin getEventByTranHash", "scBridgeAddr", scBridgeAddr, "lt", tonTran.lt.toString(10), "tranHash", tonTran.hash().toString('hex'));
+                let ret = await (0, getEvents_1.getEventByTranHash)(client, scBridgeAddr, tonTran.lt.toString(10), tonTran.hash().toString('hex'));
+                console.log("end getEventByTranHash JacobEvent ret = ", ret);
+                let tranTonTemp = (0, common_1.convertTranToTonTrans)([tonTran]);
+                console.log("begin setTranHandleFlag", "scBridgeAddr", scBridgeAddr, "lt", tonTran.lt.toString(10), "tranHash", tonTran.hash().toString('hex'));
+                await dbAcces.setTranHandleFlag(scBridgeAddr, tranTonTemp[0], true);
+            }
+            catch (err) {
+                console.error(err.code, err.response?.data?.error);
+            }
+            await (0, utils_1.sleep)(1000);
+        }
+    };
+    let round = 1;
+    let busy = false;
+    setInterval(async () => {
+        if (!busy) {
+            busy = true;
+            console.log("round = ", round++);
+            await scanEvent();
+            busy = false;
+        }
+    }, 100000);
+}
+main();
+// ts-node getAllEvents-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr

package/dist/example/event/getEventByHash-ex.d.ts

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

package/{example/getEventByHash-ex.ts → dist/example/event/getEventByHash-ex.js}

@@ -1,39 +1,35 @@
-import {sleep} from "../utils/utils";
-
-import {configTestnet,configMainnet} from "../config/config-ex";
-import {getClient, TonClientConfig, wanTonSdkInit} from "../client/client";
-import {getEventByTranHash, getEvents} from "../event/getEvents";
-import { logger } from "../utils/logger";
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_ex_1 = require("../../config/config-ex");
+const client_1 = require("../../client/client");
+const getEvents_1 = require("../../event/getEvents");
+const client_interface_1 = require("../../client/client-interface");
 const args = process.argv.slice(2);
-
-async function main(){
-    await wanTonSdkInit(configMainnet);
-    await wanTonSdkInit(configTestnet);
-    try{
-        let client = await getClient();
+async function main() {
+    //await wanTonSdkInit(configMainnet);
+    //await wanTonSdkInit(configTestnet);
+    await (0, client_1.wanTonSdkInit)(config_ex_1.configTestTonApi);
+    try {
+        let client = await (0, client_1.getClient)();
         let scBridgeAddr = args[0];
         let lt = args[1];
-        let tranHash = Buffer.from(args[2],'hex').toString('base64');
-
-        console.log("scBridgeAddr",scBridgeAddr,"lt",lt,"tranHash",tranHash);
-        let ret = await getEventByTranHash(client,scBridgeAddr,lt,tranHash);
-
-        console.log("ret = ",ret);
+        let tranHash = Buffer.from(args[2], 'hex').toString('base64');
+        console.log("scBridgeAddr", scBridgeAddr, "lt", lt, "tranHash", tranHash);
+        console.log("before getEventByTranHash", "client is WanTonClient", (0, client_interface_1.IsWanTonClient)(client));
+        let ret = await (0, getEvents_1.getEventByTranHash)(client, scBridgeAddr, lt, tranHash);
+        console.log("ret = ", ret);
         client = null;
-    }catch(err){
-        console.error(err.code,err.response?.data?.error)
     }
-
+    catch (err) {
+        console.error(err.code, err.response?.data?.error);
+    }
 }
-
 main();
 // userLock
 // ts-node getEventByHash-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr 33313072000003 5c6cbcef28ef2514ea0b7594a0dda35e4ce08416312d3c5629388ae21ad54e83
 // ts-node getEventByHash-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr 33313091000003 095015c23c8323af4b7c20b9bd35b2864aa2a4fbaa85335828fa63bccbfdaeff
 // ts-node getEventByHash-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr 33313098000001 391972a7343d4b644e279575ae1e7b4c92fcf4deda69f3fbe5cb5b7b9ea67f2a
-
 // smgRelease
 // ts-node getEventByHash-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr 33315421000001 5e654b1798cca9b63adcb8091b0962b364581538bc4431449f9e9c674bb0d5f6
 // ts-node getEventByHash-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr 33315410000001 dd22c46a31a348d5ff0b77bb0191b915549af7c450ab905390b3e7d8e6981c32
-// ts-node getEventByHash-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr 33315399000001 458f7592928e02d22584a71b290abbf82def08c618ee26acbf2da3ea2eccb7a2
+// ts-node getEventByHash-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr 33315399000001 458f7592928e02d22584a71b290abbf82def08c618ee26acbf2da3ea2eccb7a2

package/dist/example/event/getEventsByRange-ex.d.ts

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

package/dist/example/event/getEventsByRange-ex.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils/utils");
+const config_ex_1 = require("../../config/config-ex");
+const client_1 = require("../../client/client");
+const getEvents_1 = require("../../event/getEvents");
+const DbAccess_1 = require("../../db/DbAccess");
+const core_1 = require("@ton/core");
+const common_1 = require("../../db/common");
+const args = process.argv.slice(2);
+async function main() {
+    //await wanTonSdkInit(configMainnet);
+    //await wanTonSdkInit(configTestnet);
+    await (0, client_1.wanTonSdkInit)(config_ex_1.configTestTonApi);
+    //await wanTonSdkInit(configTestTonApiNoDb);
+    let scBridgeAddr = args[0];
+    let lt = BigInt(args[1]);
+    let to_lt = BigInt(args[2]);
+    let dbAcces = await DbAccess_1.DBAccess.getDBAccess();
+    if (!dbAcces) {
+        console.error("not using db cache");
+        return;
+    }
+    console.log("scBridgeAddr", scBridgeAddr);
+    console.log("scBridgeAddr final address", core_1.Address.parse(scBridgeAddr).toString());
+    let client = await (0, client_1.getClient)();
+    setInterval(async () => {
+        console.log("\n\n\n===================================getEventsByRange===================================\n");
+        console.log("\n===================================getEventsByRange===================================\n\n\n");
+        let tonTrans = [];
+        if (!dbAcces?.has(scBridgeAddr)) {
+            await dbAcces.addDbByName(scBridgeAddr);
+            await (0, utils_1.sleep)(2000);
+        }
+        try {
+            tonTrans = await dbAcces.getAllTransNotHandledByRange(args[0], lt, to_lt);
+            console.log("getAllTransNotHandledByRange tonTrans.length", tonTrans.length);
+        }
+        catch (err) {
+            console.error(err.code, err.response?.data?.error);
+        }
+        for (let tonTran of tonTrans) {
+            try {
+                console.log("scBridgeAddr", scBridgeAddr, "lt", tonTran.lt.toString(10), "tranHash", tonTran.hash().toString('hex'));
+                let ret = await (0, getEvents_1.getEventByTranHash)(client, scBridgeAddr, tonTran.lt.toString(10), tonTran.hash().toString('hex'));
+                console.log("JacobEvent ret = ", ret);
+                let tranTonTemp = (0, common_1.convertTranToTonTrans)([tonTran]);
+                await dbAcces.setTranHandleFlag(scBridgeAddr, tranTonTemp[0], true);
+            }
+            catch (err) {
+                console.error(err.code, err.response?.data?.error);
+            }
+            await (0, utils_1.sleep)(1000);
+        }
+    }, 100000);
+}
+main();
+// ts-node getAllEvents-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr 35100832000001 33781871000003

package/dist/example/getAllTrans.d.ts

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