wan-ton-sdk 0.0.6

package/code/userLock.ts

@@ -0,0 +1,291 @@
+import {getQueryID, remove0x} from "../utils/utils";
+import {isAddrDepolyed} from "../wallet/walletContract";
+import {JettonMaster, TonClient} from "@ton/ton";
+import {BridgeAccess} from "../contractAccess/bridgeAccess";
+import {Address, beginCell, ContractProvider, internal, toNano} from "@ton/core";
+import {BIP44_CHAINID, TON_COIN_ACCOUNT_STR,LOCK_COIN,LOCK_ORIGINAL_TOKEN,LOCK_WRAPPED_TOKEN} from "../const/const-value";
+import * as opcodes from "../opcodes";
+import {Maybe} from "@ton/core/src/utils/maybe";
+import {StateInit} from "@ton/core";
+import {Cell} from "@ton/core";
+import {Blockchain} from "@ton/sandbox";
+import {Bridge} from "../Bridge";
+import {TON_FEE} from "../fee/fee";
+const formatUtil = require('util');
+
+export const LOCK_TYPE={
+    coin:1,
+    tokenOrg:2,
+    tokenWrapped:3
+}
+
+export async function buildUserLockMessages(opts: {
+    value: bigint,
+    smgID:string,
+    tokenPairID:number,
+    crossValue:bigint,
+    dstUserAccount:string, // hex string
+    bridgeScAddr:string,
+    client:TonClient|Blockchain,
+    senderAccount:string,
+}){
+
+    console.log("buildUserLockMessages","opts",opts);
+
+    let queryID = await getQueryID();
+    if(! Address.isAddress(Address.parse(opts.bridgeScAddr))){
+        throw new Error(formatUtil.format("invalid bridgeScAddr %s",opts.bridgeScAddr));
+    }
+
+    if( !(await isAddrDepolyed(opts.client,opts.bridgeScAddr))){
+        throw new Error(formatUtil.format("contract %s is not deployed",opts.bridgeScAddr));
+    }
+    let tokenPairInfo = (await getTokenPairInfo(opts.client,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,Address.parse(opts.bridgeScAddr),opts.tokenPairID,fromChainID,dstChainID));
+    console.log("lockFee=%s",lockFee.toString(10));
+    let addrTokenAccount:Address;
+    let jwAddrBridgeSc:Address;
+    let jwAddrSrc:Address;
+
+    console.log("tokenAccount",tokenAccount);
+    console.log("TON_COIN_ACCOUNT_STR",TON_COIN_ACCOUNT_STR);
+    if(tokenAccount == TON_COIN_ACCOUNT_STR){
+        jwAddrBridgeSc = jwAddrSrc = addrTokenAccount = Address.parse(TON_COIN_ACCOUNT_STR)
+        return buildLockCoinMessages(opts,jwAddrBridgeSc,jwAddrSrc,addrTokenAccount,lockFee);
+    }else{
+        addrTokenAccount = Address.parse(tokenAccount);
+        jwAddrBridgeSc = await getJettonWalletAddr(opts.client,addrTokenAccount,Address.parse(opts.bridgeScAddr))
+        jwAddrSrc = await getJettonWalletAddr(opts.client,addrTokenAccount,Address.parse(opts.senderAccount))
+
+        let jettonAdminAddr:Address;
+        jettonAdminAddr = await getJettonAdminAddr(opts.client,addrTokenAccount);
+        console.log("jettonAdminAddr from getJettonAdminAddr",jettonAdminAddr.toString());
+        addrTokenAccount = Address.parse(tokenAccount);
+        if(jettonAdminAddr.toString() == opts.bridgeScAddr.toString()){
+            return buildLockWrappedTokenMessages(opts,jwAddrBridgeSc,jwAddrSrc,addrTokenAccount,lockFee);
+        }else{
+            return buildLockOriginalTokenMessages(opts,jwAddrBridgeSc,jwAddrSrc,addrTokenAccount,lockFee);
+        }
+    }
+    throw new Error("unknown tokenAccount");
+}
+
+
+async function buildInternalMessage(src: {
+    to: Address | string,
+    value: bigint | string,
+    bounce?: Maybe<boolean>,
+    init?: Maybe<StateInit>,
+    body?: Maybe<Cell | string>
+}){
+    return internal(src);
+}
+
+async function buildLockCoinMessages(opts: {
+    value: bigint,
+    smgID:string,
+    tokenPairID:number,
+    crossValue:bigint,
+    dstUserAccount:string, // hex string
+    bridgeScAddr:string,
+    client:TonClient|Blockchain,
+    senderAccount:string,
+},jwAddrBridgeSc:Address,jwAddrSrc:Address,addrTokenAccount:Address,lockFee:bigint){
+    console.log("buildLockCoinMessages","jwAddrBridgeSc",jwAddrBridgeSc.toString(),"jwAddrSrc",jwAddrSrc.toString(),"addrTokenAccount",addrTokenAccount.toString(),"lockFee",lockFee);
+    let totalValue:bigint;
+    totalValue = opts.value + opts.crossValue;
+    console.log("totalValue=>",totalValue);
+    let queryId = await getQueryID();
+    let dstUserAccountBuffer = Buffer.from(opts.dstUserAccount,'hex');
+    let dstUserAccountBufferLen = dstUserAccountBuffer.length
+    let extraCell = beginCell()
+        .storeAddress(addrTokenAccount)
+        .storeAddress(jwAddrSrc)
+        .storeAddress(jwAddrBridgeSc)
+        .endCell()
+    let extraCell2 = beginCell()
+        .storeAddress(Address.parse(opts.senderAccount))
+        .storeUint(lockFee, 256)
+        .endCell()
+
+    let body = 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:LOCK_TYPE.coin,
+        value:totalValue,
+    }
+}
+
+async function buildLockOriginalTokenMessages(opts: {
+    value: bigint,
+    smgID:string,
+    tokenPairID:number,
+    crossValue:bigint,
+    dstUserAccount:string, // hex string
+    bridgeScAddr:string,
+    client:TonClient|Blockchain,
+    senderAccount:string,
+},jwAddrBridgeSc:Address,jwAddrSrc:Address,addrTokenAccount:Address,lockFee:bigint){
+    console.log("buildLockOriginalTokenMessages","jwAddrBridgeSc",jwAddrBridgeSc.toString(),"jwAddrSrc",jwAddrSrc.toString(),"addrTokenAccount",addrTokenAccount.toString(),"lockFee",lockFee);
+
+    if(opts.value < (lockFee + TON_FEE.NOTIFY_FEE_USER_LOCK)){ //todo value > lockFee + transUserLockFee
+        throw new Error("insufficient ton balance");
+    }
+    // forward payLoad
+    let queryId = await getQueryID();
+
+    let dstUserAccountBuffer = Buffer.from(remove0x(opts.dstUserAccount),'hex');
+    let dstUserAccountBufferLen = dstUserAccountBuffer.length
+    let extraCell = beginCell()
+        .storeAddress(addrTokenAccount)
+        .storeAddress(jwAddrSrc)
+        .storeAddress(jwAddrBridgeSc)
+        .endCell()
+    let extraCell2 = beginCell()
+        .storeAddress(Address.parse(opts.senderAccount))
+        .storeUint(lockFee, 256)
+        .endCell()
+    let body = 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()
+
+    // sendToken payLoad
+    //let forwardAmount = lockFee + toNano('0.3');
+    let forwardAmount = lockFee + TON_FEE.NOTIFY_FEE_USER_LOCK;
+    console.log("forwardAmount=>",forwardAmount);
+    let sendTokenAmount = opts.crossValue;
+    let sendJettonCel = beginCell()
+        .storeUint(0xf8a7ea5, 32) // const int op::transfer = 0xf8a7ea5;
+        .storeUint(queryId, 64) // op, queryId
+        .storeCoins(sendTokenAmount) //jetton_amount
+        .storeAddress(Address.parse(opts.bridgeScAddr))  // receive address (token)
+        //.storeAddress(Address.parse(opts.bridgeScAddr)) //response address
+        .storeAddress(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:LOCK_TYPE.tokenOrg,
+        value:opts.value,
+    }
+}
+
+async function buildLockWrappedTokenMessages(opts:any,jwAddrBridgeSc:Address,jwAddrSrc:Address,addrTokenAccount:Address,lockFee:bigint){
+    console.log("buildLockWrappedTokenMessages","jwAddrBridgeSc",jwAddrBridgeSc.toString(),"jwAddrSrc",jwAddrSrc.toString(),"addrTokenAccount",addrTokenAccount.toString(),"lockFee",lockFee);
+    let ret =  (await buildLockOriginalTokenMessages(opts,jwAddrBridgeSc,jwAddrSrc,addrTokenAccount,lockFee));
+    ret.lockType = LOCK_TYPE.tokenWrapped;
+    return ret;
+}
+
+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())
+        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.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: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)
+        let jettonMasterScOpened = await client.open(jettonMasterSc)
+        return await jettonMasterScOpened.getWalletAddress(ownerAddr)
+    }else{
+        let jettonMasterSc = JettonMaster.create(jettonMasterAddr)
+        let jettonMasterScOpened = await client.openContract(jettonMasterSc)
+        return await jettonMasterScOpened.getWalletAddress(ownerAddr)
+    }
+
+}
+
+async function getJettonAdminAddr(client:TonClient|Blockchain,jettonMasterAddr:Address){
+    console.log("in getJettonAdminAddr", "jettonMasterAddr", jettonMasterAddr.toString());
+    if(client instanceof TonClient){
+        let jettonMasterSc = JettonMaster.create(jettonMasterAddr)
+        let jettonMasterScOpened = await client.open(jettonMasterSc)
+        return (await jettonMasterScOpened.getJettonData()).adminAddress
+    }else{
+        let jettonMasterSc = JettonMaster.create(jettonMasterAddr)
+        let jettonMasterScOpened = await client.openContract(jettonMasterSc)
+        return (await jettonMasterScOpened.getJettonData()).adminAddress
+    }
+}
+
+export async function getTokenPairInfo(client:TonClient|Blockchain,bridgeScAddr:Address,tokenPairID:number){
+    let tokePairInfo ;
+    let tokenAccount = "";
+
+    if(client instanceof TonClient){
+        let ba = new BridgeAccess(client,bridgeScAddr)
+        tokePairInfo = await ba.readContract("getTokenPair",[tokenPairID])
+    }else{
+        let b = Bridge.createFromAddress(bridgeScAddr);
+        let opened = await client.openContract(b);
+        tokePairInfo = await opened.getTokenPair(tokenPairID)
+    }
+    console.log("in getTokenPairInfo","tokenPairInfo",tokePairInfo,"tokenPairId",tokenPairID);
+    if (tokePairInfo.fromChainID == BIP44_CHAINID){
+        tokenAccount = tokePairInfo.fromAccount;
+    }else{
+        if(tokePairInfo.toChainID == BIP44_CHAINID){
+            tokenAccount = tokePairInfo.toAccount;
+        }else{
+            throw new Error(formatUtil.format("invalid TokenPair %d",tokenPairID));
+        }
+    }
+
+    if(! Address.isAddress(Address.parse(tokenAccount))){
+        throw new Error(formatUtil.format("invalid tokenAccount %s",tokenAccount));
+    }
+    return {tokenAccount,srcChainID:tokePairInfo.fromChainID, toChainID:tokePairInfo.toChainID};
+}

package/common.ts

@@ -0,0 +1,62 @@
+import {
+    Address,
+    beginCell,
+    Cell,
+    Contract,
+    contractAddress,
+    ContractProvider,
+    Sender,
+    SendMode,
+    toNano
+} from '@ton/core';
+
+import {logger} from './utils/logger'
+const formatUtil = require('util');
+
+
+export class common {
+    static createFromAddress(address: Address) {
+        return address;
+    }
+
+    static computeHash(currentChainId: bigint,uniqueId:bigint,tokenPairId:bigint,value:bigint,fee:bigint,tokenAccount:Address|string,userAccount: Address) {
+
+
+        let tokenAccountBuf:Buffer
+
+        if(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 = beginCell()
+            .storeUint(currentChainId, 64)
+            .storeUint(uniqueId, 256)
+            .storeUint(tokenPairId, 32)
+            .storeUint(value, 256)
+            .storeUint(fee, 256)
+            .storeRef(
+                beginCell()
+                    .storeAddress(userAccount)
+                    .storeBuffer(tokenAccountBuf)
+                    .endCell()
+            );
+        logger.info(formatUtil.format(" tokenAccount...",tokenAccount));
+        logger.info(formatUtil.format(" tokenAccountBuf......",tokenAccountBuf.toString('hex'),tokenAccountBuf.length));
+        logger.info(formatUtil.format("(bigInt) tokenAccountBuf......",BigInt("0x" + tokenAccountBuf.toString('hex'))));
+
+        logger.info(formatUtil.format(" userAccount...",userAccount));
+        logger.info(formatUtil.format(" userAccountBuf......",userAccountBuf.toString('hex'),userAccountBuf.length));
+        logger.info(formatUtil.format("(bigInt) userAccountBuf......",BigInt("0x" + userAccountBuf.toString('hex'))));
+        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
+        };
+    }
+}

package/config/config-ex.ts

@@ -0,0 +1,25 @@
+import {TonConfig} from "../client/client";
+
+export const configTestnet:TonConfig =  {
+    network:{
+        network:"testnet", // testnet|mainnet
+    },
+    usingDbCache:true,
+    urls:[
+        {
+            //url:'',
+            //apiKey:''
+        }]
+}
+
+export const configMainnet:TonConfig =  {
+    network:{
+        network:"mainnet", // testnet|mainnet
+    },
+    //usingDbCache:true,
+    urls:[
+        {
+            //url:'',
+            //apiKey:''
+        }]
+}

package/config/config.ts

@@ -0,0 +1 @@
+

package/const/const-value.ts

@@ -0,0 +1,33 @@
+export const BIP44_CHAINID = 0x8000025f;
+export const BIP44_WANCHAIN_CHAINID = 0x8057414e; // 2153201998
+export const TON_COIN_ACCOUT = "0x0000000000000000000000000000000000000000000000000000000000000000"; // 32 bytes
+export const TON_COIN_ACCOUNT_STR = 'EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c'
+export const WK_CHIANID = "0";
+
+export const ZERO_ACCOUNT_STR = TON_COIN_ACCOUNT_STR
+
+// send_raw_message flags
+export const REVERT_ON_ERRORS = 0;
+export const PAY_FEES_SEPARATELY = 1;
+export const IGNORE_ERRORS = 2;
+export const BOUNCE_MESSAGE = 16;
+export const SELFDESTRUCT_ON_EMPTY = 32;
+
+// send_raw_message MODE
+export const NORMAL = 0;
+export const CARRY_REMAINING_GAS = 64;
+export const CARRY_REMAINING_BALANCE = 128;
+
+//
+export const LOCK_COIN = 0;
+export const LOCK_ORIGINAL_TOKEN = 1;
+export const LOCK_WRAPPED_TOKEN = 2;
+
+
+export const MAX_LIMIT = 90;
+//export const MAX_LIMIT = 10;
+export const MAX_RETRY = 3;
+
+export const MAX_BACKTRACE_SECONDS = 30*86400;
+
+export const TONCLINET_TIMEOUT = 60 * 1000 * 1000;

package/contractAccess/bridgeAccess.ts

@@ -0,0 +1,60 @@
+import core_1, { Address, Cell, Contract, ContractProvider, MessageRelaxed, Sender, SendMode } from "@ton/core";
+import {TonClient} from "@ton/ton";
+import {Bridge} from '../Bridge';
+
+import {logger} from '../utils/logger'
+import {bigIntReplacer, formatError} from "../utils/utils";
+const formatUtil = require('util');
+
+export class BridgeAccess {
+    private client: TonClient;
+    private readonly contractAddr: Address;
+
+    static create(client:TonClient,contractAddr:string):BridgeAccess {
+        let addr = Address.parse(contractAddr);
+        return new BridgeAccess(client, addr);
+    }
+
+    constructor(client:TonClient,contractAddr:Address){
+        this.client = client;
+        this.contractAddr = contractAddr;
+    }
+
+    async writeContract(methodName:string,via:Sender,opts:any){
+        if(!methodName.startsWith('send')){
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+        try{
+                let  c =  Bridge.createFromAddress(this.contractAddr);
+                logger.info(formatUtil.format("writeContract contractAddress",this.contractAddr));
+                let  cOpened =  this.client.open(c);
+                return await cOpened[methodName](via,opts);
+            }catch(err){
+                logger.info(formatUtil.format("writeContract err=>","methodName",methodName,"opts",JSON.stringify(opts,bigIntReplacer),"err",formatError(err)));
+                throw new Error(`${methodName} is not supported Non send method`);
+            }
+    }
+
+    async readContract(methodName:string,parameters:any[]){
+        if(!methodName.startsWith('get')){
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+        try{
+            let  c =  Bridge.createFromAddress(this.contractAddr);
+            let  cOpened = this.client.open(c);
+            logger.info(formatUtil.format("methodName=>",methodName));
+            return await cOpened[methodName](...parameters);
+        }catch(err){
+            logger.error(formatUtil.format(formatError(err)));
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+    }
+}
+
+/*
+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/contractAccess/groupApproveAccess.ts

@@ -0,0 +1,59 @@
+import core_1, { Address, Cell, Contract, ContractProvider, MessageRelaxed, Sender, SendMode } from "@ton/core";
+import {TonClient} from "@ton/ton";
+import {GroupApprove} from '../GroupApprove';
+
+import {logger} from '../utils/logger'
+const formatUtil = require('util');
+
+export class GroupApproveAccess {
+    private client: TonClient;
+    private readonly contractAddr: Address;
+
+    static create(client:TonClient,contractAddr:string):GroupApproveAccess {
+        let addr = Address.parse(contractAddr);
+        return new GroupApproveAccess(client, addr);
+    }
+
+    constructor(client:TonClient,contractAddr:Address){
+        this.client = client;
+        this.contractAddr = contractAddr;
+    }
+
+    async writeContract(methodName:string,via:Sender,opts:any){
+        if(!methodName.startsWith('send')){
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+        try{
+                let  c =  GroupApprove.createFromAddress(this.contractAddr);
+                logger.info(formatUtil.format("writeContract contractAddress",this.contractAddr));
+                let  cOpened =  this.client.open(c);
+                return await cOpened[methodName](via,opts);
+            }catch(err){
+                logger.info(formatUtil.format("err=>",err));
+                throw new Error(`${methodName} is not supported Non send method`);
+            }
+    }
+
+    async readContract(methodName:string,parameters:any[]){
+        if(!methodName.startsWith('get')){
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+        try{
+            let  c =  GroupApprove.createFromAddress(this.contractAddr);
+            let  cOpened = this.client.open(c);
+            logger.info(formatUtil.format("methodName=>",methodName));
+            return await cOpened[methodName](...parameters);
+        }catch(err){
+            logger.info(formatUtil.format(err));
+            throw new Error(`${methodName} is not supported Non send method`);
+        }
+    }
+}
+
+/*
+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?
+ */
+