wan-ton-sdk 0.0.7 → 0.0.9

package/dist/code/userLock.js

@@ -0,0 +1,284 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCK_TYPE = void 0;
+exports.buildUserLockMessages = buildUserLockMessages;
+exports.getFee = getFee;
+exports.getJettonWalletAddr = getJettonWalletAddr;
+exports.getJettonAdminAddr = getJettonAdminAddr;
+exports.getTokenPairInfo = getTokenPairInfo;
+const utils_1 = require("../utils/utils");
+const walletContract_1 = require("../wallet/walletContract");
+const ton_1 = require("@ton/ton");
+const bridgeAccess_1 = require("../contractAccess/bridgeAccess");
+const core_1 = require("@ton/core");
+const const_value_1 = require("../const/const-value");
+const opcodes = __importStar(require("../opcodes"));
+const Bridge_1 = require("../Bridge");
+const fee_1 = require("../fee/fee");
+const client_interface_1 = require("../client/client-interface");
+const formatUtil = require('util');
+const logger_1 = require("../utils/logger");
+exports.LOCK_TYPE = {
+    coin: 1,
+    tokenOrg: 2,
+    tokenWrapped: 3
+};
+async function buildUserLockMessages(opts, differentQueryID) {
+    const { client, ...filtered } = opts;
+    logger_1.logger.info("buildUserLockMessages", "opts", filtered);
+    let queryID = await (0, utils_1.getQueryID)();
+    if (!core_1.Address.isAddress(core_1.Address.parse(opts.bridgeScAddr))) {
+        throw new Error(formatUtil.format("invalid bridgeScAddr %s", opts.bridgeScAddr));
+    }
+    if (!(await (0, walletContract_1.isAddrDepolyed)(opts.client, opts.bridgeScAddr))) {
+        throw new Error(formatUtil.format("contract %s is not deployed", opts.bridgeScAddr));
+    }
+    let tokenPairInfo = (await getTokenPairInfo(opts.client, core_1.Address.parse(opts.bridgeScAddr), opts.tokenPairID));
+    let tokenAccount = tokenPairInfo.tokenAccount;
+    let fromChainID = tokenPairInfo.srcChainID;
+    let dstChainID = tokenPairInfo.toChainID;
+    let lockFee = BigInt(await getFee(opts.client, core_1.Address.parse(opts.bridgeScAddr), opts.tokenPairID, fromChainID, dstChainID));
+    logger_1.logger.info("lockFee=%s", lockFee.toString(10));
+    let addrTokenAccount;
+    let jwAddrBridgeSc;
+    let jwAddrSrc;
+    logger_1.logger.info("tokenAccount", tokenAccount);
+    logger_1.logger.info("TON_COIN_ACCOUNT_STR", const_value_1.TON_COIN_ACCOUNT_STR);
+    if (tokenAccount == const_value_1.TON_COIN_ACCOUNT_STR) {
+        jwAddrBridgeSc = jwAddrSrc = addrTokenAccount = core_1.Address.parse(const_value_1.TON_COIN_ACCOUNT_STR);
+        return buildLockCoinMessages(opts, jwAddrBridgeSc, jwAddrSrc, addrTokenAccount, lockFee);
+    }
+    else {
+        addrTokenAccount = core_1.Address.parse(tokenAccount);
+        jwAddrBridgeSc = await getJettonWalletAddr(opts.client, addrTokenAccount, core_1.Address.parse(opts.bridgeScAddr));
+        jwAddrSrc = await getJettonWalletAddr(opts.client, addrTokenAccount, core_1.Address.parse(opts.senderAccount));
+        logger_1.logger.info("jwAddrBridgeSc(big)", (0, utils_1.AddressToBig)(jwAddrBridgeSc), "addrTokenAccount(big)", (0, utils_1.AddressToBig)(addrTokenAccount), "bridgeScAddr(big)", (0, utils_1.AddressToBig)(core_1.Address.parse(opts.bridgeScAddr)));
+        logger_1.logger.info("jwAddrSrc(big)", (0, utils_1.AddressToBig)(jwAddrSrc), "addrTokenAccount(big)", (0, utils_1.AddressToBig)(addrTokenAccount), "AddrSrc(big)", (0, utils_1.AddressToBig)(core_1.Address.parse(opts.senderAccount)));
+        let jettonAdminAddr;
+        jettonAdminAddr = await getJettonAdminAddr(opts.client, addrTokenAccount);
+        logger_1.logger.info("jettonAdminAddr from getJettonAdminAddr", jettonAdminAddr.toString());
+        addrTokenAccount = core_1.Address.parse(tokenAccount);
+        if (jettonAdminAddr.toString() == opts.bridgeScAddr.toString()) {
+            return buildLockWrappedTokenMessages(opts, jwAddrBridgeSc, jwAddrSrc, addrTokenAccount, lockFee, BigInt(differentQueryID | 0));
+        }
+        else {
+            return buildLockOriginalTokenMessages(opts, jwAddrBridgeSc, jwAddrSrc, addrTokenAccount, lockFee, BigInt(differentQueryID | 0));
+        }
+    }
+    throw new Error("unknown tokenAccount");
+}
+async function buildInternalMessage(src) {
+    return (0, core_1.internal)(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;
+    logger_1.logger.info("totalValue=>", totalValue);
+    let queryId = await (0, utils_1.getQueryID)();
+    let dstUserAccountBuffer = Buffer.from(opts.dstUserAccount, 'hex');
+    let dstUserAccountBufferLen = dstUserAccountBuffer.length;
+    let extraCell = (0, core_1.beginCell)()
+        .storeAddress(addrTokenAccount)
+        .storeAddress(jwAddrSrc)
+        .storeAddress(jwAddrBridgeSc)
+        .endCell();
+    let extraCell2 = (0, core_1.beginCell)()
+        .storeAddress(core_1.Address.parse(opts.senderAccount))
+        .storeUint(lockFee, 256)
+        .endCell();
+    let body = (0, core_1.beginCell)()
+        .storeUint(opcodes.OP_CROSS_UserLock, 32)
+        .storeUint(queryId, 64)
+        .storeUint(BigInt(opts.smgID), 256)
+        .storeUint(opts.tokenPairID, 32)
+        .storeUint(opts.crossValue, 256)
+        .storeUint(dstUserAccountBufferLen, 8)
+        .storeBuffer(dstUserAccountBuffer, dstUserAccountBufferLen)
+        .storeRef(extraCell)
+        .storeRef(extraCell2)
+        .endCell();
+    let msg = await buildInternalMessage({ to: opts.bridgeScAddr, value: totalValue, body: body, bounce: true });
+    return {
+        internalMsg: msg,
+        body: body,
+        to: opts.bridgeScAddr,
+        lockType: exports.LOCK_TYPE.coin,
+        value: totalValue,
+    };
+}
+async function buildLockOriginalTokenMessages(opts, jwAddrBridgeSc, jwAddrSrc, addrTokenAccount, lockFee, differentQueryID) {
+    logger_1.logger.info("buildLockOriginalTokenMessages", "jwAddrBridgeSc", jwAddrBridgeSc.toString(), "jwAddrSrc", jwAddrSrc.toString(), "jwAddrSrcBig", (0, utils_1.AddressToBig)(jwAddrSrc), "addrTokenAccount", addrTokenAccount.toString(), "lockFee", lockFee);
+    if (opts.value < (lockFee + fee_1.TON_FEE.NOTIFY_FEE_USER_LOCK)) { //todo value > lockFee + transUserLockFeea
+        throw new Error("insufficient ton balance");
+    }
+    // forward payLoad
+    let queryId = await (0, utils_1.getQueryID)();
+    let dstUserAccountBuffer = Buffer.from((0, utils_1.remove0x)(opts.dstUserAccount), 'hex');
+    let dstUserAccountBufferLen = dstUserAccountBuffer.length;
+    let extraCell = (0, core_1.beginCell)()
+        .storeAddress(addrTokenAccount)
+        .storeAddress(jwAddrSrc)
+        .storeAddress(jwAddrBridgeSc)
+        .endCell();
+    let extraCell2 = (0, core_1.beginCell)()
+        .storeAddress(core_1.Address.parse(opts.senderAccount))
+        .storeUint(lockFee, 256)
+        .endCell();
+    let body = (0, core_1.beginCell)()
+        .storeUint(opcodes.OP_CROSS_UserLock, 32)
+        .storeUint(differentQueryID == BigInt(0) ? queryId : differentQueryID, 64)
+        .storeUint(BigInt(opts.smgID), 256)
+        .storeUint(opts.tokenPairID, 32)
+        .storeUint(opts.crossValue, 256)
+        .storeUint(dstUserAccountBufferLen, 8)
+        .storeBuffer(dstUserAccountBuffer, dstUserAccountBufferLen)
+        .storeRef(extraCell)
+        .storeRef(extraCell2)
+        .endCell();
+    // sendToken payLoad
+    //let forwardAmount = lockFee + toNano('0.3');
+    let forwardAmount = lockFee + fee_1.TON_FEE.NOTIFY_FEE_USER_LOCK;
+    logger_1.logger.info("forwardAmount=>", forwardAmount);
+    let sendTokenAmount = opts.crossValue;
+    let sendJettonCel = (0, core_1.beginCell)()
+        .storeUint(0xf8a7ea5, 32) // const int op::transfer = 0xf8a7ea5;
+        .storeUint(queryId, 64) // op, queryId
+        .storeCoins(sendTokenAmount) //jetton_amount
+        .storeAddress(core_1.Address.parse(opts.bridgeScAddr)) // receive address (token)
+        //.storeAddress(Address.parse(opts.bridgeScAddr)) //response address
+        .storeAddress(core_1.Address.parse(opts.senderAccount))
+        .storeMaybeRef(null)
+        .storeCoins(forwardAmount) // forward_ton_amount
+        .storeMaybeRef(body) //forwardPayload
+        .endCell();
+    let msg = await buildInternalMessage({ to: jwAddrSrc, value: opts.value, body: sendJettonCel, bounce: true });
+    return {
+        internalMsg: msg,
+        body: sendJettonCel,
+        to: jwAddrSrc,
+        lockType: exports.LOCK_TYPE.tokenOrg,
+        value: opts.value,
+    };
+}
+async function buildLockWrappedTokenMessages(opts, jwAddrBridgeSc, jwAddrSrc, addrTokenAccount, lockFee, differentQueryID) {
+    logger_1.logger.info("buildLockWrappedTokenMessages", "jwAddrBridgeSc", jwAddrBridgeSc.toString(), "jwAddrSrc", jwAddrSrc.toString(), "addrTokenAccount", addrTokenAccount.toString(), "lockFee", lockFee);
+    let ret = (await buildLockOriginalTokenMessages(opts, jwAddrBridgeSc, jwAddrSrc, addrTokenAccount, lockFee));
+    ret.lockType = exports.LOCK_TYPE.tokenWrapped;
+    return ret;
+}
+async function getFee(client, bridgeScAddr, tokenPairID, srcChainId, dstChainId) {
+    let fee = 0;
+    if ((0, client_interface_1.IsWanTonClient)(client)) {
+        let ba = bridgeAccess_1.BridgeAccess.create(client, bridgeScAddr.toString());
+        let feeTp = await ba.readContract("getChainFee", [srcChainId, dstChainId]);
+        if (feeTp.contractFee != 0) {
+            fee = feeTp.contractFee;
+        }
+        else {
+            fee = await ba.readContract("getTokenPairFee", [tokenPairID]);
+        }
+    }
+    else {
+        let b = await Bridge_1.Bridge.createFromAddress(bridgeScAddr);
+        let opened = await client.openContract(b);
+        let feeTp = await opened.getChainFee(srcChainId, dstChainId);
+        if (feeTp.contractFee != 0) {
+            fee = feeTp.contractFee;
+        }
+        else {
+            fee = await opened.getTokenPairFee(tokenPairID);
+        }
+    }
+    return fee;
+}
+async function getJettonWalletAddr(client, jettonMasterAddr, ownerAddr) {
+    logger_1.logger.info("in getJettonWalletAddr", "jettonMasterAddr", jettonMasterAddr.toString(), "ownerAddr", ownerAddr.toString());
+    if ((0, client_interface_1.IsWanTonClient)(client)) {
+        let jettonMasterSc = ton_1.JettonMaster.create(jettonMasterAddr);
+        let jettonMasterScOpened = await client.open(jettonMasterSc);
+        return await jettonMasterScOpened.getWalletAddress(ownerAddr);
+    }
+    else {
+        let jettonMasterSc = ton_1.JettonMaster.create(jettonMasterAddr);
+        let jettonMasterScOpened = await client.openContract(jettonMasterSc);
+        return await jettonMasterScOpened.getWalletAddress(ownerAddr);
+    }
+}
+async function getJettonAdminAddr(client, jettonMasterAddr) {
+    logger_1.logger.info("in getJettonAdminAddr", "jettonMasterAddr", jettonMasterAddr.toString());
+    if ((0, client_interface_1.IsWanTonClient)(client)) {
+        let jettonMasterSc = ton_1.JettonMaster.create(jettonMasterAddr);
+        let jettonMasterScOpened = await client.open(jettonMasterSc);
+        return (await jettonMasterScOpened.getJettonData()).adminAddress;
+    }
+    else {
+        let jettonMasterSc = ton_1.JettonMaster.create(jettonMasterAddr);
+        let jettonMasterScOpened = await client.openContract(jettonMasterSc);
+        return (await jettonMasterScOpened.getJettonData()).adminAddress;
+    }
+}
+async function getTokenPairInfo(client, bridgeScAddr, tokenPairID) {
+    let tokePairInfo;
+    let tokenAccount = "";
+    if ((0, client_interface_1.IsWanTonClient)(client)) {
+        logger_1.logger.info("Entering getTokenPairInfo IsWanTonClient true");
+        let ba = new bridgeAccess_1.BridgeAccess(client, bridgeScAddr);
+        tokePairInfo = await ba.readContract("getTokenPair", [tokenPairID]);
+    }
+    else {
+        logger_1.logger.info("Entering getTokenPairInfo IsWanTonClient false");
+        let b = Bridge_1.Bridge.createFromAddress(bridgeScAddr);
+        let opened = await client.openContract(b);
+        tokePairInfo = await opened.getTokenPair(tokenPairID);
+    }
+    logger_1.logger.info("in getTokenPairInfo", "tokenPairInfo", tokePairInfo, "tokenPairId", tokenPairID);
+    if (tokePairInfo.fromChainID == const_value_1.BIP44_CHAINID) {
+        tokenAccount = tokePairInfo.fromAccount;
+    }
+    else {
+        if (tokePairInfo.toChainID == const_value_1.BIP44_CHAINID) {
+            tokenAccount = tokePairInfo.toAccount;
+        }
+        else {
+            throw new Error(formatUtil.format("invalid TokenPair %d", tokenPairID));
+        }
+    }
+    if (!core_1.Address.isAddress(core_1.Address.parse(tokenAccount))) {
+        throw new Error(formatUtil.format("invalid tokenAccount %s", tokenAccount));
+    }
+    return { tokenAccount, srcChainID: tokePairInfo.fromChainID, toChainID: tokePairInfo.toChainID };
+}

package/dist/common.d.ts

@@ -0,0 +1,9 @@
+import { Address } from '@ton/core';
+export declare class common {
+    static createFromAddress(address: Address): Address;
+    static computeHash(currentChainId: bigint, uniqueId: bigint, tokenPairId: bigint, value: bigint, fee: bigint, tokenAccount: Address | string, userAccount: Address): {
+        hashHex: string;
+        hashBig: bigint;
+        hashBuf: Buffer;
+    };
+}

package/dist/common.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.common = void 0;
+const core_1 = require("@ton/core");
+const logger_1 = require("./utils/logger");
+const formatUtil = require('util');
+class common {
+    static createFromAddress(address) {
+        return address;
+    }
+    static computeHash(currentChainId, uniqueId, tokenPairId, value, fee, tokenAccount, userAccount) {
+        let tokenAccountBuf;
+        if (core_1.Address.isAddress(tokenAccount)) {
+            tokenAccountBuf = tokenAccount.hash;
+        }
+        else {
+            tokenAccountBuf = Buffer.from(tokenAccount.substring(0, 2).toLowerCase() == '0x' ? tokenAccount.substring(2) : tokenAccount, 'hex');
+        }
+        let userAccountBuf = userAccount.hash;
+        let msg = (0, core_1.beginCell)()
+            .storeUint(currentChainId, 64)
+            .storeUint(uniqueId, 256)
+            .storeUint(tokenPairId, 32)
+            .storeUint(value, 256)
+            .storeUint(fee, 256)
+            .storeRef((0, core_1.beginCell)()
+            .storeAddress(userAccount)
+            .storeBuffer(tokenAccountBuf)
+            .endCell());
+        logger_1.logger.info(formatUtil.format(" tokenAccount...", tokenAccount));
+        logger_1.logger.info(formatUtil.format(" tokenAccountBuf......", tokenAccountBuf.toString('hex'), tokenAccountBuf.length));
+        logger_1.logger.info(formatUtil.format("(bigInt) tokenAccountBuf......", BigInt("0x" + tokenAccountBuf.toString('hex'))));
+        logger_1.logger.info(formatUtil.format(" userAccount...", userAccount));
+        logger_1.logger.info(formatUtil.format(" userAccountBuf......", userAccountBuf.toString('hex'), userAccountBuf.length));
+        logger_1.logger.info(formatUtil.format("(bigInt) userAccountBuf......", BigInt("0x" + userAccountBuf.toString('hex'))));
+        logger_1.logger.info(formatUtil.format("user_account_cell(cell)", msg.endCell()));
+        let hashBuf = msg.endCell().hash();
+        return {
+            hashHex: hashBuf.toString('hex'),
+            hashBig: BigInt(`0x${hashBuf.toString('hex')}`),
+            hashBuf: hashBuf
+        };
+    }
+}
+exports.common = common;

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

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

package/dist/config/config-ex.js

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

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

@@ -0,0 +1,21 @@
+export declare const BIP44_CHAINID = 2147484255;
+export declare const BIP44_WANCHAIN_CHAINID = 2153201998;
+export declare const TON_COIN_ACCOUT = "0x0000000000000000000000000000000000000000000000000000000000000000";
+export declare const TON_COIN_ACCOUNT_STR = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
+export declare const WK_CHIANID = "0";
+export declare const ZERO_ACCOUNT_STR = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
+export declare const REVERT_ON_ERRORS = 0;
+export declare const PAY_FEES_SEPARATELY = 1;
+export declare const IGNORE_ERRORS = 2;
+export declare const BOUNCE_MESSAGE = 16;
+export declare const SELFDESTRUCT_ON_EMPTY = 32;
+export declare const NORMAL = 0;
+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 RETRY_INTERNAL_TIME = 20;
+export declare const TONCLINET_TIMEOUT: number;
+export declare const MIN_SCAN_INTER: number;
+export declare const MAX_SCAN_INTER: number;

package/dist/const/const-value.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SCAN_INTER = exports.MIN_SCAN_INTER = exports.TONCLINET_TIMEOUT = exports.RETRY_INTERNAL_TIME = exports.MAX_BACKTRACE_SECONDS = exports.MAX_RETRY = exports.MAX_LIMIT = exports.CARRY_REMAINING_BALANCE = exports.CARRY_REMAINING_GAS = exports.NORMAL = exports.SELFDESTRUCT_ON_EMPTY = exports.BOUNCE_MESSAGE = exports.IGNORE_ERRORS = exports.PAY_FEES_SEPARATELY = exports.REVERT_ON_ERRORS = exports.ZERO_ACCOUNT_STR = exports.WK_CHIANID = exports.TON_COIN_ACCOUNT_STR = exports.TON_COIN_ACCOUT = exports.BIP44_WANCHAIN_CHAINID = exports.BIP44_CHAINID = void 0;
+exports.BIP44_CHAINID = 0x8000025f;
+exports.BIP44_WANCHAIN_CHAINID = 0x8057414e; // 2153201998
+exports.TON_COIN_ACCOUT = "0x0000000000000000000000000000000000000000000000000000000000000000"; // 32 bytes
+exports.TON_COIN_ACCOUNT_STR = 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c';
+exports.WK_CHIANID = "0";
+exports.ZERO_ACCOUNT_STR = exports.TON_COIN_ACCOUNT_STR;
+// send_raw_message flags
+exports.REVERT_ON_ERRORS = 0;
+exports.PAY_FEES_SEPARATELY = 1;
+exports.IGNORE_ERRORS = 2;
+exports.BOUNCE_MESSAGE = 16;
+exports.SELFDESTRUCT_ON_EMPTY = 32;
+// send_raw_message MODE
+exports.NORMAL = 0;
+exports.CARRY_REMAINING_GAS = 64;
+exports.CARRY_REMAINING_BALANCE = 128;
+exports.MAX_LIMIT = 90;
+exports.MAX_RETRY = 3;
+exports.MAX_BACKTRACE_SECONDS = 30 * 86400;
+exports.RETRY_INTERNAL_TIME = 20;
+exports.TONCLINET_TIMEOUT = 60 * 1000 * 1000;
+exports.MIN_SCAN_INTER = 60 * 1000;
+exports.MAX_SCAN_INTER = 90 * 1000;

package/dist/contractAccess/bridgeAccess.d.ts

@@ -0,0 +1,10 @@
+import { Address, Sender } from "@ton/core";
+import { WanTonClient } from "../client/client-interface";
+export declare class BridgeAccess {
+    private client;
+    private readonly contractAddr;
+    static create(client: WanTonClient, contractAddr: string): BridgeAccess;
+    constructor(client: WanTonClient, contractAddr: Address);
+    writeContract(methodName: string, via: Sender, opts: any): Promise<any>;
+    readContract(methodName: string, parameters: any[]): Promise<any>;
+}

package/dist/contractAccess/bridgeAccess.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeAccess = void 0;
+const core_2 = require("@ton/core");
+const Bridge_1 = require("../Bridge");
+const logger_1 = require("../utils/logger");
+const utils_1 = require("../utils/utils");
+const formatUtil = require('util');
+class BridgeAccess {
+    static create(client, contractAddr) {
+        let addr = core_2.Address.parse(contractAddr);
+        return new BridgeAccess(client, addr);
+    }
+    constructor(client, contractAddr) {
+        this.client = client;
+        this.contractAddr = contractAddr;
+    }
+    async writeContract(methodName, via, opts) {
+        if (!methodName.startsWith('send')) {
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+        try {
+            let c = Bridge_1.Bridge.createFromAddress(this.contractAddr);
+            logger_1.logger.info(formatUtil.format("writeContract contractAddress", this.contractAddr));
+            let cOpened = this.client.open(c);
+            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`);
+        }
+    }
+    async readContract(methodName, parameters) {
+        if (!methodName.startsWith('get')) {
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+        try {
+            let c = Bridge_1.Bridge.createFromAddress(this.contractAddr);
+            let cOpened = this.client.open(c);
+            logger_1.logger.info(formatUtil.format("methodName=>", methodName));
+            return await cOpened[methodName](...parameters);
+        }
+        catch (err) {
+            logger_1.logger.error(formatUtil.format((0, utils_1.formatError)(err)));
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+    }
+}
+exports.BridgeAccess = BridgeAccess;
+/*
+1. put down all the getMethod
+2. for users, all the parameter value is hexString, or bigInt, or Address, or string
+3. convert the input value to the value which is used in Bridge.ts class
+4. use client's runGetMessage or use the Bridge.ts?
+ */

package/dist/contractAccess/groupApproveAccess.d.ts

@@ -0,0 +1,10 @@
+import { Address, Sender } from "@ton/core";
+import { WanTonClient } from "../client/client-interface";
+export declare class GroupApproveAccess {
+    private client;
+    private readonly contractAddr;
+    static create(client: WanTonClient, contractAddr: string): GroupApproveAccess;
+    constructor(client: WanTonClient, contractAddr: Address);
+    writeContract(methodName: string, via: Sender, opts: any): Promise<any>;
+    readContract(methodName: string, parameters: any[]): Promise<any>;
+}

package/dist/contractAccess/groupApproveAccess.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupApproveAccess = void 0;
+const core_2 = require("@ton/core");
+const GroupApprove_1 = require("../GroupApprove");
+const logger_1 = require("../utils/logger");
+const formatUtil = require('util');
+class GroupApproveAccess {
+    static create(client, contractAddr) {
+        let addr = core_2.Address.parse(contractAddr);
+        return new GroupApproveAccess(client, addr);
+    }
+    constructor(client, contractAddr) {
+        this.client = client;
+        this.contractAddr = contractAddr;
+    }
+    async writeContract(methodName, via, opts) {
+        if (!methodName.startsWith('send')) {
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+        try {
+            let c = GroupApprove_1.GroupApprove.createFromAddress(this.contractAddr);
+            logger_1.logger.info(formatUtil.format("writeContract contractAddress", this.contractAddr));
+            let cOpened = this.client.open(c);
+            return await cOpened[methodName](via, opts);
+        }
+        catch (err) {
+            logger_1.logger.info(formatUtil.format("err=>", err));
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+    }
+    async readContract(methodName, parameters) {
+        if (!methodName.startsWith('get')) {
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+        try {
+            let c = GroupApprove_1.GroupApprove.createFromAddress(this.contractAddr);
+            let cOpened = this.client.open(c);
+            logger_1.logger.info(formatUtil.format("methodName=>", methodName));
+            return await cOpened[methodName](...parameters);
+        }
+        catch (err) {
+            logger_1.logger.info(formatUtil.format(err));
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+    }
+}
+exports.GroupApproveAccess = GroupApproveAccess;
+/*
+1. put down all the getMethod
+2. for users, all the parameter value is hexString, or bigInt, or Address, or string
+3. convert the input value to the value which is used in GroupApprove.ts class
+4. use client's runGetMessage or use the GroupApprove.ts?
+ */

package/dist/db/Db.d.ts

@@ -0,0 +1,24 @@
+export declare enum RangeOpen {
+    CloseRange = 0,// 0
+    RightOpenRange = 1
+}
+export type TonTransaction = {
+    hash: string;
+    lt: bigint;
+    raw: string;
+    in: {
+        src: string;
+        inMsgHash: string;
+        inBodyHash: string;
+        createdLt: bigint;
+        createAt: bigint;
+    };
+    out: {
+        dst: string;
+        outMsgHash: string;
+        outBodyHash: string;
+        createdLt: bigint;
+        createAt: bigint;
+    }[];
+    emitEventOrNot: boolean;
+};