wan-ton-sdk 0.0.6

package/opcodes.ts

@@ -0,0 +1,58 @@
+export const OP_SIG                            = 0x10000000;
+export const OP_SIG_Verify                     = 0x10000001;
+export const OP_SIG_VerifyEcdsa                = 0x10000002;
+export const OP_COMMON                         = 0x20000000;
+export const OP_COMMON_TransferOwner           = 0x20000003;
+export const OP_COMMON_SetHalt                 = 0x20000004;
+export const OP_COMMON_Finished                = 0x2000000F;
+export const OP_FEE                            = 0x30000000;
+export const OP_FEE_SetChainFee                = 0x30000001;
+export const OP_FEE_SetChainFees               = 0x30000002;
+export const OP_FEE_SetSmgFeeProxy             = 0x30000003;
+export const OP_FEE_SetFeeOperator             = 0x30000004;
+export const OP_FEE_SetTokenPairFee            = 0x30000005;
+export const OP_FEE_SetTokenPairFees           = 0x30000006;
+export const OP_FEE_AddCrossAdmin              = 0x30000007;
+export const OP_FEE_DelCrossAdmin              = 0x30000008;
+export const OP_CROSS                          = 0x40000000;
+export const OP_CROSS_UserLock                 = 0x40000001;
+export const OP_CROSS_SmgMint                  = 0x40000002;
+export const OP_CROSS_UserBurn                 = 0x40000003;
+export const OP_CROSS_UserRelease              = 0x40000004;
+export const OP_CROSS_SmgRelease               = 0x40000005;
+export const OP_CROSS_TransOwner               = 0x40000006;
+export const OP_TOKENPAIR                      = 0x50000000;
+export const OP_TOKENPAIR_Remove               = 0x50000002;
+export const OP_TOKENPAIR_Upsert               = 0x50000003;
+export const OP_ORACLE                         = 0x60000000;
+export const OP_ORACLE_TransferOracleAdmin     = 0x60000001;
+export const OP_ORACLE_SetSMG                  = 0x60000002;
+export const OP_ORACLE_CommitSMG               = 0x60000003;
+export const OP_ORACLE_DeleteSMG               = 0x60000004;
+export const OP_EXTEND                         = 0x80000000;
+export const OP_EXTEND_UpdateAddInt            = 0x80000007;
+export const OP_UPGRADE                         = 0x90000000;
+export const OP_UPGRADE_Code                    = 0x90000001;
+export const OP_GROUPAPPROVE_Proposol           = 0xa0000001;
+export const OP_GROUPAPPROVE_Execute            = 0xa0000002;
+export const OP_GROUPAPPROVE_Executed_CB            = 0xa0000003;
+export const OP_GROUPAPPROVE_TranferFoundation  = 0xa0000004;
+export const OP_GROUPAPPROVE_Execute_WithGPK    = 0xa0000005;
+export const OP_GROUPAPPROVE_Proposol_SetSmgFeeProxy    = 0xa0000010;
+export const OP_GROUPAPPROVE_Proposol_AddCrossAdmin    = 0xa0000011;
+export const OP_GROUPAPPROVE_Proposol_DelCrossAdmin    = 0xa0000012;
+export const OP_GROUPAPPROVE_Proposol_TransferOwner    = 0xa0000013;
+export const OP_GROUPAPPROVE_Proposol_SetHalt    = 0xa0000014;
+export const OP_GROUPAPPROVE_Proposol_TOKENPAIR_Upsert    = 0xa0000015;
+export const OP_GROUPAPPROVE_Proposol_TOKENPAIR_Remove    = 0xa0000016;
+export const OP_GROUPAPPROVE_Proposol_TranferFoundation    = 0xa0000017;
+export const OP_GROUPAPPROVE_Proposol_TransferOracleAdmin    = 0xa0000018;
+export const OP_GROUPAPPROVE_Proposol_TransferOperator    = 0xa000001;
+export const OP_GROUPAPPROVE_Proposol_UpgradeSc    = 0xa000001a;
+export const OP_FETCH_GPK                         = 0xb0000001;
+
+
+
+export const OP_TRANSFER_NOTIFICATION = 0x7362d09c;
+export const OP_TRANSFER = 0xf8a7ea5;
+export const OP_EXCESSES = 0xd53276db;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "wan-ton-sdk",
+  "version": "0.0.6",
+  "scripts": {
+    "build": "rm -rf ../wan-ton-sdk/dist && tsc",
+    "test": "jest --verbose",
+    "main": "../wan-ton-sdk/dist/index.js"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.14.1",
+    "jest": "29.7.0",
+    "prettier": "^3.3.2",
+    "ts-jest": "^29.2.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3"
+  },
+  "dependencies": {
+    "@orbs-network/ton-access": "^2.3.3",
+    "@ton-community/func-js": "0.7.0",
+    "@ton/blueprint": "0.22.0",
+    "@ton/core": "0.56.3",
+    "@ton/crypto": "3.3.0",
+    "@ton/sandbox": "0.20.0",
+    "@ton/ton": "13.11.2",
+    "async-mutex": "^0.5.0",
+    "bigi": "^1.4.2",
+    "json-bigint": "^1.0.0",
+    "lowdb": "^1.0.0",
+    "moment": "^2.30.1",
+    "winston": "^3.17.0",
+    "winston-daily-rotate-file": "^5.0.0"
+  }
+}

package/publish.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+
+# ------------------- 配置 -------------------
+PROJECT_ROOT=$(pwd)        # 项目根目录，默认为脚本执行目录
+OUTPUT_DIR="dist"          # TypeScript 编译输出目录
+NPM_COMMAND="npm"          # npm 命令，如果你的环境不同可以修改
+BUILD_COMMAND="npm run build" # 执行 TypeScript 编译的命令
+TEST_COMMAND="npm run test"   # 执行测试的命令 (可选)
+DRY_RUN=false              # 是否进行 npm publish 的 dry-run (模拟发布)
+# --------------------------------------------
+
+echo "开始自动编译和发布 TypeScript 项目..."
+echo "项目根目录: $PROJECT_ROOT"
+echo "输出目录: $OUTPUT_DIR"
+
+# 切换到项目根目录
+cd "$PROJECT_ROOT" || {
+  echo "错误: 无法切换到项目根目录。"
+  exit 1
+}
+
+echo "当前工作目录: $(pwd)"
+
+# 检查 package.json 和 tsconfig.json 是否存在
+if [ ! -f "package.json" ]; then
+  echo "错误: package.json 文件不存在。"
+  exit 1
+fi
+
+if [ ! -f "tsconfig.json" ]; then
+  echo "错误: tsconfig.json 文件不存在。"
+  exit 1
+fi
+
+echo "package.json 和 tsconfig.json 文件存在。"
+
+# 执行构建命令
+echo "执行构建命令: $BUILD_COMMAND"
+if ! $BUILD_COMMAND; then
+  echo "错误: TypeScript 编译失败。"
+  exit 1
+fi
+
+echo "TypeScript 编译成功，文件输出到 $OUTPUT_DIR 目录。"
+
+# 执行测试命令 (可选)
+#if [ -n "$TEST_COMMAND" ]; then
+#  echo "执行测试命令: $TEST_COMMAND"
+#  if ! $TEST_COMMAND; then
+#    echo "警告: 测试失败，但继续发布。"
+#    # 如果你希望测试失败就停止发布，取消下一行的注释
+#    # exit 1
+#  fi
+#  echo "测试通过。"
+#fi
+
+# 发布 npm 包
+echo "准备发布 npm 包..."
+
+if $DRY_RUN; then
+  echo "执行 npm publish --dry-run (模拟发布)..."
+  if ! $NPM_COMMAND publish --dry-run; then
+    echo "错误: npm publish --dry-run 失败，请检查你的 npm 配置。"
+    exit 1
+  fi
+  echo "npm publish --dry-run 成功。"
+else
+  echo "执行 npm publish..."
+  if ! $NPM_COMMAND publish; then
+    echo "错误: npm publish 失败，请检查你的 npm 配置和包版本。"
+    exit 1
+  fi
+  echo "npm 包发布成功！"
+fi
+
+echo "脚本执行完毕。"
+
+exit 0

package/sign/buildHash.ts

@@ -0,0 +1,47 @@
+import {
+    Address,
+    beginCell,
+} from '@ton/core';
+
+import {logger} from '../utils/logger'
+const formatUtil = require('util');
+
+export function 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("jacob tokenAccount...", tokenAccount));
+    logger.info(formatUtil.format("jacob tokenAccountBuf......", tokenAccountBuf.toString('hex'), tokenAccountBuf.length));
+    logger.info(formatUtil.format("(bigInt)jacob tokenAccountBuf......", BigInt("0x" + tokenAccountBuf.toString('hex'))));
+
+    logger.info(formatUtil.format("jacob userAccount...", userAccount));
+    logger.info(formatUtil.format("jacob userAccountBuf......", userAccountBuf.toString('hex'), userAccountBuf.length));
+    logger.info(formatUtil.format("(bigInt)jacob 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/sign/log/.ba8901062aebb86bf525b42c65ff84f9485419e4-audit.json

@@ -0,0 +1,15 @@
+{
+    "keep": {
+        "days": true,
+        "amount": 10
+    },
+    "auditLog": "log/.ba8901062aebb86bf525b42c65ff84f9485419e4-audit.json",
+    "files": [
+        {
+            "date": 1744604588044,
+            "name": "log/wan-ton-sdk.out.2025-04-14",
+            "hash": "94b71d3dfd41927c260dacc58b030c5acee210ef6952a6e7e491fdf4dcea1c6f"
+        }
+    ],
+    "hashType": "sha256"
+}

package/sign/log/wan-ton-sdk.out.2025-04-14

@@ -0,0 +1,3 @@
+2025-04-14T04:23:08.458Z [info]: getClient config {"network":"testnet","tonClientTimeout":60000000}
+2025-04-14T04:23:10.581Z [info]: http endpoint is => https://ton.access.orbs.network/55033c0ff5Bd3F8B62C092Ab4D238bEE463E5503/1/testnet/toncenter-api-v2/jsonRPC
+2025-04-14T04:23:10.596Z [info]: fromBuffer,toBuffer: 833589fcd6edb6e08f4c7c32d4f71b54bda02913 0000000000000000000000000000000000000000000000000000000000000000

package/sign/rawTrans.spec.ts

@@ -0,0 +1,117 @@
+import {TON_FEE} from "../fee/fee";
+
+import {configTestnet,configMainnet} from "../config/config-ex";
+
+import {Cell, toNano} from "@ton/core";
+import {
+    buildSignData,
+    signData,
+    buildRawTransaction,
+    sendRawTransaction,
+    buildInternalMessage
+} from "./rawTrans";
+import {OP_FEE_SetTokenPairFee, OP_TOKENPAIR_Upsert} from "../opcodes"
+import {BIP44_CHAINID, TON_COIN_ACCOUT, TON_COIN_ACCOUNT_STR} from "../const/const-value";
+import {codeTable} from "../code/encode-decode";
+import {getClient, TonClientConfig} from "../client/client";
+import {getSenderByPrvKey, getWalletByPrvKey, openWalletByPrvKey} from "../wallet/walletContract";
+import {sign} from "@ton/crypto";
+import {SendMode} from "@ton/core";
+import {getQueryID, sleep} from "../utils/utils";
+import {getTranResultByMsgHash} from "../transResult/transResult";
+
+let  jettonAdmin = TON_COIN_ACCOUNT_STR;
+
+let tokenInfo = {
+    tokenOrg:{tokenPairId:0x01,srcChainId:0x1234,dstChainId:BIP44_CHAINID,srcTokenAcc:"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",dstTokenAcc:'',},
+    tokenWrapped:{tokenPairId:0x02,srcChainId:0x1234,dstChainId:BIP44_CHAINID,srcTokenAcc:"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",dstTokenAcc:'',},
+    coin:{tokenPairId:0x03,srcChainId:0x1234,dstChainId:BIP44_CHAINID,srcTokenAcc:"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",dstTokenAcc:''},
+}
+let queryID ;
+let tokenPairId3 = tokenInfo.coin.tokenPairId;
+let srcChainId3 = tokenInfo.coin.srcChainId;
+let dstChainId3 = tokenInfo.coin.dstChainId;
+let srcTokenAcc3 = tokenInfo.coin.srcTokenAcc;
+let dstTokenAcc3 = tokenInfo.coin.dstTokenAcc;
+tokenInfo.coin.dstTokenAcc = TON_COIN_ACCOUT;
+
+const scAddresses = require('../testData/contractAddress.json');
+let prvList = require('../testData/prvlist.json')
+
+let client = null;
+let wallet = null;
+let walletOpenned = null;
+let privateKey = Buffer.from(prvList[0],'hex')
+
+describe('sendRawTransaction', () => {
+
+    beforeAll(async () => {
+        client = await getClient();
+        wallet = await getWalletByPrvKey(privateKey);
+        walletOpenned = await openWalletByPrvKey(client , privateKey);
+        queryID = await getQueryID();
+    },50000);
+
+    it('build rawTrans, sign, and send rawTrans', async () => {
+        // build body
+        let opt = {
+            value: TON_FEE.TRANS_FEE_NORMAL,
+            queryID,
+            tokenPairId: tokenPairId3,
+            fromChainID: srcChainId3,
+            fromAccount: srcTokenAcc3,
+            toChainID: dstChainId3,
+            toAccount: dstTokenAcc3,
+            jettonAdminAddr:jettonAdmin,
+        }
+        let bodyCell = codeTable[OP_TOKENPAIR_Upsert]["enCode"](opt);
+
+        // build message
+        let message = await buildInternalMessage(wallet.address,{
+            to:scAddresses.bridgeAddress,
+            value:TON_FEE.TRANS_FEE_NORMAL,
+            bounce:true,
+            body:bodyCell,
+        })
+
+        // build data for sign
+        let seqno = await walletOpenned.getSeqno();
+        let walletId = 698983191; // provide by user
+        let timeoutTimeStamp = Math.floor(Date.now() / 1e3) + 60;  // experiment timestamp.
+        let dataNeedSign = await buildSignData({
+            seqno:seqno,
+            sendMode:SendMode.PAY_GAS_SEPARATELY,
+            walletId:walletId,
+            messages:[message],
+            timeout:timeoutTimeStamp,
+        });
+
+        for(let msgHash of dataNeedSign.msgHashs){
+            console.log("msgHash is ",msgHash);
+        }
+
+        console.log("hash of signData =>",dataNeedSign.hash.toString('hex'));
+
+        // sign data
+        let signature = sign(dataNeedSign.hash,privateKey);
+
+        // build rawTrans
+        let rawTrans = await buildRawTransaction(signature,dataNeedSign.rawDataBuilder);
+
+        // send raw trans
+        console.log("wallet.address=>",wallet.address);
+        let ret = await sendRawTransaction(client,wallet.address,rawTrans);
+        console.log("ret of sendRawTransaction ==>",ret);
+
+        await sleep(10000);
+        // for(let msgHash of dataNeedSign.msgHashs){
+        //     let ret1 = await getTranResultByMsgHash(client,scAddresses.bridgeAddress,msgHash);
+        //     console.log(ret1);
+        // }
+
+        let ret1 = await getTranResultByMsgHash(client,ret.scAddr,ret.msgBodyCellHash, ret.externalInMessageHash);
+        console.log("*******************TranResult=>",ret1);
+
+    },500000);
+
+});

package/sign/rawTrans.ts

@@ -0,0 +1,122 @@
+import {bigIntReplacer} from "../utils/utils";
+
+import {configTestnet,configMainnet} from "../config/config-ex";
+import {
+    Address,
+    beginCell,
+    Builder,
+    Cell,
+    MessageRelaxed,
+    storeMessage,
+    Message,
+    storeMessageRelaxed,
+    external
+} from "@ton/core";
+import {Maybe} from "@ton/ton/dist/utils/maybe";
+import {sign} from "@ton/crypto";
+import {getClient, TonClientConfig} from "../client/client";
+import {internal} from "@ton/core";
+import {StateInit} from "@ton/core";
+import {TonClient} from "@ton/ton";
+
+export async function buildInternalMessage(from:Address,src: {
+    to: Address | string,
+    value: bigint | string,
+    bounce?: Maybe<boolean>,
+    init?: Maybe<StateInit>,
+    body?: Maybe<Cell | string>
+}){
+    let msgRelaxed = await internal(src);
+    msgRelaxed.info.src = from;
+    return msgRelaxed as unknown as Message;
+}
+
+export async function buildExternalMessage(src: {
+    to: Address | string,
+    init?: Maybe<StateInit>,
+    body?: Maybe<Cell>
+}){
+    return await external(src);
+}
+
+export async function buildSignData(args: {
+    seqno: number;
+    sendMode: number;
+    walletId: number;
+    messages: Message[];
+    timeout?: Maybe<number>;
+}){
+    // Check number of messages
+    if (args.messages.length > 4) {
+        throw Error("Maximum number of messages in a single transfer is 4");
+    }
+    let signingMessage = beginCell()
+        .storeUint(args.walletId, 32);
+    if (args.seqno === 0) {
+        for (let i = 0; i < 32; i++) {
+            signingMessage.storeBit(1);
+        }
+    }
+    else {
+        signingMessage.storeUint(args.timeout || Math.floor(Date.now() / 1e3) + 60, 32); // Default timeout: 60 seconds
+    }
+    signingMessage.storeUint(args.seqno, 32);
+    signingMessage.storeUint(0, 8); // Simple order
+    for (let m of args.messages) {
+        signingMessage.storeUint(args.sendMode, 8);
+        //signingMessage.storeRef(beginCell().store(storeMessageRelaxed(m)));
+        signingMessage.storeRef(beginCell().store(storeMessage(m)));
+    }
+    return {
+        rawData: signingMessage.endCell(),
+        hash:signingMessage.endCell().hash(),
+        rawDataBuilder:signingMessage,
+        msgHashs:await getMsgHash(args.messages),
+    }
+}
+
+export async function signData(hash:Buffer,secretKey:Buffer) {
+    return sign(hash,secretKey)}
+
+export async function buildRawTransaction(signature:Buffer, rawDataBuilder:Builder){
+    return beginCell()
+        .storeBuffer(signature)
+        .storeBuilder(rawDataBuilder)
+        .endCell();
+}
+
+/*
+external_message = {
+				to: <wallet_sc_address>,
+                init?: neededInit,
+                body: rawTransactionCell
+}
+ */
+export async function sendRawTransaction(client:TonClient, senderAddress:Address,rawTrans:Cell){
+    // let client = await getClient();
+    let provider =  client.provider(senderAddress)
+    await provider.external(rawTrans)
+
+
+    let externalInMessage = await buildExternalMessage({
+        to:senderAddress,
+        body:rawTrans,
+    })
+    return {
+        scAddr:senderAddress,
+        msgBodyCellHash:rawTrans.hash().toString('hex'),
+        externalInMessageHash:beginCell().store(storeMessage(externalInMessage)).endCell().hash().toString('hex'),
+    }
+}
+
+
+
+
+export function getMsgHash(msgs:Message[]){
+    let ret = [];
+    for(let m of msgs){
+        console.log("==========msg=>",JSON.stringify(m,bigIntReplacer));
+        ret.push(beginCell().store(storeMessage(m)).endCell().hash().toString('hex'));
+    }
+    return ret;
+}

package/sign/tools-secp256k1.js

@@ -0,0 +1,210 @@
+const crypto = require('crypto');
+const BigInteger = require('bigi');
+const ecurve = require('ecurve');
+const Web3EthAbi = require('web3-eth-abi');
+const ecparams = ecurve.getCurveByName('secp256k1');
+const Web3Utils = require("web3-utils");
+
+const logger = require('../utils/logger').logger
+const formatUtil = require('util');
+
+// buffer
+const r = new Buffer("e7e59bebdcee876e84d03832544f5a517e96a9e3f60cd8f564bece6719d5af52", 'hex');
+// buffer
+let R = baseScarMulti(r);
+
+// sk*G
+// return: buff
+function baseScarMulti(sk) {
+    let curvePt = ecparams.G.multiply(BigInteger.fromBuffer(sk));
+    let ret = curvePt.getEncoded(false);
+    let str = ret.toString('hex');
+    str = str.slice(2);
+    return Buffer.from(str, 'hex');
+}
+
+// hash
+// return:buffer
+function h(buff) {
+    let sha = crypto.createHash('sha256').update(buff).digest();
+    return sha;
+}
+
+// get s
+// s = r+sk*m
+// return: buffer
+function getSBuff(sk, m) {
+    let rBig = BigInteger.fromBuffer(r);
+    let skBig = BigInteger.fromBuffer(sk);
+    let mBig = BigInteger.fromBuffer(m);
+    let retBig;
+    retBig = rBig.add(skBig.multiply(mBig).mod(ecparams.n)).mod(ecparams.n);
+    return retBig.toBuffer(32);
+}
+
+// return: buffer
+function computeM1(M) {
+    let M1 = h(M);
+    return M1;
+}
+
+// compute m
+// M1=hash(M)
+// m=hash(M1||R)
+// M: buffer
+// R: buffer
+// return: buffer
+function computem(M1, R) {
+    let list = [];
+    list.push(M1);
+    list.push(R);
+    // hash(M1||R)
+    let m = Buffer.concat(list);
+    return h(m)
+}
+
+// input:pk Buffer
+// return buffer (1byte)
+function getPararity(pk) {
+    let b = BigInteger.fromBuffer(pk.slice(32))  // get pkY
+    if (b.testBit(0)) {     // odd
+        return Buffer.from("1c", 'hex');
+    } else {
+        return Buffer.from("1b", 'hex');
+    }
+}
+
+// pk: Buffer
+// return buffer (20bytes)
+function getAddrFromPk(pk) {
+    logger.info(formatUtil.format("len of pk", pk.length));
+    const publicKeyToAddress = require('ethereum-public-key-to-address')
+    return publicKeyToAddress(pk)
+}
+
+// pk: Buffer (64bytes)
+// return buffer (32bytes)
+function getXBytesFromPk(pk) {
+    return pk.slice(0, 32)
+}
+
+function getYBytesFromPk(pk) {
+    return pk.slice(32)
+}
+
+//  input Buffer
+//
+//  output Buffer
+//  hash(R_addr||gpk[0]+27-2||gpk.XBytes||message_hash)
+function computeE(RBuf, pararityBuf, gpkXBuf, MBuf) {
+    let list = [];
+    //list.push(RBuf);
+    logger.info(formatUtil.format("RBuf", bufferToHexString(RBuf)));
+    let RAddr = getAddrFromPk(Buffer.concat([Buffer.from("04", 'hex'), RBuf]));
+    logger.info(formatUtil.format("RAddr", RAddr))
+
+
+    let RAddrBytes = Buffer.from(RAddr.substring(2), 'hex');
+
+    list.push(RAddrBytes);
+    logger.info(formatUtil.format("R_addr", bufferToHexString(RAddrBytes)))
+
+    list.push(pararityBuf);
+    logger.info(formatUtil.format("pararityBuf", bufferToHexString(pararityBuf)));
+
+    list.push(gpkXBuf);
+    logger.info(formatUtil.format("gpkXBuf", bufferToHexString(gpkXBuf)));
+
+    list.push(MBuf);
+    logger.info(formatUtil.format("MBuf", bufferToHexString(MBuf)));
+
+    let eBuffer = Buffer.concat(list);
+    logger.info(formatUtil.format("eBuf before hash", bufferToHexString(eBuffer)));
+    return (Web3Utils.keccak256(eBuffer))
+}
+
+
+//typesArray:['uint256','string']
+//parameters: ['2345675643', 'Hello!%']
+//return : buff
+function computeM(typesArray, parameters) {
+    let mStrHex = Web3EthAbi.encodeParameters(typesArray, parameters);
+    return new Buffer(mStrHex.substring(2), 'hex');
+}
+
+// return : hexString
+function getR() {
+    return "0x" + R.toString('hex');
+}
+
+// return: hexString
+function bufferToHexString(buff) {
+    return "0x" + buff.toString('hex');
+}
+
+// sk: buff
+// return: hexString
+function getPKBySk(sk) {
+    return bufferToHexString(baseScarMulti(sk));
+}
+
+//typesArray:['uint256','string']
+//parameters: ['2345675643', 'Hello!%']
+//return :hexString
+function getS(sk, typesArray, parameters) {
+    let MBuff = computeM(typesArray, parameters);
+    let M1Buff = computeM1(MBuff);
+    let mBuff = computem(M1Buff, R);
+    let sBuff = getSBuff(sk, mBuff);
+    return bufferToHexString(sBuff);
+}
+
+//typesArray:['uint256','string']
+//parameters: ['2345675643', 'Hello!%']
+//return :hexString
+function getSecSchnorrS(sk, typesArray, parameters) {
+    let MBuff = computeM(typesArray, parameters);
+    let M1Buff = computeM1(MBuff);
+    let pk = getPKBySk(sk);
+    let pkBuf = Buffer.from(pk.substring(2), 'hex');
+    let eBuffHexStr = computeE(R, getPararity(pkBuf), getXBytesFromPk(pkBuf), M1Buff);
+    logger.info(formatUtil.format("eBuf after hash", eBuffHexStr));
+    let sBuff = getSBuff(sk, Buffer.from(eBuffHexStr.substring(2), 'hex'));
+    return {
+        s: bufferToHexString(sBuff),
+        e: (eBuffHexStr),
+        p: bufferToHexString(getPararity(pkBuf)),
+        pkX: bufferToHexString(getXBytesFromPk(pkBuf)),
+        pkY: bufferToHexString(getYBytesFromPk(pkBuf)),
+        msgHash: bufferToHexString(M1Buff),
+    }
+}
+// msgHash: buffer
+function getSecSchnorrSByMsgHash(sk, msgHash) {
+    // let MBuff = computeM(typesArray, parameters);
+    // let M1Buff = computeM1(MBuff);
+    console.log("getSecSchnorrSByMsgHash sk=>",sk);
+    let pk = getPKBySk(sk);
+    let pkBuf = Buffer.from(pk.substring(2), 'hex');
+    let eBuffHexStr = computeE(R, getPararity(pkBuf), getXBytesFromPk(pkBuf), msgHash);
+    logger.info(formatUtil.format("eBuf after hash", eBuffHexStr));
+    let sBuff = getSBuff(sk, Buffer.from(eBuffHexStr.substring(2), 'hex'));
+    return {
+        s: bufferToHexString(sBuff),
+        e: eBuffHexStr,
+        p: bufferToHexString(getPararity(pkBuf)),
+        pkX: bufferToHexString(getXBytesFromPk(pkBuf)),
+        pkY: bufferToHexString(getYBytesFromPk(pkBuf)),
+        msgHash: bufferToHexString(msgHash),
+    }
+}
+
+module.exports = {
+    getS: getS,
+    getPKBySk: getPKBySk,
+    getR: getR,
+    computeE: computeE,
+    getPararity: getPararity,
+    getSecSchnorrS: getSecSchnorrS,
+    getSecSchnorrSByMsgHash:getSecSchnorrSByMsgHash,
+};