wan-ton-sdk 0.0.15 → 0.0.16

package/dist/code/encode-decode.js

@@ -58,6 +58,8 @@ exports.codeTable = {
             let crossValue = slice.loadUintBig(256);
             let dstUserAccountLen = slice.loadUint(8);
             let dstUserAccountBuff = slice.loadBuffer(dstUserAccountLen);
+            console.log("dstUserAccountBuff", dstUserAccountBuff.toString('hex'));
+            console.log("dstUserAccountBuffLen", dstUserAccountLen);
             logger_1.logger.info("before load extraCell");
             let extraCell = slice.loadRef().beginParse();
             let addrTokenAccount = extraCell.loadAddress();
@@ -96,7 +98,7 @@ exports.codeTable = {
                 txHashBase64: opts.txHashBase64,
                 txHash: opts.txHash,
                 lt: opts?.lt,
-                from: opts?.origin,
+                from: (opts?.senderAccount).equals(core_1.Address.parse(const_value_1.TON_COIN_ACCOUNT_STR)) ? opts?.origin : opts?.senderAccount,
                 prevTransactionHash: opts?.prevTransactionHash,
                 prevTransactionLt: opts?.prevTransactionLt,
             };

package/dist/code/exports.d.ts

@@ -0,0 +1,2 @@
+export * from "./encode-decode";
+export * from "./userLock";

package/dist/code/exports.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./encode-decode"), exports);
+__exportStar(require("./userLock"), exports);

package/dist/code/userLock.d.ts

@@ -1,4 +1,6 @@
 import { Address } from "@ton/core";
+import { Maybe } from "@ton/core/src/utils/maybe";
+import { StateInit } from "@ton/core";
 import { Cell } from "@ton/core";
 import { Blockchain } from "@ton/sandbox";
 import { WanTonClient } from "../client/client-interface";
@@ -29,6 +31,53 @@ export declare function buildUserLockMessages(opts: {
     lockType: number;
     value: bigint;
 }>;
+export declare function buildInternalMessage(src: {
+    to: Address | string;
+    value: bigint | string;
+    bounce?: Maybe<boolean>;
+    init?: Maybe<StateInit>;
+    body?: Maybe<Cell | string>;
+}): Promise<import("@ton/ton").MessageRelaxed>;
+export declare function buildLockCoinMessages(opts: {
+    value: bigint;
+    smgID: string;
+    tokenPairID: number;
+    crossValue: bigint;
+    dstUserAccount: string;
+    bridgeScAddr: string;
+    client: WanTonClient | Blockchain;
+    senderAccount: string;
+}, jwAddrBridgeSc: Address, jwAddrSrc: Address, addrTokenAccount: Address, lockFee: bigint): Promise<{
+    internalMsg: import("@ton/ton").MessageRelaxed;
+    body: Cell;
+    to: string;
+    lockType: number;
+    value: bigint;
+}>;
+export declare function buildLockOriginalTokenMessages(opts: {
+    value: bigint;
+    smgID: string;
+    tokenPairID: number;
+    crossValue: bigint;
+    dstUserAccount: string;
+    bridgeScAddr: string;
+    client: WanTonClient | Blockchain;
+    senderAccount: string;
+    differentQueryID?: bigint;
+}, jwAddrBridgeSc: Address, jwAddrSrc: Address, addrTokenAccount: Address, lockFee: bigint, differentQueryID?: bigint): Promise<{
+    internalMsg: import("@ton/ton").MessageRelaxed;
+    body: Cell;
+    to: Address;
+    lockType: number;
+    value: bigint;
+}>;
+export declare function buildLockWrappedTokenMessages(opts: any, jwAddrBridgeSc: Address, jwAddrSrc: Address, addrTokenAccount: Address, lockFee: bigint, differentQueryID?: bigint): Promise<{
+    internalMsg: import("@ton/ton").MessageRelaxed;
+    body: Cell;
+    to: Address;
+    lockType: number;
+    value: bigint;
+}>;
 export declare function getFee(client: WanTonClient | Blockchain, bridgeScAddr: Address, tokenPairID: number, srcChainId: any, dstChainId: any): Promise<number>;
 export declare function getJettonWalletAddr(client: WanTonClient | Blockchain, jettonMasterAddr: Address, ownerAddr: Address): Promise<Address>;
 export declare function getJettonAdminAddr(client: WanTonClient | Blockchain, jettonMasterAddr: Address): Promise<Address>;

package/dist/code/userLock.js

@@ -35,6 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LOCK_TYPE = void 0;
 exports.buildUserLockMessages = buildUserLockMessages;
+exports.buildInternalMessage = buildInternalMessage;
+exports.buildLockCoinMessages = buildLockCoinMessages;
+exports.buildLockOriginalTokenMessages = buildLockOriginalTokenMessages;
+exports.buildLockWrappedTokenMessages = buildLockWrappedTokenMessages;
 exports.getFee = getFee;
 exports.getJettonWalletAddr = getJettonWalletAddr;
 exports.getJettonAdminAddr = getJettonAdminAddr;
@@ -106,10 +110,10 @@ async function buildInternalMessage(src) {
 async function buildLockCoinMessages(opts, jwAddrBridgeSc, jwAddrSrc, addrTokenAccount, lockFee) {
     logger_1.logger.info("buildLockCoinMessages", "jwAddrBridgeSc", jwAddrBridgeSc.toString(), "jwAddrSrc", jwAddrSrc.toString(), "addrTokenAccount", addrTokenAccount.toString(), "lockFee", lockFee);
     let totalValue;
-    totalValue = opts.value + opts.crossValue;
+    totalValue = opts.value + opts.crossValue + lockFee;
     logger_1.logger.info("totalValue=>", totalValue);
     let queryId = await (0, utils_1.getQueryID)();
-    let dstUserAccountBuffer = Buffer.from(opts.dstUserAccount, 'hex');
+    let dstUserAccountBuffer = Buffer.from((0, utils_1.remove0x)(opts.dstUserAccount), 'hex');
     let dstUserAccountBufferLen = dstUserAccountBuffer.length;
     let extraCell = (0, core_1.beginCell)()
         .storeAddress(addrTokenAccount)

package/dist/config/config-ex.d.ts

@@ -1,6 +1,7 @@
 import { TonConfig } from "../client/client";
 export declare const configTestnet: TonConfig;
 export declare const configTestnetObs: TonConfig;
+export declare const configTestnetNoDb: TonConfig;
 export declare const configMainnet: TonConfig;
 export declare const configTestTonApi: TonConfig;
 export declare const configTestTonApiNoDb: TonConfig;

package/dist/config/config-ex.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configMainTonApi = exports.configTestTonApiNoDb = exports.configTestTonApi = exports.configMainnet = exports.configTestnetObs = exports.configTestnet = void 0;
+exports.configMainTonApi = exports.configTestTonApiNoDb = exports.configTestTonApi = exports.configMainnet = exports.configTestnetNoDb = exports.configTestnetObs = exports.configTestnet = void 0;
 exports.configTestnet = {
     network: {
         network: "testnet", // testnet|mainnet
@@ -19,6 +19,18 @@ exports.configTestnetObs = {
     },
     usingDbCache: true,
 };
+exports.configTestnetNoDb = {
+    network: {
+        network: "testnet", // testnet|mainnet
+    },
+    usingDbCache: false,
+    urls: [
+        {
+        //url:'',
+        //apiKey:''
+        }
+    ]
+};
 exports.configMainnet = {
     network: {
         network: "mainnet", // testnet|mainnet

package/dist/const/const-value.d.ts

@@ -14,7 +14,7 @@ export declare const CARRY_REMAINING_GAS = 64;
 export declare const CARRY_REMAINING_BALANCE = 128;
 export declare const MAX_LIMIT = 90;
 export declare const MAX_RETRY = 3;
-export declare const MAX_BACKTRACE_SECONDS: number;
+export declare const MAX_BACKTRACE_SECONDS = 86400;
 export declare const RETRY_INTERNAL_TIME = 20;
 export declare const TONCLINET_TIMEOUT: number;
 export declare const MIN_SCAN_INTER: number;

package/dist/const/const-value.js

@@ -19,8 +19,9 @@ exports.CARRY_REMAINING_GAS = 64;
 exports.CARRY_REMAINING_BALANCE = 128;
 exports.MAX_LIMIT = 90;
 exports.MAX_RETRY = 3;
-exports.MAX_BACKTRACE_SECONDS = 30 * 86400;
+//export const MAX_BACKTRACE_SECONDS = 30*86400;
+exports.MAX_BACKTRACE_SECONDS = 86400;
 exports.RETRY_INTERNAL_TIME = 20;
 exports.TONCLINET_TIMEOUT = 60 * 1000 * 1000;
-exports.MIN_SCAN_INTER = 10 * 1000;
-exports.MAX_SCAN_INTER = 20 * 1000;
+exports.MIN_SCAN_INTER = 20 * 1000;
+exports.MAX_SCAN_INTER = 40 * 1000;

package/dist/contractAccess/bridgeAccess.js

@@ -26,8 +26,8 @@ class BridgeAccess {
             return await cOpened[methodName](via, opts);
         }
         catch (err) {
-            logger_1.logger.info(formatUtil.format("writeContract err=>", "methodName", methodName, "opts", JSON.stringify(opts, utils_1.bigIntReplacer), "err", (0, utils_1.formatError)(err)));
-            throw new Error(`${methodName} is not supported Non send method`);
+            logger_1.logger.error(formatUtil.format("writeContract err=>", "methodName", methodName, "opts", JSON.stringify(opts, utils_1.bigIntReplacer), "err", (0, utils_1.formatError)(err)));
+            throw new Error(`writeContract ${methodName} error ${(0, utils_1.formatError)(err)}`);
         }
     }
     async readContract(methodName, parameters) {
@@ -42,7 +42,7 @@ class BridgeAccess {
         }
         catch (err) {
             logger_1.logger.error(formatUtil.format((0, utils_1.formatError)(err)), "methodName", methodName, "parameters", parameters);
-            throw new Error(`${methodName} is not supported Non send method`);
+            throw new Error(`readContract ${methodName} error ${(0, utils_1.formatError)(err)}`);
         }
     }
 }

package/dist/db/Db.js

@@ -310,13 +310,18 @@ class DB {
             try {
                 let getSuccess = false;
                 let maxRetry = const_value_1.MAX_RETRY;
-                while ((maxRetry-- > 0) && (!getSuccess)) {
+                let insertSuccess = false;
+                while ((maxRetry-- > 0) && (!getSuccess || !insertSuccess)) {
                     try {
                         //let trans = await client.getTransactions(scAddress, optsOne)
                         let trans = await client.getTransactions(rawAddr, optsOne);
                         getSuccess = true;
                         this.logger.info("scanTonTxByTask get transcations one success", "optsOne", optsOne, "pivolt tran hash", trans[0].hash().toString('hex'));
                         tranPovit = trans[0];
+                        let tonTrans = (0, common_1.convertTranToTonTrans)(trans);
+                        this.logger.info("before insert povit tran", "db", this.dbName, "tranPovit.hash", tranPovit.hash().toString('base64'));
+                        await this.insertTrans(tonTrans);
+                        insertSuccess = true;
                     }
                     catch (e) {
                         this.logger.error("get transcations one err ", (0, utils_1.formatError)(e), "optsOne", optsOne);
@@ -391,7 +396,10 @@ class DB {
                         this.logger.info("scanTonTxByTask getTransactions success from rpc", "opts", JSON.stringify(opts, utils_1.bigIntReplacer), "len of getTransactions", transCount, "dbName", this.dbName);
                         for (let tran of ret) {
                             this.logger.info("(scanTonTxByTask) =====> tranHash = %s lt = %s", tran.hash().toString('base64'), tran.lt.toString(10), "dbName", this.dbName);
-                            trans.push(tran);
+                            let cci = tran.inMessage.info;
+                            if (cci?.createdAt && (BigInt(cci?.createdAt) + BigInt(const_value_1.MAX_BACKTRACE_SECONDS) >= BigInt(nowTimeStamp))) {
+                                trans.push(tran); // oldest tran should not be inserted into db.
+                            }
                         }
                         if (ret.length) {
                             opts.lt = ret[ret.length - 1].lt.toString(10);

package/dist/db/DbAccess.d.ts

@@ -18,6 +18,7 @@ export declare class DBAccess {
     getChildTxs(dbName: string, tran: TonTransaction): Promise<import("@ton/core").Transaction[]>;
     getAllTransNotHandled(dbName: string): Promise<import("@ton/core").Transaction[]>;
     getAllTrans(dbName: string): Promise<import("@ton/core").Transaction[]>;
+    insertTrans(dbName: string, trans: TonTransaction[]): Promise<void>;
     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;

package/dist/db/DbAccess.js

@@ -189,6 +189,12 @@ class DBAccess {
             return finalRet;
         }
     }
+    async insertTrans(dbName, trans) {
+        if (!this.has(dbName)) {
+            throw new Error(`db ${dbName} not exists`);
+        }
+        await this.dbs.get(this.getDbNameFinal(dbName)).inserTrans(trans);
+    }
     async getAllTransNotHandledByRange(dbName, lt, to_lt) {
         if (!this.has(dbName)) {
             throw new Error(`db ${dbName} not exists`);

package/dist/event/getEvents.d.ts

@@ -10,8 +10,10 @@ export declare function getTransactions(client: WanTonClient, scAddress: string,
     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 getEventFromTran(client: WanTonClient, tran: Transaction, scAddress: string, slim?: boolean): Promise<any>;
+export declare function getSlimEventFromTran(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 getSlimEventByTranHash(client: WanTonClient, scAddress: string, lt: string, tranHash: string): Promise<any>;
 export declare function getOpCodeFromCell(cell: Cell): Promise<number>;

package/dist/event/getEvents.js

@@ -37,9 +37,11 @@ exports.getEvents = getEvents;
 exports.getTransactions = getTransactions;
 exports.getAllTransactions = getAllTransactions;
 exports.getEventFromTran = getEventFromTran;
+exports.getSlimEventFromTran = getSlimEventFromTran;
 exports.getTransaction = getTransaction;
 exports.getTransactionFromDb = getTransactionFromDb;
 exports.getEventByTranHash = getEventByTranHash;
+exports.getSlimEventByTranHash = getSlimEventByTranHash;
 exports.getOpCodeFromCell = getOpCodeFromCell;
 const core_1 = require("@ton/core");
 const encode_decode_1 = require("../code/encode-decode");
@@ -51,6 +53,7 @@ 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");
+const common_1 = require("../db/common");
 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) {
@@ -89,12 +92,23 @@ async function getTransactions(client, scAddress, opts) {
     logger_1.logger.info(formatUtil.format("contractAddr=>", scAddress));
     try {
         ret = await client.getTransactions(scAddr, opts);
+        await insertTransByRpc(scAddr, ret);
     }
     catch (err) {
         logger_1.logger.error((0, utils_1.formatError)(err), "getTransactions from RPC server opts = %s", opts);
     }
     return ret;
 }
+async function insertTransByRpc(scAddress, trans) {
+    let dbAccess = await DbAccess_1.DBAccess.getDBAccess();
+    if (!dbAccess) {
+        logger_1.logger.error("insertTransByRpc dbAccess null", "scAddress", scAddress.toString(), "trans.lenth", trans.length);
+        return null;
+    }
+    let tonTrans = (0, common_1.convertTranToTonTrans)(trans);
+    await dbAccess.insertTrans(scAddress.toString(), tonTrans);
+    logger_1.logger.error("insertTransByRpc successfully", "scAddress", scAddress.toString(), "trans.lenth", trans.length);
+}
 async function getTransactionsFromDb(client, scAddress, opts) {
     logger_1.logger.info("getTransactionsFromDb opts = %s", opts);
     let scAddr = core_1.Address.parse(scAddress);
@@ -161,7 +175,7 @@ async function getAllTransactions(client, scAddress, limit, retry) {
     logger_1.logger.info("getAllTransactions success");
     return trans;
 }
-async function getEventFromTran(client, tran, scAddress) {
+async function getEventFromTran(client, tran, scAddress, slim = false) {
     logger_1.logger.info("getEventFromTran entering", "client is WanTonClient", (0, client_interface_1.IsWanTonClient)(client));
     let bodyCell = tran.inMessage?.body;
     if (!bodyCell) {
@@ -188,28 +202,31 @@ async function getEventFromTran(client, tran, scAddress) {
         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);
+            let handleResult = await handleUserLockEvent(client, core_1.Address.parse(scAddress), tran, slim);
             if (!handleResult.valid) {
                 logger_1.logger.error(formatUtil.format("handleResult OP_CROSS_UserLock is not valid", "tran.hash", tran.hash().toString("base64")));
                 return null;
             }
-            decoded.origin = handleResult.origin;
+            decoded.origin = decoded.sendAccount ? decoded.sendAccount : handleResult.origin;
         }
         else {
-            let handleResult = await handleCommonEvent(client, core_1.Address.parse(scAddress), tran);
+            let handleResult = await handleCommonEvent(client, core_1.Address.parse(scAddress), tran, slim);
             if (!handleResult.valid) {
-                logger_1.logger.error(formatUtil.format("handleResult handleCommonEvent is not valid", "tran.hash", tran.hash().toString("base64")));
+                logger_1.logger.error(formatUtil.format("handleResult handleCommonEvent is not valid", "tran.hash", tran.hash().toString("base64"), "slim", slim));
                 return null;
             }
-            decoded.origin = handleResult.origin;
+            decoded.origin = decoded.sendAccount ? decoded.sendAccount : 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)), "tran.hash", tran.hash().toString("base64"));
-        return null;
+        throw new Error(formatUtil.format("getEventFromTran err", (0, utils_1.formatError)(err)));
     }
 }
+async function getSlimEventFromTran(client, tran, scAddress) {
+    return await getEventFromTran(client, tran, scAddress, true);
+}
 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));
@@ -315,6 +332,13 @@ async function getEventByTranHash(client, scAddress, lt, tranHash) {
     logger_1.logger.info("getEventByTranHash before getEventFromTran", "client is WanTonClient", (0, client_interface_1.IsWanTonClient)(client));
     return await getEventFromTran(client, tran, scAddress);
 }
+async function getSlimEventByTranHash(client, scAddress, lt, tranHash) {
+    logger_1.logger.info("entering getSlimEventByTranHash getTransaction success", "tranHash ", tranHash, "lt", lt, "dbName", scAddress);
+    let tran = await getTransaction(client, scAddress, lt, tranHash);
+    logger_1.logger.info("getSlimEventByTranHash getTransaction success", "tranHash ", tran.hash().toString('hex'));
+    logger_1.logger.info("getSlimEventByTranHash before getEventFromTran", "client is WanTonClient", (0, client_interface_1.IsWanTonClient)(client));
+    return await getSlimEventFromTran(client, tran, scAddress);
+}
 async function getOpCodeFromCell(cell) {
     if (cell.equals(core_1.Cell.EMPTY)) {
         throw new Error("empty cell");
@@ -334,12 +358,12 @@ async function getOpCodeFromCell(cell) {
     origin: Address,    // from address, who trigger the lock event.
 }
  */
-async function handleUserLockEvent(client, scAddr, tran) {
-    return handleCommonEvent(client, scAddr, tran);
+async function handleUserLockEvent(client, scAddr, tran, slim = false) {
+    return handleCommonEvent(client, scAddr, tran, slim);
 }
-async function handleCommonEvent(client, scAddr, tran) {
+async function handleCommonEvent(client, scAddr, tran, slim = false) {
     logger_1.logger.info(formatUtil.format("Entering handleCommonEvent"));
-    let transResult = await getTransResult(client, scAddr, tran);
+    let transResult = await getTransResult(client, scAddr, tran, slim);
     if (!transResult.success) {
         logger_1.logger.error("the trans tree is not success", "tran.hash", tran.hash().toString('base64'));
         return {
@@ -381,6 +405,6 @@ async function decodeUserLock(bodyCell) {
         jwAddrBridgeSc
     };
 }
-async function getTransResult(client, scAddr, tran) {
-    return await (0, transResult_1.getTranResultByTran)(client, scAddr, tran);
+async function getTransResult(client, scAddr, tran, slim = false) {
+    return await (0, transResult_1.getTranResultByTran)(client, scAddr, tran, slim);
 }

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

@@ -31,8 +31,8 @@ async function main() {
             await (0, utils_1.sleep)(2000);
         }
         try {
-            //tonTrans = await dbAcces.getAllTransNotHandled(args[0])
-            tonTrans = await dbAcces.getAllTrans(args[0]);
+            tonTrans = await dbAcces.getAllTransNotHandled(args[0]);
+            //tonTrans = await dbAcces.getAllTrans(args[0])
             console.log("getAllTransNotHandled tonTrans.length", tonTrans.length);
         }
         catch (err) {

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

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

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

@@ -0,0 +1,73 @@
+"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 scanSlimEvent = 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]);
+            //tonTrans = await dbAcces.getAllTrans(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 getSlimEventByTranHash", "scBridgeAddr", scBridgeAddr, "lt", tonTran.lt.toString(10), "tranHash", tonTran.hash().toString('hex'));
+                let ret = await (0, getEvents_1.getSlimEventByTranHash)(client, scBridgeAddr, tonTran.lt.toString(10), tonTran.hash().toString('hex'));
+                console.log("end getSlimEventByTranHash JacobEvent ret = ", ret);
+            }
+            catch (err) {
+                console.error(err.code, err.response?.data?.error);
+                await (0, utils_1.sleep)(1000);
+                continue;
+            }
+            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);
+            await (0, utils_1.sleep)(1000);
+        }
+    };
+    let round = 1;
+    let busy = false;
+    setInterval(async () => {
+        if (!busy) {
+            busy = true;
+            console.log("round = ", round++);
+            await scanSlimEvent();
+            busy = false;
+        }
+    }, 10000);
+}
+main();
+// ts-node getAllSlimEvents-ex.ts kQDlYDH0PmST2okwTluXJ2mUDMDCzPzXF1gGz24U6H2tE9Wr

package/dist/example/getAllTrans.js

@@ -4,7 +4,7 @@ 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 scAddress = require('../testData/contractAddress.json');
+const scAddress = require('../../testData/contractAddress.json');
 const LIMIT = 10;
 let MAX_TRY_TIMES = 5;
 async function main() {

package/dist/example/jetton/getJettonInfo-ex.js

@@ -10,7 +10,7 @@ const prvList = require('../../testData/prvlist');
 let client = null;
 async function init() {
     //await wanTonSdkInit(configMainnet);
-    await (0, client_1.wanTonSdkInit)(config_ex_1.configTestnet);
+    await (0, client_1.wanTonSdkInit)(config_ex_1.configTestTonApiNoDb);
     client = await (0, client_1.getClient)();
 }
 async function DisplayJettonInfo(client, addr) {

package/dist/example/lock-release/smgRelease-ex.js

@@ -29,7 +29,7 @@ let client = null;
 let aliceWallet, aliceAddressStr, aliceAddress;
 let bobWallet, bobAddress, bobAddressStr;
 async function init() {
-    await (0, client_1.wanTonSdkInit)(config_ex_1.configMainnet);
+    //await wanTonSdkInit(configMainnet);
     await (0, client_1.wanTonSdkInit)(config_ex_1.configTestnet);
     client = await (0, client_1.getClient)();
     aliceWallet = await (0, walletContract_1.getWalletByPrvKey)(prvAlice);
@@ -92,35 +92,41 @@ async function smgRelease() {
         let transValueSmg = transValueSmgRelease;
         let ba = bridgeAccess_1.BridgeAccess.create(client, bridgeScAddr);
         for (let key of Object.keys(tokenInfo)) {
-            console.log("key:", key);
-            // if(key.toString().toLowerCase() !== "tokenwrapped"){
-            //     continue;
-            // }
-            // if(key.toString().toLowerCase() !== "coin"){
-            //     continue;
-            // }
-            // if(key.toString().toLowerCase() !== "tokenOrg".toLowerCase()){
-            //     continue;
-            // }
-            if (key.toString().toLowerCase() !== "coin".toLowerCase()) {
-                transValueSmg = fee_1.TON_FEE.TRANS_FEE_USER_LOCK_TOKEN;
+            try {
+                console.log("key:", key);
+                // if(key.toString().toLowerCase() !== "tokenwrapped"){
+                //     continue;
+                // }
+                // if(key.toString().toLowerCase() !== "coin"){
+                //     continue;
+                // }
+                // if(key.toString().toLowerCase() !== "tokenOrg".toLowerCase()){
+                //     continue;
+                // }
+                if (key.toString().toLowerCase() !== "ton".toLowerCase()) {
+                    transValueSmg = fee_1.TON_FEE.TRANS_FEE_USER_LOCK_TOKEN;
+                }
+                let smgReleasePara = await buildSmgReleaseParameters(client, {
+                    smgID: smgConfig.smgId,
+                    tokenPairID: tokenInfo[key].tokenPairId,
+                    releaseValue: smgReleaseValue,
+                    value: transValueSmg,
+                    queryID: BigInt(await (0, utils_1.getQueryID)()),
+                    uniqueID: BigInt(await (0, utils_1.getQueryID)()), // should be txHas->bigInt, here is the example.
+                    tokenCoinAccount: core_1.Address.parse(tokenInfo[key].dstTokenAcc),
+                    //tokenCoinAccount:Address.parseFriendly(tokenInfo.tokenOrg.dstTokenAcc).address,
+                    destAccount: bobAddress,
+                    fwTonAmount: fee_1.TON_FEE.FWD_TON_AMOUNT_TRANSFER_JETTON,
+                    totalTonAmount: fee_1.TON_FEE.TOTAL_TON_AMOUNT_TRANSFER_JETTON
+                }, tokenInfo[key].srcChainId, tokenInfo[key].dstChainId, core_1.Address.parse(bridgeScAddr));
+                let ret = await ba.writeContract('sendSmgRelease', aliceSender, smgReleasePara);
+                await (0, utils_1.sleep)(3000);
+                console.log("key = %s, ret of smRelease is %s", key, ret);
+            }
+            catch (err) {
+                console.error("key = %s, error: %s", key, err);
             }
-            let smgReleasePara = await buildSmgReleaseParameters(client, {
-                smgID: smgConfig.smgId,
-                tokenPairID: tokenInfo[key].tokenPairId,
-                releaseValue: smgReleaseValue,
-                value: transValueSmg,
-                queryID: BigInt(await (0, utils_1.getQueryID)()),
-                uniqueID: BigInt(await (0, utils_1.getQueryID)()), // should be txHas->bigInt, here is the example.
-                tokenCoinAccount: core_1.Address.parse(tokenInfo[key].dstTokenAcc),
-                //tokenCoinAccount:Address.parseFriendly(tokenInfo.tokenOrg.dstTokenAcc).address,
-                destAccount: bobAddress,
-                fwTonAmount: fee_1.TON_FEE.FWD_TON_AMOUNT_TRANSFER_JETTON,
-                totalTonAmount: fee_1.TON_FEE.TOTAL_TON_AMOUNT_TRANSFER_JETTON
-            }, tokenInfo[key].srcChainId, tokenInfo[key].dstChainId, core_1.Address.parse(bridgeScAddr));
-            let ret = await ba.writeContract('sendSmgRelease', aliceSender, smgReleasePara);
             await (0, utils_1.sleep)(3000);
-            console.log("key = %s, ret of smRelease is %s", key, ret);
         }
     }
     catch (e) {

package/dist/example/lock-release/userLock-ex.js

@@ -14,7 +14,7 @@ const scAddresses = require('../../testData/contractAddress.json');
 const smgCfg = require('../../testData/smg.json');
 const tokenInfo = require('../../testData/tokenInfo.json');
 let smgID = smgCfg.smgId;
-let crossValue = (0, core_1.toNano)('0.1');
+let crossValue = (0, core_1.toNano)('0.001');
 let bridgeScAddr = scAddresses.bridgeAddress;
 //let transValueUserLock = toNano('0.4')
 let transValueUserLock = (0, core_1.toNano)('1');
@@ -25,7 +25,8 @@ let aliceWallet, aliceAddress;
 async function init() {
     //await wanTonSdkInit(configMainnet);
     //await wanTonSdkInit(configTestnet);
-    await (0, client_1.wanTonSdkInit)(config_ex_1.configTestTonApiNoDb);
+    //await wanTonSdkInit(configTestTonApiNoDb);
+    await (0, client_1.wanTonSdkInit)(config_ex_1.configTestnetNoDb);
     client = await (0, client_1.getClient)();
     aliceWallet = await (0, walletContract_1.getWalletByPrvKey)(prvAlice);
     aliceAddress = aliceWallet.address.toString();
@@ -38,11 +39,12 @@ async function userLock() {
         let ba = bridgeAccess_1.BridgeAccess.create(client, bridgeScAddr);
         for (let key of Object.keys(tokenInfo)) {
             console.log("key:", key);
-            if (key.toString().toLowerCase() !== ("tokenorg").toLowerCase()) {
-                continue;
-            }
-            if (key.toString().toLowerCase() !== ("coin").toLowerCase()) {
+            if (key.toString().toLowerCase() !== ("ton").toLowerCase()) {
                 transValue = fee_1.TON_FEE.TRANS_FEE_USER_LOCK_TOKEN;
+                //continue;
+            }
+            if (key.toString().toLowerCase() !== ("wan").toLowerCase()) {
+                continue;
             }
             let ret = await ba.writeContract('sendUserLock', aliceSender, {
                 value: transValue,
@@ -60,6 +62,7 @@ async function userLock() {
     }
     catch (e) {
         console.log("err  =%s", e.Error);
+        console.log("err(detailed):", e);
     }
 }
 async function main() {