wan-ton-sdk 0.0.6 → 0.0.7

package/code/userLock.ts

@@ -211,7 +211,7 @@ async function buildLockWrappedTokenMessages(opts:any,jwAddrBridgeSc:Address,jwA
     return ret;
 }
 
-async function getFee(client:TonClient|Blockchain,bridgeScAddr:Address,tokenPairID:number,srcChainId,dstChainId){
+export async function getFee(client:TonClient|Blockchain,bridgeScAddr:Address,tokenPairID:number,srcChainId,dstChainId){
     let fee = 0;
     if(client instanceof TonClient){
         let ba = BridgeAccess.create(client,bridgeScAddr.toString())
@@ -234,7 +234,7 @@ async function getFee(client:TonClient|Blockchain,bridgeScAddr:Address,tokenPair
     return fee;
 }
 
-async function getJettonWalletAddr(client:TonClient|Blockchain,jettonMasterAddr:Address,ownerAddr:Address){
+export async function getJettonWalletAddr(client:TonClient|Blockchain,jettonMasterAddr:Address,ownerAddr:Address){
     console.log("in getJettonWalletAddr", "jettonMasterAddr", jettonMasterAddr.toString(),"ownerAddr",ownerAddr.toString());
     if(client instanceof TonClient){
         let jettonMasterSc = JettonMaster.create(jettonMasterAddr)
@@ -248,7 +248,7 @@ async function getJettonWalletAddr(client:TonClient|Blockchain,jettonMasterAddr:
 
 }
 
-async function getJettonAdminAddr(client:TonClient|Blockchain,jettonMasterAddr:Address){
+export async function getJettonAdminAddr(client:TonClient|Blockchain,jettonMasterAddr:Address){
     console.log("in getJettonAdminAddr", "jettonMasterAddr", jettonMasterAddr.toString());
     if(client instanceof TonClient){
         let jettonMasterSc = JettonMaster.create(jettonMasterAddr)

package/db/DbAccess.ts

@@ -160,6 +160,18 @@ export class DBAccess {
         }
     }
 
+    async getTxByOnlyMsgHash(dbName:string,msgCellHash:string){
+        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 convertTonTransToTrans(ret);
+        }
+    }
+
     getDbNameFinal(dbName:string){
         let dbNameFinal = dbName;
         if(Address.parse(dbName).toString()  != dbName){

package/event/getEvents.ts

@@ -156,7 +156,7 @@ export async function getAllTransactions(client:TonClient,scAddress:string,limit
     return trans;
 }
 
-async function getEventFromTran(client:TonClient,tran:Transaction, scAddress:string){
+export async function getEventFromTran(client:TonClient,tran:Transaction, scAddress:string){
     let bodyCell = tran.inMessage?.body;
     if(!bodyCell){
         console.error("body is empty","tran",tran.hash().toString("base64"));
@@ -325,7 +325,7 @@ export async function getEventByTranHash(client:TonClient, scAddress:string, lt:
     return await getEventFromTran(client,tran,scAddress);
 }
 
-async function getOpCodeFromCell(cell:Cell){
+export async function getOpCodeFromCell(cell:Cell){
     if(cell.equals(Cell.EMPTY)){
         throw new Error("empty cell");
     }

package/index.ts

@@ -1,19 +1,22 @@
 export {
-    TonClientConfig, getClient,
+    TonClientConfig, TonUrlConfig,TonConfig,getGlobalTonConfig,getClient,wanTonSdkInit
 } from "./client/client";
 
 export {codeTable,} from "./code/encode-decode"
-export {buildUserLockMessages} from "./code/userLock"
-export {getTokenPairInfo} from "./code/userLock"
+export {LOCK_TYPE,buildUserLockMessages,getFee,getJettonWalletAddr,getJettonAdminAddr,getTokenPairInfo,} from "./code/userLock"
+
+export {configTestnet,configMainnet} from "./config/config-ex"
 
 export {
     BIP44_CHAINID, TON_COIN_ACCOUT, TON_COIN_ACCOUNT_STR, WK_CHIANID,
 } from "./const/const-value"
 
 export {
-    getEvents,
+    getEvents,getTransactions,getAllTransactions,getEventFromTran,getTransaction,getTransactionFromDb,getEventByTranHash,getOpCodeFromCell
 } from "./event/getEvents"
 
+export {TON_FEE} from "./fee/fee"
+
 export {
     computeHash,
 } from "./sign/buildHash"
@@ -30,6 +33,7 @@ export {
 
 export {
     TranStepInfo, TranResult, TranPathInfo, getTranResultByMsgHash, getTranResultByTxHash, getTranByMsgHash,
+    getTranResultByTran,getTranByOnlyMsgHash
 } from "./transResult/transResult"
 
 export {
@@ -37,9 +41,13 @@ export {
 } from "./utils/compileContract"
 
 export {
-    getRandomTon, BufferrToHexString, HexStringToBuffer, getQueryID, bigIntReviver, bigIntReplacer
+    getRandomTon, BufferrToHexString, HexStringToBuffer, getQueryID, bigIntReviver,
+    bigIntReplacer,isAddressEqual,bigIntToBytes32,int64ToByte32,remove0x,add0x,
+    formatError,isValidHexString,isNotBase64,toBase64
 } from "./utils/utils"
 
+export {CoinBalance,TokenBalance} from "./wallet/balance"
+
 export {
     getJettonBalance,
     getJettonAddress,
@@ -65,3 +73,4 @@ export {
     getWalletAddrBySecPrvKey,
     isAddrDepolyed
 } from "./wallet/walletContract"
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wan-ton-sdk",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "scripts": {
     "build": "rm -rf ../wan-ton-sdk/dist && tsc",
     "test": "jest --verbose",

package/transResult/transResult.ts

@@ -90,6 +90,7 @@ export async function getUpperStepsFromDb(client:TonClient,scAddr:Address,tran:T
     let dbAccess = await DBAccess.getDBAccess();
     if(!dbAccess){
         console.error("not using db cache");
+        throw new Error("not using db cache");
     }
     let transFromDb = null;
     let foundInDb = false;
@@ -140,6 +141,7 @@ export async function getUpperSteps(client:TonClient,scAddr:Address,tran:Transac
         console.log("getUpperStepsFromDb error",formatError(err));
     }
 
+    console.log("getUpperSteps from rpc","scAddr",scAddr,"tran hash",tran.hash().toString('hex'));
     const inMessageCell = beginCell().store(storeMessage( tran.inMessage)).endCell();
     console.log("inMessageCell==>",inMessageCell.toBoc().toString('hex'));
     let tranInMsgHash = inMessageCell.hash().toString('hex');
@@ -424,6 +426,33 @@ export async function findMsgCellHashInTran(tran:Transaction,msgCellHash:string,
     return found;
 }
 
+export async function findOnlyMsgCellHashInTran(tran:Transaction,msgCellHash:string):Promise<Boolean> {
+    let found = false;
+    const inMessageCell = beginCell().store(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 as unknown as CommonMessageInfoInternal).createdLt.toString(10);
+    }
+
+    if(!internalMsg){
+        if ((inMessageHash == msgCellHash)) {
+            found = true;
+        }
+    }else{
+        if ((inMessageHash == msgCellHash)) {
+            found = true;
+        }
+    }
+
+    return found;
+}
+
 export async function getTranByMsgHash(client:TonClient, scAddr:Address, msgCellHash:string,msgBodyHash:string,lt:string=''):Promise<Transaction> {
     let limit = MAX_LIMIT;
     let retry = 5
@@ -501,121 +530,79 @@ export async function getTranByMsgHash(client:TonClient, scAddr:Address, msgCell
 
 }
 
-/*
-
-async function monitorTransactionbyHash(client, addr, txhash, txlt) {
-    let allTransactions = []
-    const myAddress = Address.parse(addr);
-    let tx = await client.getTransaction(myAddress,txlt, txhash)
-    for (const outMessage of tx.outMessages.values()) {
-        const outMessageCell = beginCell().store(storeMessage(outMessage)).endCell();
-        const outMessageHash = outMessageCell.hash().toString('hex');
-        await findTransactionbyMsgHash(client,  outMessage.info.dest.toString({testOnly:true}), outMessageHash, allTransactions)
-    }
-    let success = true
-    for(let i=0; i<allTransactions.length; i++) {
-        success = success && allTransactions[i].description.aborted==false && allTransactions[i].description.computePhase.exitCode==0
-            && allTransactions[i].description.computePhase.seccess && allTransactions[i].description.actionPhase.seccess
-    }
-    return {success,allTransactions}
-}
-
-async function monitorTransactionbyExternalIn(client, from,  msgHash){
-    let allTransactions = []
-    await waitTransactionbyExternalIn(client, from, msgHash, allTransactions);
-    let success = true
-    for(let i=0; i<allTransactions.length; i++) {
-        success = success && allTransactions[i].description.aborted==false && allTransactions[i].description.computePhase.exitCode==0
-            && allTransactions[i].description.computePhase.seccess && allTransactions[i].description.actionPhase.seccess
-    }
-    return {success,allTransactions}
-}
-
-// wait the new sub transactions to be confirmed
-async function waitTransactionbyExternalIn(client, from,  msgHash, allTransactions) {
-    const myAddress = Address.parse(from); // address that you want to fetch transactions from
-    const maxRetry = 30;
-    let retry=0;
-    let to_lt = "0"
-    while(retry++ < maxRetry) {
-        console.log("call getTransactions, para:", myAddress.toString({testOnly:true}), to_lt);
-        const transactions = await client.getTransactions(myAddress, {
-            to_lt ,
-            limit: 10,
-        });
-        console.log("transactions length:", transactions.length)
-        for (let i=0; i<transactions.length; i++) {
-            let tx = transactions[i]
-            if(i == 0) {
-                to_lt = tx.lt.toString()
+export async function getTranByOnlyMsgHash(client:TonClient, scAddr:Address, msgCellHash:string):Promise<Transaction> {
+    let limit = MAX_LIMIT;
+    let retry = 5
+    let maxRetry = retry;
+    //get from scanned db
+    let dbAccess = await 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(2000);
             }
-            const transactionHash = tx.hash().toString('hex');
-            console.log("tx hash is:",i, tx.lt, transactionHash)
-            const inMessage = tx.inMessage;
-            let inMessageHash
-            // if (inMessage?.info.type === 'external-in') {
-            const inMessageCell = beginCell().store(storeMessage(inMessage)).endCell();
-            inMessageHash = inMessageCell.hash().toString('hex');
-            //   console.log("inMessageHash", inMessageHash, msgHash);
-            if(inMessageHash == msgHash) {
-                console.log("found:", tx.lt, tx.hash().toString('hex'))
-                allTransactions.push(tx)
-                if(tx.outMessagesCount!=0){
-                    for (const outMessage of tx.outMessages.values()) {
-                        console.log("outMessage:", outMessage)
-                        const outMessageCell = beginCell().store(storeMessage(outMessage)).endCell();
-                        const outMessageHash = outMessageCell.hash().toString('hex');
-                        console.log("outMessageHash:", outMessageHash)
-                        await waitTransactionbyExternalIn(client, outMessage.info.dest.toString(), outMessageHash, allTransactions)
-                    }
-                }
-                return
+            transFromDb = await dbAccess?.getTxByOnlyMsgHash(scAddr.toString(),msgCellHash);
+            if(transFromDb){  // found from db
+                return transFromDb;
             }
+        }catch(err){
+            console.error("getTranByMsgHash from db err",formatError(err),"retry ",maxRetry);
         }
-        await sleep(1000)
+        await sleep(2000);
     }
-}
 
-// find old transactions.
-async function findTransactionbyMsgHash(client:TonClient, from:Address,  msgHash:string, allTransactions) {
-    const myAddress = from;
-    let maxRetry = 30;
-    let txOpts = {
-        limit: 10
+    //get from rpc
+    maxRetry = retry;
+
+    let trans = [];
+    let transCount = limit;
+    let opts: {
+        limit: number;
+        lt?: string;
+        hash?: string;
+        to_lt?: string;
+        inclusive?: boolean;
+        archival?: boolean;
+    } = {
+        limit,
+        archival:true,
     }
-    while(maxRetry-- > 0){
-        console.log("call findTransactionbyMsgHash, para:", from, txOpts);
-        const transactions = await client.getTransactions(from, txOpts);
-        console.log("transactions length:", transactions.length)
-        for (let i=0; i<transactions.length; i++) {
-            let tx = transactions[i]
-            // console.log("tx:", tx)
-            const transactionHash = tx.hash().toString('hex');
-            console.log("tx hash is:",i, tx.lt, transactionHash)
-            const inMessage = tx.inMessage;
-            let inMessageHash
-            // if (inMessage?.info.type === 'external-in') {
-            const inMessageCell = beginCell().store(storeMessage(inMessage)).endCell();
-            inMessageHash = inMessageCell.hash().toString('hex');
-            //   console.log("inMessageHash", inMessageHash, msgHash);
-            if(inMessageHash == msgHash) {
-                console.log("found:", tx.lt, tx.hash().toString('hex'))
-                allTransactions.push(tx)
-                if(tx.outMessagesCount!=0){
-                    for (const outMessage of tx.outMessages.values()) {
-                        console.log("outMessage:", outMessage)
-                        const outMessageCell = beginCell().store(storeMessage(outMessage)).endCell();
-                        const outMessageHash = outMessageCell.hash().toString('hex');
-                        console.log("outMessageHash:", outMessageHash)
-                        await findTransactionbyMsgHash(client, outMessage.info.dest.toString(), outMessageHash, allTransactions)
+
+    while(transCount){
+        let getSuccess = false
+        while(maxRetry-- >0 && (!getSuccess)){
+            try{
+                console.log("maxRetry = %s, getSuccess = %s, transCount = %s, scAddress = %s opts = %s",maxRetry,getSuccess,transCount,scAddr,JSON.stringify(opts,bigIntReplacer));
+                let ret = await client.getTransactions(scAddr,opts)
+                transCount = ret.length;
+                console.log("getTransactions success","opts",JSON.stringify(opts,bigIntReplacer),"len of getTransactions",transCount);
+                for(let tran of ret){
+                    console.log("=====> tranHash = %s lt = %s",tran.hash().toString('base64'),tran.lt.toString(10));
+                    let found = await findOnlyMsgCellHashInTran(tran,msgCellHash);
+                    if(found){
+                        return tran;
                     }
                 }
-                return
+                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){
+                console.error("err ",formatError(e));
+                await sleep(2000);
             }
         }
-        txOpts.hash = transactions[transactions.length - 1].hash().toString('base64')
-        txOpts.lt =  transactions[transactions.length - 1].lt.toString()
+        if(maxRetry == 0){
+            throw(new Error(formatUtil("getTransactions failed after %d retry. opts is %s",retry,JSON.stringify(opts))));
+        }
+
+        await sleep(2000);
     }
-}
 
-*/
+}

package/tsconfig.json

@@ -15,5 +15,5 @@
   },
   "include": ["./**/*"],
   "exclude": [
-    "node_modules", "./*.spec.ts"]
+    "node_modules", "./*.spec.ts","./*/*log*","./log/*"]
 }