wan-ton-sdk 0.0.6

package/example/log/wan-ton-sdk.out.2025-04-30

@@ -0,0 +1,9 @@
+2025-04-30T03:43:15.696Z [info]: getClient config {"network":{"network":"testnet"},"usingDbCache":true,"urls":[{}]}
+2025-04-30T03:43:22.074Z [info]: getClient config {"network":{"network":"testnet"},"usingDbCache":true,"urls":[{}]}
+2025-04-30T03:43:42.086Z [info]: getClient config {"network":{"network":"testnet"},"usingDbCache":true,"urls":[{}]}
+2025-04-30T03:44:02.101Z [info]: getClient config {"network":{"network":"testnet"},"usingDbCache":true,"urls":[{}]}
+2025-04-30T03:44:22.115Z [info]: getClient config {"network":{"network":"testnet"},"usingDbCache":true,"urls":[{}]}
+2025-04-30T03:45:48.578Z [info]: getClient config {"network":{"network":"mainnet"},"urls":[{}]}
+2025-04-30T03:47:36.261Z [info]: getClient config {"network":{"network":"mainnet"},"urls":[{}]}
+2025-04-30T03:54:14.580Z [info]: getClient config {"network":{"network":"mainnet"},"urls":[{}]}
+2025-04-30T03:55:11.559Z [info]: getClient config {"network":{"network":"mainnet"},"urls":[{}]}

package/example/mintToken-ex.ts

@@ -0,0 +1,82 @@
+import {configTestnet,configMainnet} from "../config/config-ex";
+
+import {Address, Cell, toNano, TupleItemInt, fromNano, beginCell, Sender} from '@ton/core';
+
+import {Bridge} from '../Bridge';
+import {TON_COIN_ACCOUT, BIP44_CHAINID,TON_COIN_ACCOUNT_STR,BIP44_WANCHAIN_CHAINID} from '../const/const-value';
+
+import {getSenderByPrvKey, getTonAddrByPrvKey, getWalletByPrvKey} from "../wallet/walletContract";
+import {getClient, TonClientConfig, wanTonSdkInit} from "../client/client";
+
+const smgCfg = require('../testData/smg.json');
+
+const args = process.argv.slice(2);
+let tokenType = args[0];
+let amount = args[1];
+const prvList = require('../testData/prvlist')
+
+let deployer =null,smgFeeProxy=null,oracleAdmin = null,robotAdmin = null;
+let alicePrv,bobPrv = null;
+let aliceAddr:Address
+let bobAddr :Address
+let aliceWallet, bobWallet;
+let client = null;
+
+const scAddresses = require('../testData/contractAddress.json');
+import { BridgeAccess } from "../contractAccess/bridgeAccess";
+import {getQueryID} from "../utils/utils";
+
+
+let contractProvider =null;
+async function init(){
+    await wanTonSdkInit(configMainnet);
+    await wanTonSdkInit(configTestnet);
+    deployer = await getWalletByPrvKey(Buffer.from(prvList[0],'hex'));
+    aliceWallet = await getWalletByPrvKey(Buffer.from(prvList[1],'hex'));
+    bobWallet = await getWalletByPrvKey(Buffer.from(prvList[2],'hex'));
+
+    aliceAddr = aliceWallet.address;
+    bobAddr = bobWallet.address;
+
+    client = await getClient();
+    console.log("client=>",client);
+}
+
+const schnorr = require("../sign/tools-secp256k1.js");
+
+let tokenInfo = require('../testData/tokenInfo.json')
+
+import{JettonMinter} from "../JettonMinter";
+import{JettonWallet} from "../JettonWallet";
+import {CoinBalance,TokenBalance} from "../wallet/balance";
+import {TonClient} from "@ton/ton";
+import {TON_FEE} from "../fee/fee";
+
+
+async function mintToken(client:TonClient,tokenType: string, to: Address, amount: bigint) {
+    let jettonTokenAddr = tokenInfo[tokenType].dstTokenAcc
+    console.log("tokenAddress = %s, tokenType = %s,to= %s,amount=%d",jettonTokenAddr,tokenType,to.toString(),amount)
+    console.log("before mintToken to:%s, coin:%d,token:%d", to.toString(), await CoinBalance(client, to), await TokenBalance(client, Address.parse(jettonTokenAddr), to));
+    let via = await getSenderByPrvKey(client, Buffer.from(prvList[0], 'hex'));
+
+
+    let jettonMinter = JettonMinter.createFromAddress(jettonTokenAddr);
+    let contractProvider = client.provider(jettonTokenAddr);
+
+    let mintResult = await jettonMinter.sendMint(contractProvider, via, to, amount, TON_FEE.FWD_FEE_MINT_JETTON, TON_FEE.TOTAL_FEE_MINT_JETTON)
+    console.log("mintResult",mintResult);
+    console.log("after mintToken to:%s, coin:%d,token:%d", to.toString(), await CoinBalance(client, to), await TokenBalance(client, Address.parse(jettonTokenAddr), to));
+
+}
+
+async function main(){
+    console.log("Entering main function");
+    await init();
+    await mintToken(client,tokenType,aliceAddr,toNano(amount));
+    await mintToken(client,tokenType,bobAddr,toNano(amount));
+};
+
+main();
+
+// ts-node mintToken-ex.ts tokenWrapped  1.0
+// ts-node mintToken-ex.ts tokenOrg     1.0

package/example/setFee-ex.ts

@@ -0,0 +1,82 @@
+import {configTestnet,configMainnet} from "../config/config-ex";
+
+import {Address, Cell, toNano, TupleItemInt, fromNano, beginCell, Sender} from '@ton/core';
+
+import {Bridge} from '../Bridge';
+import {TON_COIN_ACCOUT, BIP44_CHAINID,TON_COIN_ACCOUNT_STR,BIP44_WANCHAIN_CHAINID} from '../const/const-value';
+
+import {getSenderByPrvKey, getWalletByPrvKey} from "../wallet/walletContract";
+import {getClient, TonClientConfig, wanTonSdkInit} from "../client/client";
+
+const smgCfg = require('../testData/smg.json');
+
+const args = process.argv.slice(2);
+const prvList = require('../testData/prvlist')
+
+let deployer =null,smgFeeProxy=null,oracleAdmin = null,robotAdmin = null;
+let client = null;
+
+const scAddresses = require('../testData/contractAddress.json');
+import { BridgeAccess } from "../contractAccess/bridgeAccess";
+import {getQueryID} from "../utils/utils";
+import {SandboxContract, TreasuryContract} from "@ton/sandbox";
+import {TON_FEE} from "../fee/fee";
+
+
+async function init(){
+    await wanTonSdkInit(configMainnet);
+    await wanTonSdkInit(configTestnet);
+    deployer = await getWalletByPrvKey(Buffer.from(prvList[0],'hex'));
+    client = await getClient();
+    console.log("client=>",client);
+}
+
+const schnorr = require("../sign/tools-secp256k1.js");
+
+let tokenInfo = require('../testData/tokenInfo.json')
+
+
+async  function setFee(){
+    let contractChainFee = toNano('0.01')
+    let contractTokenPairFee = toNano('0.02')
+    let agentFee = toNano('0.03')
+
+    let ba = BridgeAccess.create(client,scAddresses.bridgeAddress);
+
+    // set chain fee
+    for(let key of Object.keys(tokenInfo)){
+        const queryID=await getQueryID();
+        let via = await getSenderByPrvKey(client,Buffer.from(prvList[0],'hex'));
+        let ret = await ba.writeContract('sendSetChainFee',via,{
+            srcChainId:tokenInfo[key].srcChainId,
+            dstChainId:tokenInfo[key].dstChainId,
+            contractFee:Number(contractChainFee),
+            agentFee:Number(agentFee),
+            value: TON_FEE.TRANS_FEE_NORMAL,
+            queryID,
+        });
+
+        ret = await ba.writeContract('sendSetTokenPairFee',via,{
+            tokenPairID:tokenInfo[key].tokenPairId,
+            fee:Number(contractTokenPairFee),
+            value: TON_FEE.TRANS_FEE_NORMAL,
+            queryID,
+        });
+
+        let tokenPairFee = await ba.readContract('getTokenPairFee',[tokenInfo[key].tokenPairId])
+        console.log("tokenpairIdFee",tokenInfo[key].tokenPairId, tokenPairFee);
+
+        let chainFee = await ba.readContract('getChainFee',[tokenInfo[key].srcChainId,tokenInfo[key].dstChainId])
+        console.log("chainFee","srcChainId", tokenInfo[key].srcChainId,"desChainId",tokenInfo[key].dstChainId,chainFee);
+    }
+}
+
+async function main(){
+    console.log("Entering main function");
+    await init();
+    await setFee();
+};
+
+main();
+
+// ts-node setFee-ex.ts

package/example/setFeeProxy.ts

@@ -0,0 +1,70 @@
+import {configTestnet,configMainnet} from "../config/config-ex";
+
+import {Address, Cell, toNano, TupleItemInt, fromNano, beginCell, Sender} from '@ton/core';
+
+import {Bridge} from '../Bridge';
+import {TON_COIN_ACCOUT, BIP44_CHAINID,TON_COIN_ACCOUNT_STR,BIP44_WANCHAIN_CHAINID} from '../const/const-value';
+
+import {getSenderByPrvKey, getWalletByPrvKey} from "../wallet/walletContract";
+import {getClient, TonClientConfig, wanTonSdkInit} from "../client/client";
+
+const smgCfg = require('../testData/smg.json');
+
+const args = process.argv.slice(2);
+const prvList = require('../testData/prvlist')
+
+let deployer =null,feeProxy=null,oracleAdmin = null,robotAdmin = null;
+let client = null;
+
+const scAddresses = require('../testData/contractAddress.json');
+import { BridgeAccess } from "../contractAccess/bridgeAccess";
+import {getQueryID, sleep} from "../utils/utils";
+import {SandboxContract, TreasuryContract} from "@ton/sandbox";
+import {TON_FEE} from "../fee/fee";
+
+
+async function init(){
+    await wanTonSdkInit(configMainnet);
+    await wanTonSdkInit(configTestnet);
+    deployer = await getWalletByPrvKey(Buffer.from(prvList[0],'hex'));
+    client = await getClient();
+    console.log("client=>",client);
+
+    feeProxy = await getWalletByPrvKey(Buffer.from(prvList[4],'hex'));
+}
+
+const schnorr = require("../sign/tools-secp256k1.js");
+
+let tokenInfo = require('../testData/tokenInfo.json')
+
+const setFeeGasValue =  TON_FEE.TRANS_FEE_NORMAL
+
+async  function setFeeProxy(){
+
+    let ba = BridgeAccess.create(client,scAddresses.bridgeAddress);
+
+    // set chain fee
+
+        const queryID=await getQueryID();
+        let via = await getSenderByPrvKey(client,Buffer.from(prvList[0],'hex'));
+        let ret = await ba.writeContract('sendSetFeeProxy',via,{
+            feeProxy:feeProxy.address, // EQAqx2ITzIiFmFdXx4DNsGo5jr0Ju7Q3pL9X_qzK11klOsEx
+            value: setFeeGasValue,
+            queryID,
+        });
+
+        await sleep(3000)
+        let configInfo = await ba.readContract('getCrossConfig',[]);
+        console.log("configInfo",configInfo);
+
+}
+
+async function main(){
+    console.log("Entering main function");
+    await init();
+    await setFeeProxy();
+};
+
+main();
+
+// ts-node setFeeProxy.ts

package/example/smgRelease-ex.ts

@@ -0,0 +1,173 @@
+import {TonClient} from "@ton/ton";
+import {getClient, TonClientConfig, wanTonSdkInit} from "../client/client";
+import {getSenderByPrvKey, getWalletByPrvKey} from "../wallet/walletContract";
+import {buildUserLockMessages} from "../code/userLock";
+import {Address, toNano} from "@ton/core";
+import {BridgeAccess} from "../contractAccess/bridgeAccess";
+import {getQueryID, sleep} from "../utils/utils";
+import {common} from "../common";
+import {BIP44_CHAINID, TON_COIN_ACCOUNT_STR, TON_COIN_ACCOUT} from "../const/const-value";
+
+import {getJettonAddress } from "../wallet/jetton";
+
+const schnorr = require("../sign/tools-secp256k1.js");
+import * as util from "node:util";
+import {TON_FEE} from "../fee/fee";
+
+import {configTestnet,configMainnet} from "../config/config-ex";
+const prvList = require('../testData/prvlist')
+const prvAlice = Buffer.from(prvList[1],'hex');
+const prvBob = Buffer.from(prvList[2],'hex');
+
+const scAddresses = require('../testData/contractAddress.json');
+
+const smgCfg = require('../testData/smg.json');
+const tokenInfo = require('../testData/tokenInfo.json');
+let smgID = smgCfg.smgId
+let smgReleaseValue = toNano('0.1')
+let bridgeScAddr = scAddresses.bridgeAddress
+let transValueSmgRelease = TON_FEE.TRANS_FEE_SMG_RELEASE
+let smgAgentFee = BigInt(1000); // should get from contract.
+let dstUserAccount = "0xF6eB3CB4b187d3201AfBF96A38e62367325b29F9"
+let aliceSender;
+
+let smgConfig = require('../testData/smg.json')
+
+
+let client = null;
+let aliceWallet,aliceAddressStr,aliceAddress;
+let bobWallet,bobAddress,bobAddressStr;
+
+async function init() {
+    await wanTonSdkInit(configMainnet);
+    await wanTonSdkInit(configTestnet);
+    client = await getClient();
+    aliceWallet = await getWalletByPrvKey(prvAlice);
+    bobWallet = await getWalletByPrvKey(prvBob);
+
+    aliceAddressStr = aliceWallet.address.toString();
+    aliceAddress = aliceWallet.address;
+
+    bobAddressStr = bobWallet.address.toString();
+    bobAddress = bobWallet.address;
+    aliceSender = await getSenderByPrvKey(client, prvAlice);
+}
+
+
+async function getAgentFee(tokenPairID:number,srcChainId:number,dstChainId:number){
+    let ba = BridgeAccess.create(client,bridgeScAddr);
+    let tokenPairFee = await ba.readContract('getTokenPairFee',[tokenPairID]);
+    let chainFee = await ba.readContract('getChainFee',[srcChainId,dstChainId]);
+    if(chainFee.agentFee){
+        return chainFee.agentFee
+    }else{
+        return tokenPairFee.agentFee
+    }
+}
+const jetton = require('../wallet/jetton');
+
+async function getJettonWalletAddr(client:TonClient,tokenAccountAddr:Address,ownerAddress:Address){
+    if(tokenAccountAddr.equals(Address.parse(TON_COIN_ACCOUNT_STR))){
+        return Address.parse(TON_COIN_ACCOUNT_STR);
+    }else{
+        return getJettonAddress(client,tokenAccountAddr,ownerAddress);
+    }
+}
+
+async function buildSmgReleaseParameters(client:TonClient,input:{
+    smgID:string,
+    tokenPairID:number,
+    releaseValue:bigint,
+    value:bigint,
+    queryID:bigint,
+    uniqueID:bigint,
+    tokenCoinAccount:Address,
+    destAccount:Address,
+    fwTonAmount:bigint,
+    totalTonAmount:bigint,
+},srcChainId:number,dstChainId:number,bridgeScAddr:Address){
+    let bridgeJwAddress = await getJettonWalletAddr(client,input.tokenCoinAccount, bridgeScAddr);
+    let agentFee = await getAgentFee(input.tokenPairID,srcChainId,dstChainId);
+
+    let msgHashResult = common.computeHash(BigInt(BIP44_CHAINID),
+        BigInt(input.uniqueID),
+        BigInt(input.tokenPairID),
+        BigInt(input.releaseValue),
+        BigInt(agentFee),
+        input.tokenCoinAccount,
+        input.destAccount);
+    console.log("smgConfig.skSmg=>",smgConfig.skSmg);
+    let sig = schnorr.getSecSchnorrSByMsgHash(Buffer.from(smgConfig.skSmg,'hex'),msgHashResult.hashBuf);
+    console.log("sig=>",sig);
+    const e = BigInt(sig.e);
+
+    const p = BigInt(sig.p);
+    const s = BigInt(sig.s);
+
+    return {
+        value: input.value,
+        queryID:input.queryID,
+        uniqueID:input.uniqueID,
+        smgID:input.smgID,
+        tokenPairID:input.tokenPairID,
+        releaseValue:input.releaseValue,
+        fee:agentFee,
+        userAccount: input.destAccount,
+        bridgeJettonWalletAddr:bridgeJwAddress,
+        e,
+        p,
+        s,
+        fwTonAmount:input.fwTonAmount,
+        totalTonAmount:input.totalTonAmount,
+    }
+}
+
+async function smgRelease(){
+    try{
+        let transValueSmg : bigint = transValueSmgRelease;
+        let ba = 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 = 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 getQueryID()),
+                uniqueID:BigInt(await getQueryID()),  // should be txHas->bigInt, here is the example.
+                tokenCoinAccount:Address.parse(tokenInfo[key].dstTokenAcc),
+                //tokenCoinAccount:Address.parseFriendly(tokenInfo.tokenOrg.dstTokenAcc).address,
+                destAccount:bobAddress,
+                fwTonAmount:TON_FEE.FWD_TON_AMOUNT_TRANSFER_JETTON,
+                totalTonAmount:TON_FEE.TOTAL_TON_AMOUNT_TRANSFER_JETTON
+            },tokenInfo[key].srcChainId,tokenInfo[key].dstChainId,Address.parse(bridgeScAddr))
+            let ret = await ba.writeContract('sendSmgRelease', aliceSender, smgReleasePara)
+            await sleep(3000);
+            console.log("key = %s, ret of smRelease is %s",key,ret);
+        }
+
+    }catch(e){
+        console.log("err  =%s",e.Error,e);
+    }
+}
+async function main() {
+
+    await init();
+    await smgRelease();
+
+}
+main();

package/example/upgradeBridgeSc-ex.ts

@@ -0,0 +1,49 @@
+import {conf } from "../testData/bridge.compile.func"
+let filePath = "../testData/bridge.compiled.json";
+import {doCompile} from "../utils/compileContract";
+import {getSenderByPrvKey, getWalletByPrvKey} from "../wallet/walletContract";
+import {getClient, TonClientConfig, wanTonSdkInit} from "../client/client";
+import {getQueryID} from "../utils/utils";
+import {BridgeAccess} from "../contractAccess/bridgeAccess";
+import {toNano} from "@ton/core";
+import {TON_COIN_ACCOUNT_STR} from "../const/const-value";
+import {TON_FEE} from "../fee/fee";
+
+const prvList = require('../testData/prvlist')
+
+let client = null;
+let queryID;
+let deployer;
+import {configTestnet,configMainnet} from "../config/config-ex";
+
+const scAddresses = require('../testData/contractAddress.json');
+(async function main() {
+    await init();
+    let ret = await doCompile(conf,filePath);
+    if(ret){
+        console.log(ret);
+    }
+
+    let newCode = ret.codeCell;
+    let ba = BridgeAccess.create(client,scAddresses.bridgeAddress);
+    // write contract
+    let via = await getSenderByPrvKey(client,Buffer.from(prvList[0],'hex'));
+    let opt = {
+        sender:via,
+        value: TON_FEE.TRANS_FEE_NORMAL,
+        queryID,
+        code:newCode,
+    }
+    console.log("opt=>",opt);
+    ret = await ba.writeContract('sendUpgradeSC',via,opt);
+    console.log("sendUpgradeSC",ret);
+
+})()
+
+async function init(){
+    await wanTonSdkInit(configMainnet);
+    await wanTonSdkInit(configTestnet);
+    deployer = await getWalletByPrvKey(Buffer.from(prvList[0],'hex'));
+    queryID = await getQueryID();
+    client = await getClient();
+}

package/example/userLock-ex.ts

@@ -0,0 +1,78 @@
+import {TonClient} from "@ton/ton";
+import {getClient, TonClientConfig, wanTonSdkInit} from "../client/client";
+import {getSenderByPrvKey, getWalletByPrvKey} from "../wallet/walletContract";
+import {buildUserLockMessages} from "../code/userLock";
+import {toNano} from "@ton/core";
+import {BridgeAccess} from "../contractAccess/bridgeAccess";
+import {sleep} from "../utils/utils";
+import {TON_FEE} from "../fee/fee";
+
+import {configTestnet,configMainnet} from "../config/config-ex";
+const prvList = require('../testData/prvlist')
+const prvAlice = Buffer.from(prvList[1],'hex');
+const prvBob = Buffer.from(prvList[2],'hex');
+
+const scAddresses = require('../testData/contractAddress.json');
+
+const smgCfg = require('../testData/smg.json');
+const tokenInfo = require('../testData/tokenInfo.json');
+let smgID = smgCfg.smgId
+let crossValue = toNano('0.1')
+let bridgeScAddr = scAddresses.bridgeAddress
+//let transValueUserLock = toNano('0.4')
+let transValueUserLock = toNano('1')
+let dstUserAccount = "0xF6eB3CB4b187d3201AfBF96A38e62367325b29F9"
+let aliceSender;
+
+
+
+let client = null;
+let aliceWallet,aliceAddress;
+async function init(){
+    await wanTonSdkInit(configMainnet);
+    await wanTonSdkInit(configTestnet);
+    client = await getClient();
+     aliceWallet = await getWalletByPrvKey(prvAlice);
+     aliceAddress = aliceWallet.address.toString();
+     aliceSender = await getSenderByPrvKey(client,prvAlice);
+}
+
+async function userLock(){
+    try{
+        let transValue:bigint = transValueUserLock;
+        let ba = BridgeAccess.create(client,bridgeScAddr);
+        for(let key of Object.keys(tokenInfo)) {
+            console.log("key:",key);
+            // if(key.toString().toLowerCase() !== ("coin").toLowerCase()){
+            //     continue;
+            // }
+
+            if(key.toString().toLowerCase() !== ("coin").toLowerCase()){
+                transValue = TON_FEE.TRANS_FEE_USER_LOCK_TOKEN;
+            }
+
+            let ret = await ba.writeContract('sendUserLock', aliceSender, {
+                value: transValue,
+                smgID,
+                tokenPairID: tokenInfo[key].tokenPairId,
+                crossValue,
+                dstUserAccount,
+                bridgeScAddr,
+                client,
+                senderAccount: aliceAddress
+            })
+            await sleep(3000);
+            console.log("key = %s, ret of userLock is %s",key,ret);
+        }
+
+    }catch(e){
+        console.log("err  =%s",e.Error);
+    }
+}
+async function main() {
+
+    await init();
+    await userLock();
+
+}
+main();

package/fee/fee.ts

@@ -0,0 +1,23 @@
+//
+import {toNano} from "@ton/core";
+export const TON_FEE = {
+    TRANS_FEE_NORMAL : toNano('0.1'),
+
+    // for mint token
+    FWD_FEE_MINT_JETTON: toNano('0.01'),
+    TOTAL_FEE_MINT_JETTON: toNano('0.2'),
+
+    // for deploy contract
+    TRANS_FEE_DEPLOY: toNano('0.1'),
+
+    // for user lock
+    TRANS_FEE_USER_LOCK_TOKEN:toNano('1'),
+    NOTIFY_FEE_USER_LOCK:toNano('0.8'),
+
+    // for smg release
+    TRANS_FEE_SMG_RELEASE: toNano('0.3'),
+    TRANS_FEE_SMG_RELEASE_TOKEN:toNano('0.5'),        // for smgRelease, the first tx value
+    FWD_TON_AMOUNT_TRANSFER_JETTON:toNano('0.0'),     // for smgRelease , send token
+    TOTAL_TON_AMOUNT_TRANSFER_JETTON:toNano('0.2'),   // for smgRelease , send token
+}
+

package/index.ts

@@ -0,0 +1,67 @@
+export {
+    TonClientConfig, getClient,
+} from "./client/client";
+
+export {codeTable,} from "./code/encode-decode"
+export {buildUserLockMessages} from "./code/userLock"
+export {getTokenPairInfo} from "./code/userLock"
+
+export {
+    BIP44_CHAINID, TON_COIN_ACCOUT, TON_COIN_ACCOUNT_STR, WK_CHIANID,
+} from "./const/const-value"
+
+export {
+    getEvents,
+} from "./event/getEvents"
+
+export {
+    computeHash,
+} from "./sign/buildHash"
+
+export {
+    buildInternalMessage,
+    buildExternalMessage,
+    buildSignData,
+    signData,
+    buildRawTransaction,
+    sendRawTransaction,
+    getMsgHash,
+} from "./sign/rawTrans"
+
+export {
+    TranStepInfo, TranResult, TranPathInfo, getTranResultByMsgHash, getTranResultByTxHash, getTranByMsgHash,
+} from "./transResult/transResult"
+
+export {
+    CR, compileContract, writeCR, doCompile
+} from "./utils/compileContract"
+
+export {
+    getRandomTon, BufferrToHexString, HexStringToBuffer, getQueryID, bigIntReviver, bigIntReplacer
+} from "./utils/utils"
+
+export {
+    getJettonBalance,
+    getJettonAddress,
+    getJettonData,
+    getJettonDataContent,
+    buildWrappedJettonContent,
+    parseWrappedJettonContent
+} from "./wallet/jetton"
+
+export {
+    getWalletByMnemonic,
+    openWallet,
+    getSender,
+    getWalletByPrvKey,
+    getTonAddrByPrvKey,
+    getSenderByPrvKey,
+    getWalletAddrByPrvKey,
+    openWalletByPrvKey,
+    getWalletBySecPrvKey,
+    getTonAddrBySecPrvKey,
+    getSenderBySecPrvKey,
+    openWalletBySecPrvKey,
+    getWalletAddrBySecPrvKey,
+    isAddrDepolyed
+} from "./wallet/walletContract"

package/jest.config.ts

@@ -0,0 +1,9 @@
+import type { Config } from 'jest';
+
+const config: Config = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+};
+
+export default config;

package/log/.ba8901062aebb86bf525b42c65ff84f9485419e4-audit.json

@@ -0,0 +1,20 @@
+{
+    "keep": {
+        "days": true,
+        "amount": 10
+    },
+    "auditLog": "log/.ba8901062aebb86bf525b42c65ff84f9485419e4-audit.json",
+    "files": [
+        {
+            "date": 1745202533527,
+            "name": "log/wan-ton-sdk.out.2025-04-21",
+            "hash": "04398e7712ef33c1735d78c6eefa0f22fecd7652c9bd52e2f042bc28c5381850"
+        },
+        {
+            "date": 1745985927389,
+            "name": "log/wan-ton-sdk.out.2025-04-30",
+            "hash": "748a421be18c9cd5df822f67097edffffc9e3b5a855c66c3c8e44148862d1f14"
+        }
+    ],
+    "hashType": "sha256"
+}

package/log/wan-ton-sdk.out.2025-04-30

@@ -0,0 +1,10 @@
+2025-04-30T04:05:28.479Z [info]: getClient config undefined
+2025-04-30T04:05:29.448Z [info]: fromBuffer=> 307838333335383966636436656462366530386634633763333264346637316235346264613032393133
+2025-04-30T04:05:29.450Z [info]: toBuffer=> 0000000000000000000000000000000000000000000000000000000000000000
+2025-04-30T04:05:29.497Z [info]: fromBuffer=> 833589FCD6EDB6E08F4C7C32D4F71B54BDA02913
+2025-04-30T04:05:29.498Z [info]: toBuffer=> 0000000000000000000000000000000000000000000000000000000000000000
+2025-04-30T04:05:29.504Z [info]: fromBuffer=> 833589FCD6EDB6E08F4C7C32D4F71B54BDA02913
+2025-04-30T04:05:29.506Z [info]: toBuffer=> 0000000000000000000000000000000000000000000000000000000000000000
+2025-04-30T04:05:31.380Z [info]: Entering 
+2025-04-30T04:05:31.381Z [info]: hello Jacob  alice
+2025-04-30T04:05:32.400Z [info]: getClient config undefined