wan-ton-sdk 0.0.7 → 0.0.9

package/dist/testData/JettonWallet.compile.func.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conf = void 0;
+const fs_2 = __importDefault(require("fs"));
+exports.conf = {
+    targets: [
+        '../../contracts/jetton/jetton-wallet.func'
+    ],
+    sources: (path) => (0, fs_2.default.readFileSync)(path).toString(),
+};

package/dist/testData/bridge.compile.func.d.ts

@@ -0,0 +1,2 @@
+import { CompilerConfig } from '@ton-community/func-js';
+export declare const conf: CompilerConfig;

package/dist/testData/bridge.compile.func.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conf = void 0;
+const fs_2 = __importDefault(require("fs"));
+exports.conf = {
+    targets: [
+        '../../contracts/bridge.fc'
+    ],
+    sources: (path) => (0, fs_2.default.readFileSync)(path).toString(),
+};

package/dist/transResult/transResult.d.ts

@@ -0,0 +1,29 @@
+import { Address, Transaction } from "@ton/core";
+import { WanTonClient } from "../client/client-interface";
+export declare function isTranSuccess(tran: Transaction): Promise<boolean>;
+export declare function getUpperStepsFromDb(client: WanTonClient, scAddr: Address, tran: Transaction, path: TranPathInfo): Promise<void>;
+export declare function getUpperSteps(client: WanTonClient, scAddr: Address, tran: Transaction, path: TranPathInfo): Promise<void>;
+export declare function getLowerSteps(client: WanTonClient, scAddr: Address, tran: Transaction, path: TranPathInfo): Promise<void>;
+export interface TranStepInfo {
+    addr: Address;
+    txHash: string;
+    gasUsed: bigint;
+    status: boolean;
+    lt: string;
+}
+export interface TranResult {
+    addr: Address;
+    msgInHash: string;
+    path: TranPathInfo;
+    success: boolean;
+    originAddr: Address;
+    gasUsed: bigint;
+}
+export type TranPathInfo = TranStepInfo[];
+export declare function getTranResultByMsgHash(client: WanTonClient, scAddr: Address, msgBodyCellHash: string, msgInHash: string): Promise<TranResult>;
+export declare function getTranResultByTxHash(client: WanTonClient, scAddr: Address, txHash: string, lt: string): Promise<TranResult>;
+export declare function getTranResultByTran(client: WanTonClient, scAddr: Address, tran: Transaction): Promise<TranResult>;
+export declare function findMsgCellHashInTran(tran: Transaction, msgCellHash: string, msgBodyHash: string, lt?: string): Promise<Boolean>;
+export declare function findOnlyMsgCellHashInTran(tran: Transaction, msgCellHash: string): Promise<Boolean>;
+export declare function getTranByMsgHash(client: WanTonClient, scAddr: Address, msgCellHash: string, msgBodyHash: string, lt?: string): Promise<Transaction>;
+export declare function getTranByOnlyMsgHash(client: WanTonClient, scAddr: Address, msgCellHash: string): Promise<Transaction>;

package/dist/transResult/transResult.js

@@ -0,0 +1,528 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTranSuccess = isTranSuccess;
+exports.getUpperStepsFromDb = getUpperStepsFromDb;
+exports.getUpperSteps = getUpperSteps;
+exports.getLowerSteps = getLowerSteps;
+exports.getTranResultByMsgHash = getTranResultByMsgHash;
+exports.getTranResultByTxHash = getTranResultByTxHash;
+exports.getTranResultByTran = getTranResultByTran;
+exports.findMsgCellHashInTran = findMsgCellHashInTran;
+exports.findOnlyMsgCellHashInTran = findOnlyMsgCellHashInTran;
+exports.getTranByMsgHash = getTranByMsgHash;
+exports.getTranByOnlyMsgHash = getTranByOnlyMsgHash;
+const core_1 = require("@ton/core");
+const utils_1 = require("../utils/utils");
+const DbAccess_1 = require("../db/DbAccess");
+const common_1 = require("../db/common");
+const const_value_1 = require("../const/const-value");
+const logger_1 = require("../utils/logger");
+const formatUtil = require('util');
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/*
+return
+[
+    {
+        addr: Address,
+        txHash: string,
+        gasUsed: bigInt,
+        status: boolean,
+    },
+    ...
+]
+ */
+async function getTranPathInfoByMsgHash(client, scAddr, msgBodyCellHash, msgInHash) {
+    let pivotTran = await getTranByMsgHash(client, scAddr, msgBodyCellHash, msgInHash);
+    let path = await getTranPathInfoByPivotTran(client, scAddr, pivotTran);
+    return path;
+}
+async function isTranSuccess(tran) {
+    //https://testnet.tonviewer.com/transaction/3a80c94fa62a855ebb47c634f1b42ebd0fdc9ea35ab3f6389bf2c086aac887ef
+    let td = tran.description;
+    // if(td.aborted){
+    //     return false
+    // }
+    let cp = td.computePhase;
+    if ((cp.type == "vm") && (!cp.success || cp.exitCode != 0)) {
+        return false;
+    }
+    if (td.aborted && cp.type == "vm") {
+        return false;
+    }
+    let ap = td.actionPhase;
+    let apSuccess = ap?.success ? ap.success : true;
+    if (!apSuccess) {
+        return false;
+    }
+    return true;
+}
+async function computePathGas(path) {
+    let ret = BigInt(0);
+    for (let step of path) {
+        ret += step.gasUsed;
+    }
+    return ret;
+}
+async function isTranPathSuccess(allTranPathInfo) {
+    let ret = true;
+    for (let step of allTranPathInfo) {
+        if (!step.status) {
+            return false;
+        }
+    }
+    return true;
+}
+async function getUpperStepsFromDb(client, scAddr, tran, path) {
+    logger_1.logger.info("getUpperStepsFromDb", "tran hash", tran.hash().toString('hex'));
+    if (tran.inMessage.info.type == 'external-in') {
+        return;
+    }
+    const inMessageCell = (0, core_1.beginCell)().store((0, core_1.storeMessage)(tran.inMessage)).endCell();
+    logger_1.logger.info("getUpperStepsFromDb inMessageCell==>", "hash", tran.hash().toString('hex'));
+    let upperAddress = tran.inMessage.info.src;
+    let maxRetry = 5;
+    //get from scanned db
+    let dbAccess = await DbAccess_1.DBAccess.getDBAccess();
+    if (!dbAccess) {
+        logger_1.logger.error("not using db cache");
+        throw new Error("not using db cache");
+    }
+    let transFromDb = null;
+    let foundInDb = false;
+    while (maxRetry-- > 0 && !transFromDb) {
+        try {
+            let inDb = await dbAccess?.has(upperAddress.toString());
+            if (!inDb) {
+                await dbAccess?.addDbByName(upperAddress.toString());
+                await sleep(const_value_1.RETRY_INTERNAL_TIME);
+            }
+            logger_1.logger.info("getUpperStepsFromDb before dbAccess.getParentTx", "tran hash", tran.hash().toString('hex'), "upperAddress", upperAddress.toString());
+            transFromDb = await dbAccess?.getParentTx(upperAddress.toString(), (0, common_1.convertTranToTonTrans)([tran])[0]);
+            if (transFromDb) { // found from db
+                foundInDb = true;
+            }
+        }
+        catch (err) {
+            logger_1.logger.info("getUpperStepsFromDb from db err", (0, utils_1.formatError)(err), "retry ", maxRetry);
+        }
+        await sleep(const_value_1.RETRY_INTERNAL_TIME);
+    }
+    if (maxRetry == 0 && !foundInDb) {
+        throw new Error(`Fail to look for parent. upperAddress: ${upperAddress.toString()}`);
+    }
+    if (foundInDb && transFromDb) {
+        logger_1.logger.info("getUpperStepsFromDB success", "hash", tran.hash().toString('hex'), "parent hash", transFromDb.hash().toString('hex'));
+        let stepInfoTemp = {
+            addr: upperAddress,
+            txHash: transFromDb.hash().toString('hex'),
+            gasUsed: transFromDb.totalFees.coins,
+            status: await isTranSuccess(transFromDb),
+            lt: transFromDb.lt.toString(),
+        };
+        path.unshift(stepInfoTemp);
+        await getUpperStepsFromDb(client, upperAddress, transFromDb, path);
+    }
+}
+async function getUpperSteps(client, scAddr, tran, path) {
+    if (tran.inMessage.info.type == 'external-in') {
+        return;
+    }
+    try {
+        await getUpperStepsFromDb(client, scAddr, tran, path);
+        return;
+    }
+    catch (err) {
+        logger_1.logger.info("getUpperStepsFromDb error", (0, utils_1.formatError)(err));
+    }
+    logger_1.logger.info("getUpperSteps from rpc", "scAddr", scAddr, "tran hash", tran.hash().toString('hex'));
+    const inMessageCell = (0, core_1.beginCell)().store((0, core_1.storeMessage)(tran.inMessage)).endCell();
+    logger_1.logger.info("inMessageCell==>", inMessageCell.toBoc().toString('hex'));
+    let tranInMsgHash = inMessageCell.hash().toString('hex');
+    let tranInMsgBodyCellHash = tran.inMessage.body.hash().toString('hex');
+    let upperAddress = tran.inMessage.info.src;
+    let maxTrans = 1000;
+    let transChecked = 0;
+    let opts = {
+        limit: 10,
+        archival: true,
+    };
+    let foundUpper = false;
+    let transCount = 10;
+    while (transChecked < maxTrans && !foundUpper && transCount) {
+        let retry = 5;
+        let status = false;
+        let transactions = [];
+        while (--retry > 0 && !status) {
+            try {
+                logger_1.logger.info("getUpperSteps getTransactions ", "scAddress", upperAddress, "opts", opts);
+                transactions = await client.getTransactions(upperAddress, opts);
+                transCount = transactions.length;
+                status = true;
+                retry = 5;
+            }
+            catch (e) {
+                await sleep(1000);
+                logger_1.logger.error((0, utils_1.formatError)(e));
+            }
+        }
+        if (retry == 0) {
+            throw (new Error(formatUtil.format("error getUpperSteps getTransactions ", "scAddress", upperAddress, "opts", opts)));
+        }
+        for (let i = 0; i < transactions.length; i++) {
+            let tx = transactions[i];
+            if (i == transactions.length - 1) {
+                opts.lt = tx.lt.toString(10);
+                opts.hash = tx.hash().toString('base64');
+            }
+            const transactionHash = tx.hash().toString('base64');
+            logger_1.logger.info("tx hash is:", i, tx.lt, transactionHash, tx.hash().toString('hex'));
+            const outMessages = tx.outMessages;
+            let foundInOutMsgs = false;
+            for (let outMsgKey of outMessages.keys()) {
+                let outMsg = outMessages.get(outMsgKey);
+                let outMsgHash = (0, core_1.beginCell)().store((0, core_1.storeMessage)(outMsg)).endCell().hash().toString('hex');
+                let outMsgBodyHash = outMsg.body.hash().toString('hex');
+                logger_1.logger.info("outMsgHash", outMsgHash, "tranInMsgHash", tranInMsgHash, "outMsgBodyHash", outMsgBodyHash, "tranInMsgBodyCellHash", tranInMsgBodyCellHash);
+                if (outMsgHash == tranInMsgHash || outMsgBodyHash == tranInMsgBodyCellHash) {
+                    if (outMsg.info.dest.equals(scAddr)) {
+                        if (outMsg.info.createdLt == tran.inMessage.info.createdLt) {
+                            let stepInfoTemp = {
+                                addr: upperAddress,
+                                txHash: tx.hash().toString('hex'),
+                                gasUsed: tx.totalFees.coins,
+                                status: await isTranSuccess(tx),
+                                lt: tx.lt.toString(),
+                            };
+                            path.unshift(stepInfoTemp);
+                            foundInOutMsgs = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (foundInOutMsgs) {
+                logger_1.logger.info("found upper tx", tx.hash().toString('base64'));
+                await getUpperSteps(client, upperAddress, tx, path);
+                foundUpper = true;
+                break; // found the upper tx
+            }
+        }
+        await sleep(const_value_1.RETRY_INTERNAL_TIME);
+        transChecked += transactions.length;
+    }
+    if (transChecked >= maxTrans) {
+        throw new Error("can not found the upper tx!");
+    }
+}
+async function getLowerSteps(client, scAddr, tran, path) {
+    logger_1.logger.info("Entering getLowerSteps", "scAddr", scAddr);
+    if (tran.outMessages.keys().length == 0) {
+        return;
+    }
+    const outMessages = tran.outMessages;
+    for (let outMsgKey of outMessages.keys()) {
+        let outMsg = outMessages.get(outMsgKey);
+        let lowerAddr = outMsg.info.dest;
+        let msgCellHash = (0, core_1.beginCell)().store((0, core_1.storeMessage)(outMsg)).endCell().hash().toString('hex');
+        let msgBodyHash = outMsg.body.hash().toString('hex');
+        logger_1.logger.info("===========================before getTranByMsgHash", "outMsg", outMsg);
+        let lowerTx = await getTranByMsgHash(client, lowerAddr, msgCellHash, msgBodyHash, outMsg.info.createdLt.toString(10));
+        let stepInfoTemp = {
+            addr: lowerAddr,
+            txHash: lowerTx.hash().toString('hex'),
+            gasUsed: lowerTx.totalFees.coins,
+            status: await isTranSuccess(lowerTx),
+            lt: lowerTx.lt.toString(),
+        };
+        path.push(stepInfoTemp);
+        await getLowerSteps(client, lowerAddr, lowerTx, path);
+    }
+}
+async function getTranPathInfoByPivotTran(client, scAddr, pivotTran) {
+    logger_1.logger.info("Entering getTranPathInfoByPivotTran");
+    let allTranPathInfo = [];
+    let beforePivotTranPathInfo = [];
+    let afterPivotTranPathInfo = [];
+    let pivoltTranStepInfo = {
+        addr: scAddr,
+        txHash: pivotTran.hash().toString('hex'),
+        gasUsed: pivotTran.totalFees.coins,
+        status: await isTranSuccess(pivotTran),
+        lt: pivotTran.lt.toString(),
+    };
+    logger_1.logger.info("Entering get children tx");
+    await getLowerSteps(client, scAddr, pivotTran, afterPivotTranPathInfo); // find children tx //todo check it carefully.
+    logger_1.logger.info("End get children tx");
+    logger_1.logger.info("Entering get parent tx");
+    await getUpperSteps(client, scAddr, pivotTran, beforePivotTranPathInfo); // find parent tx
+    logger_1.logger.info("End get parent tx");
+    logger_1.logger.info("[pivoltTranStepInfo]====>", [pivoltTranStepInfo]);
+    logger_1.logger.info("[beforePivotTranPathInfo]====>", beforePivotTranPathInfo);
+    logger_1.logger.info("[afterPivotTranPathInfo]====>", afterPivotTranPathInfo);
+    let ret = allTranPathInfo.concat(beforePivotTranPathInfo, [pivoltTranStepInfo], afterPivotTranPathInfo);
+    logger_1.logger.info("========================ret = >", ret);
+    return ret;
+}
+// example of result
+/*
+TranResult=> {
+        addr: EQCT7rMc77KcPciOlxV-dfhYWK7RisB7lEAdGze2f0-vUI30,
+        msgInHash: '8a2fdd9e5508f06c94ff55f0d367fdaaca82207c52ed03008680319b2424bfed',
+        path: [
+        {
+            addr: EQCT7rMc77KcPciOlxV-dfhYWK7RisB7lEAdGze2f0-vUI30,
+            txHash: '3bc0e57c110eab0a0ad1d282df89a99f3c2a3aa71fcd27d2ff897bc45febd3bb',
+            gasUsed: 2577471n,
+            status: true,
+            lt: '29498261000001'
+        },
+        {
+            addr: EQBsdoNazbwI9ybbsgufhRocWBPm7emo7cZQxojqzNuvNRcC,
+            txHash: '9e4f815609fa16591648b08d186cda0d81175e3a45ee17a91754f83fe013136d',
+            gasUsed: 4319392n,
+            status: true,
+            lt: '29498264000001'
+        },
+        {
+            addr: EQCT7rMc77KcPciOlxV-dfhYWK7RisB7lEAdGze2f0-vUI30,
+            txHash: '78b3031ffed07ec7b147f24db7a80e6fda5338d1d9fdbf5e9a845dbcf12de67f',
+            gasUsed: 396405n,
+            status: true,
+            lt: '29498268000001'
+        }
+    ],
+        success: true,
+        originAddr: EQCT7rMc77KcPciOlxV-dfhYWK7RisB7lEAdGze2f0-vUI30,
+        gasUsed: 7293268n
+}
+*/
+async function getTranResultByMsgHash(client, scAddr, msgBodyCellHash, msgInHash) {
+    let path = await getTranPathInfoByMsgHash(client, scAddr, msgBodyCellHash, msgInHash);
+    let success = await isTranPathSuccess(path);
+    return {
+        addr: scAddr,
+        msgInHash,
+        path,
+        success,
+        originAddr: path[0].addr,
+        gasUsed: await computePathGas(path)
+    };
+}
+async function getTranResultByTxHash(client, scAddr, txHash, lt) {
+    let tran = await client.getTransaction(scAddr, lt, txHash);
+    let path = await getTranPathInfoByPivotTran(client, scAddr, tran);
+    let success = await isTranPathSuccess(path);
+    return {
+        addr: scAddr,
+        msgInHash: tran.inMessage.body.hash().toString('base64'),
+        path,
+        success,
+        originAddr: path[0].addr,
+        gasUsed: await computePathGas(path)
+    };
+}
+async function getTranResultByTran(client, scAddr, tran) {
+    logger_1.logger.info("Entering getTranResultByTran");
+    let path = await getTranPathInfoByPivotTran(client, scAddr, tran);
+    let success = await isTranPathSuccess(path);
+    return {
+        addr: scAddr,
+        msgInHash: tran.inMessage.body.hash().toString('base64'),
+        path,
+        success,
+        originAddr: path[0].addr,
+        gasUsed: await computePathGas(path)
+    };
+}
+async function findMsgCellHashInTran(tran, msgCellHash, msgBodyHash, lt = '') {
+    let found = false;
+    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 internalMsg = true;
+    if (tran.inMessage.info.type == 'external-in') {
+        internalMsg = false;
+    }
+    let inMessageLt = "";
+    if (internalMsg) {
+        inMessageLt = tran.inMessage.info.createdLt.toString(10);
+    }
+    if (!internalMsg) {
+        if ((inMessageHash == msgCellHash || inMessageBodyCellHash == msgBodyHash)) {
+            found = true;
+        }
+    }
+    else {
+        if ((inMessageHash == msgCellHash || inMessageBodyCellHash == msgBodyHash)) {
+            if (lt.length != 0 && (inMessageLt == lt)) {
+                found = true;
+            }
+            else {
+                if (lt.length == 0) {
+                    found = true;
+                }
+            }
+        }
+    }
+    return found;
+}
+async function findOnlyMsgCellHashInTran(tran, msgCellHash) {
+    let found = false;
+    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 internalMsg = true;
+    if (tran.inMessage.info.type == 'external-in') {
+        internalMsg = false;
+    }
+    let inMessageLt = "";
+    if (internalMsg) {
+        inMessageLt = tran.inMessage.info.createdLt.toString(10);
+    }
+    if (!internalMsg) {
+        if ((inMessageHash == msgCellHash)) {
+            found = true;
+        }
+    }
+    else {
+        if ((inMessageHash == msgCellHash)) {
+            found = true;
+        }
+    }
+    return found;
+}
+async function getTranByMsgHash(client, scAddr, msgCellHash, msgBodyHash, lt = '') {
+    let limit = const_value_1.MAX_LIMIT;
+    let retry = const_value_1.MAX_RETRY;
+    let maxRetry = retry;
+    //get from scanned db
+    let dbAccess = await DbAccess_1.DBAccess.getDBAccess();
+    let transFromDb = null;
+    while (maxRetry-- > 0 && !transFromDb) {
+        try {
+            let inDb = await dbAccess?.has(scAddr.toString());
+            if (!inDb) {
+                await dbAccess.addDbByName(scAddr.toString());
+                await sleep(const_value_1.RETRY_INTERNAL_TIME);
+            }
+            transFromDb = await dbAccess?.getTxByMsg(scAddr.toString(), msgCellHash, msgBodyHash, BigInt(lt));
+            if (transFromDb) { // found from db
+                logger_1.logger.info("getTranByMsgHash from db success", "scAddr", scAddr, "msgCellHash", msgCellHash, "msgBodyHash", msgBodyHash, "lt", lt);
+                return transFromDb;
+            }
+        }
+        catch (err) {
+            logger_1.logger.error(err);
+            logger_1.logger.error("getTranByMsgHash from db err", (0, utils_1.formatError)(err), "retry ", maxRetry, "scAddr", scAddr, "msgCellHash", msgCellHash, "msgBodyHash", msgBodyHash, "lt", lt);
+        }
+        await sleep(const_value_1.RETRY_INTERNAL_TIME);
+    }
+    logger_1.logger.info("begin getTranByMsgHash from rpc", "scAddr", scAddr, "msgCellHash", msgCellHash, "msgBodyHash", msgBodyHash, "lt", lt);
+    //get from rpc
+    maxRetry = retry;
+    let trans = [];
+    let transCount = limit;
+    let opts = {
+        limit,
+        archival: true,
+    };
+    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, scAddr, JSON.stringify(opts, utils_1.bigIntReplacer));
+                let ret = await client.getTransactions(scAddr, opts);
+                transCount = ret.length;
+                logger_1.logger.info("getTranByMsgHash getTransactions success from rpc", "opts", JSON.stringify(opts, utils_1.bigIntReplacer), "len of getTransactions", transCount, "scAddr", scAddr);
+                for (let tran of ret) {
+                    logger_1.logger.info("=====> tranHash = %s lt = %s", tran.hash().toString('base64'), tran.lt.toString(10));
+                    let found = await findMsgCellHashInTran(tran, msgCellHash, msgBodyHash, lt);
+                    if (found) {
+                        return 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("getTranByMsgHash from rpc err ", (0, utils_1.formatError)(e));
+                await sleep(const_value_1.RETRY_INTERNAL_TIME);
+            }
+        }
+        if (maxRetry == 0) {
+            throw (new Error(formatUtil("getTransactions failed after %d retry. opts is %s", retry, JSON.stringify(opts))));
+        }
+        await sleep(const_value_1.RETRY_INTERNAL_TIME);
+    }
+}
+async function getTranByOnlyMsgHash(client, scAddr, msgCellHash) {
+    let limit = const_value_1.MAX_LIMIT;
+    let retry = const_value_1.MAX_RETRY;
+    let maxRetry = retry;
+    //get from scanned db
+    let dbAccess = await DbAccess_1.DBAccess.getDBAccess();
+    let transFromDb = null;
+    while (maxRetry-- > 0 && !transFromDb) {
+        try {
+            let inDb = await dbAccess?.has(scAddr.toString());
+            if (!inDb) {
+                await dbAccess.addDbByName(scAddr.toString());
+                await sleep(10);
+            }
+            transFromDb = await dbAccess?.getTxByOnlyMsgHash(scAddr.toString(), msgCellHash);
+            if (transFromDb) { // found from db
+                return transFromDb;
+            }
+        }
+        catch (err) {
+            logger_1.logger.error("getTranByOnlyMsgHash from db err", (0, utils_1.formatError)(err), "retry ", maxRetry);
+        }
+        await sleep(10);
+    }
+    //get from rpc
+    maxRetry = retry;
+    let trans = [];
+    let transCount = limit;
+    let opts = {
+        limit,
+        archival: true,
+    };
+    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, scAddr, JSON.stringify(opts, utils_1.bigIntReplacer));
+                let ret = await client.getTransactions(scAddr, opts);
+                transCount = ret.length;
+                logger_1.logger.info("getTranByOnlyMsgHash getTransactions success from rpc", "opts", JSON.stringify(opts, utils_1.bigIntReplacer), "len of getTransactions", transCount, "scAddr", scAddr);
+                for (let tran of ret) {
+                    logger_1.logger.info("=====> tranHash = %s lt = %s", tran.hash().toString('base64'), tran.lt.toString(10));
+                    let found = await findOnlyMsgCellHashInTran(tran, msgCellHash);
+                    if (found) {
+                        return 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 sleep(const_value_1.RETRY_INTERNAL_TIME);
+            }
+        }
+        if (maxRetry == 0) {
+            throw (new Error(formatUtil("getTransactions failed after %d retry. opts is %s", retry, JSON.stringify(opts))));
+        }
+        await sleep(const_value_1.RETRY_INTERNAL_TIME);
+    }
+}

package/dist/utils/compileContract.d.ts

@@ -0,0 +1,13 @@
+import { CompilerConfig, CompilerVersion } from '@ton-community/func-js';
+import { Cell } from '@ton/core';
+export interface CR {
+    version: CompilerVersion;
+    hashHex: string;
+    codeBase64: string;
+}
+export declare function compileContract(conf: CompilerConfig): Promise<CR>;
+export declare function writeCR(filePath: string, cr: CR): void;
+export declare function doCompile(conf: CompilerConfig, resultFilePath?: string): Promise<{
+    status: boolean;
+    codeCell: Cell;
+}>;

package/dist/utils/compileContract.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileContract = compileContract;
+exports.writeCR = writeCR;
+exports.doCompile = doCompile;
+const func_js_1 = require("@ton-community/func-js");
+const core_1 = require("@ton/core");
+const fs_2 = __importDefault(require("fs"));
+const logger_1 = require("../utils/logger");
+const formatUtil = require('util');
+async function compileContract(conf) {
+    // You can get compiler version
+    let version = await (0, func_js_1.compilerVersion)();
+    let result = await (0, func_js_1.compileFunc)(conf);
+    if (result.status === 'error') {
+        logger_1.logger.error(result.message);
+        return;
+    }
+    let codeCell = core_1.Cell.fromBoc(Buffer.from(result.codeBoc, "base64"))[0];
+    logger_1.logger.info(formatUtil.format("hash=>", codeCell.hash().toString('hex')));
+    let cr = {
+        version,
+        hashHex: codeCell.hash().toString('hex'),
+        codeBase64: result.codeBoc,
+    };
+    return cr;
+}
+function writeCR(filePath, cr) {
+    return fs_2.default.writeFileSync(filePath, JSON.stringify(cr));
+}
+async function doCompile(conf, resultFilePath) {
+    let ret = await compileContract(conf);
+    //logger.info(formatUtil.format(ret?.toBoc().toString('base64'));
+    logger_1.logger.info(formatUtil.format("result file path: %s", resultFilePath));
+    if (resultFilePath) {
+        writeCR(resultFilePath, ret);
+        let cr = JSON.parse(fs_2.default.readFileSync(resultFilePath, 'utf-8'));
+        let codeCell = core_1.Cell.fromBoc(Buffer.from(cr.codeBase64, "base64"))[0];
+        return {
+            status: codeCell.hash().toString('hex') == cr.hashHex && cr.hashHex == ret?.hashHex,
+            codeCell: codeCell
+        };
+    }
+    else {
+        let codeCell = core_1.Cell.fromBoc(Buffer.from(ret?.codeBase64, "base64"))[0];
+        return {
+            status: true,
+            codeCell: codeCell,
+        };
+    }
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,16 @@
+export declare class Logger {
+    private filePath;
+    private errorFilePath;
+    private level;
+    private errorFile;
+    private file;
+    private name;
+    private logger;
+    constructor(name: any, file: any, errorFile: any, level?: string);
+    init(name: any, file: any, errorFile: any, level: any): void;
+    debug(...params: any[]): void;
+    info(...params: any[]): void;
+    warn(...params: any[]): void;
+    error(...params: any[]): void;
+}
+export declare const logger: Logger;