improve gitignore and seafile-ignore

.gitignore

@@ -0,0 +1,109 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+# how to include another gitignore? 
+#   https://stackoverflow.com/questions/7005142/can-i-include-other-gitignore-file-in-a-gitignore-file-like-include-in-c-li
+#   https://github.com/github/gitignore
+#   https://github.com/SlideWave/gitignore-include?tab=readme-ov-file#examples
+#   https://gitignore.io
+
+### .gitignore.global.txt ###
+
+# Self defined pattern to ignore
+?*.gitignore
+?*.gitignore/
+?*.gitignore.*
+?*.gitignore.*/
+*.gitomit
+*.gitomit/
+*.gitomit.*
+*.gitomit.*/
+# 保留
+!.gitignore
+!.gitignore.*
+!.gitkeep
+
+# 通用
+.svn/
+.deploy_git/
+.idea/
+.sass-cache/
+.wrangler
+/test/unit/coverage/
+/test/e2e/reports/
+node_modules/
+*.aab
+*.apk
+*.ipa
+*.min.js
+*.min.css
+*.min.html
+*.iml
+*.njsproj
+*.ntvs*
+*.sw*
+*.sln
+*.suo
+.gitattributes
+.umi
+.umi-production
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+yarn.lock
+selenium-debug.log
+Thumbs.db
+thumbs.db
+_desktop.ini
+
+# vue-cli 项目
+/dist/
+
+# 来自 vue-cli 创建项目的 .gitignore
+.project
+
+# hexo
+/public/
+
+# Hardhat
+/artifacts/
+/cache/
+
+# seafile 临时文件
+._*
+
+.$*
+
+# office 暂存文件
+~$*
+
+# 用户shell配置脚本
+.bashrc_custom
+
+# 苹果系统临时文件
+.DS_Store
+
+# 安卓缓存文件夹
+.thumbnails
+
+# local env files
+.env.local
+.env.*.local
+
+# hexo
+/db.json
+
+# wo
+# 服务端
+/_archive/*
+/_datastore/*
+/_filestore/*
+/_logstore/*
+/_webroot/*
+/_ssl/*
+# uniapp 客户端
+/unpackage/*
+!/unpackage/res/
+package-lock.json
+pages4loader.json5
+
+### .gitignore.local.txt ###
+

btc.js

@@ -3,62 +3,81 @@
 const axios = require('axios')
 const HDNode = require('./utils/hdnode')
 const bitcoinjs = require('bitcoinjs-lib')
-const Ticrypto = require('tic.crypto')
+const ticc = require('tic-crypto')
 const BTC_NODE = require('./netConfig').BTC_NODE
 const BTC_NODE2 = require('./netConfig').BTC_NODE2
 const BTC_TXFEE = 30
 
 class BTC {
   constructor (privateKey) {
-        if(!Ticrypto.isSeckey(privateKey)) throw new Error('Invalid PrivateKey')
+    if (!ticc.is_prikey({ prikey: privateKey }))
-        var publicKey = Ticrypto.seckey2pubkey(privateKey)
+      throw new Error('Invalid PrivateKey')
+    var publicKey = ticc.prikey_to_pubkey(privateKey)
     Object.defineProperties(this, {
-            "privateKey" : {
+      privateKey: {
         enumerable: true,
         writable: false,
         value: privateKey
       },
-            "publicKey": {
+      publicKey: {
         enumerable: true,
         writable: false,
-                value : Ticrypto.seckey2pubkey(privateKey,{coin:"BTC"})
+        value: ticc.prikey_to_pubkey({ prikey: privateKey, coin: 'BTC' })
       },
-            "address" : {
+      address: {
         enumerable: true,
         writable: false,
-                value : Ticrypto.pubkey2address(publicKey,{coin:"BTC"}) 
+        value: ticc.pubkey_to_address({ pubkey: publicKey, coin: 'BTC' })
       },
-            "url" : {
+      url: {
         enumerable: true,
-                get: function() { return this._url },
+        get: function () {
+          return this._url
+        },
         set: function (url) {
-                    if (typeof(url) !== 'string') { throw new Error('invalid url') }
+          if (typeof url !== 'string') {
+            throw new Error('invalid url')
+          }
           this._url = url
         }
       },
-            "defaultGas":{
+      defaultGas: {
         enumerable: true,
-                get: function() { return this._defaultGasFee },
+        get: function () {
+          return this._defaultGasFee
+        },
         set: function (value) {
-                    if (typeof(value) !== 'number') { throw new Error('invalid defaultGasFee') }
+          if (typeof value !== 'number') {
+            throw new Error('invalid defaultGasFee')
+          }
           this._defaultGasFee = value
         }
       }
     })
     this._url = BTC_NODE
     this._defaultGasFee = BTC_TXFEE
-
   }
   static generateNewAccount () {
-        var mnemonic = Ticrypto.randomSecword()
+    var mnemonic = ticc.randomize_secword()
-        return Object.assign(new BTC(Ticrypto.secword2keypair(mnemonic, {coin:"BTC"}).seckey),{mnemonic : mnemonic})
+    return Object.assign(
+      new BTC(
+        ticc.secword_to_keypair({ secword: mnemonic, coin: 'BTC' }).prikey
+      ),
+      { mnemonic: mnemonic }
+    )
   }
   static fromMnemonic (mnemonic) {
     HDNode.isValidMnemonic(mnemonic)
-        return Object.assign(new BTC(Ticrypto.secword2keypair(mnemonic, {coin:"BTC"}).seckey),{mnemonic:mnemonic})
+    return Object.assign(
+      new BTC(
+        ticc.secword_to_keypair({ secword: mnemonic, coin: 'BTC' }).prikey
+      ),
+      { mnemonic: mnemonic }
+    )
   }
   static async getBalance (address) {
-        return (await axios.get(`${BTC_NODE}/addrs/${address}/balance`)).data.balance
+    return (await axios.get(`${BTC_NODE}/addrs/${address}/balance`)).data
+      .balance
   }
   static async getActions (address) {
     return (await axios.get(`${BTC_NODE}/addrs/${address}`)).data.txrefs
@@ -66,37 +85,42 @@ class BTC {
   static async getUTXO (address) {
     // console.log(`${BTC_NODE2}/unspent?active=${address}`,`${BTC_NODE2}/unspent?active=${address}`)
     try {
-            return (await axios.get(`${BTC_NODE2}/unspent?active=${address}`)).data.unspent_outputs
+      return (await axios.get(`${BTC_NODE2}/unspent?active=${address}`)).data
+        .unspent_outputs
     } catch (error) {
       return null
     }
   }
   static encrypt (data, key) {
     if (!data || !key) throw new Error('Required Params Missing')
-        return Ticrypto.encrypt(data,key)
+    return ticc.encrypt_easy({ data, key })
   }
   static decrypt (data, key) {
-        return Ticrypto.decrypt(data, key, {format:"json"})  //return null for wrong key
+    return ticc.decrypt_easy(data, key, { format: 'json' }) //return null for wrong key
   }
   static isValidAddress (address) {
     return address.length == 34 && address[0] == '1'
   }
   async sendTransaction (toAddress, amount, option = { gasFee: BTC_TXFEE }) {
-        let set = bitcoinjs.ECPair.fromPrivateKey(Buffer.from(this.privateKey,'hex'))//导入私钥用于签名
+    let set = bitcoinjs.ECPair.fromPrivateKey(
+      Buffer.from(this.privateKey, 'hex')
+    ) //导入私钥用于签名
     let txb = new bitcoinjs.TransactionBuilder() //初始化交易对象
     let tx = await BTC.getUTXO('1DEP8i3QJCsomS4BSMY2RpU1upv62aGvhD')
     if (!tx) return null
     var tot = 0 //用于记录UTXO总量
     amount += 1e4 //消费金额是转出金额加上10000的矿工费
     txb.setVersion(1) //设置交易版本号
-        for(var i=0;i<tx.length;i++){   //将UTXO的相关信息依次填入交易体中
+    for (var i = 0; i < tx.length; i++) {
+      //将UTXO的相关信息依次填入交易体中
       txb.addInput(tx[i].tx_hash_big_endian, tx[i].tx_output_n)
       tot += tx[i].value
     }
 
     txb.addOutput(toAddress, amount - 1e4) //填入转出目标地址和对应的金额
     txb.addOutput(this.address, tot - amount) //填入找零地址，也就是原地址，并填入把找零金额
-        for(var i=0;i<tx.length;i++){//对交易体中的UTXO依次签名
+    for (var i = 0; i < tx.length; i++) {
+      //对交易体中的UTXO依次签名
       txb.sign(i, set)
     }
     // let txBody = txb.buildIncomplete().toHex()
@@ -107,7 +131,6 @@ class BTC {
     } catch (error) {
       return null
     }
-
   }
   // async sendTransaction(toAddress, amount, option = {gasFee : BTC_TXFEE}){
   //     var privateKey = bitcore.PrivateKey(this.privateKey)

eth.js

@@ -2,7 +2,7 @@
 const eth = require('etherscan-api').init('E3ZFFAEMNN33KX4HHVUZ4KF8XY1FXMR4BI')
 const secretStorage = require('./utils/secret-storage')
 const SigningKey = require('./utils/signing-key.js')
-const Ticrypto = require('tic.crypto')
+const ticc = require('tic-crypto')
 const HDNode = require('./utils/hdnode')
 const utils = require('./util.js')
 const axios = require('axios')
@@ -12,53 +12,64 @@ require('setimmediate')
 const GAS_UNIT_WEI = 1e18 //1wei
 const GAS_UNIT_GWEI = 1e9 //1gwei = 1e9 wei
 const GAS_Fee = 0.000021
-const GAS_Fee_ERC20 = 0.000060
+const GAS_Fee_ERC20 = 0.00006
 const GAS_LIMIT = 21000
 const GAS_LIMIT_ERC20 = 6e4
 const defaultPath = "m/44'/60'/0'/0/0"
 const ETH_NODE = require('./netConfig').ETH_NODE
 
 const transactionFields = [
-    {name: 'nonce',    maxLength: 32, },
+  { name: 'nonce', maxLength: 32 },
-    {name: 'gasPrice', maxLength: 32, },
+  { name: 'gasPrice', maxLength: 32 },
-    {name: 'gasLimit', maxLength: 32, },
+  { name: 'gasLimit', maxLength: 32 },
-    {name: 'to',          length: 20, },
+  { name: 'to', length: 20 },
-    {name: 'value',    maxLength: 32, },
+  { name: 'value', maxLength: 32 },
-    {name: 'data'},
+  { name: 'data' }
 ]
 
 class ETH {
   constructor (privateKey) {
-        if(privateKey.length == 64 && !(privateKey.split('x')[1] && privateKey.split('x')[0] === '0'))
+    if (
+      privateKey.length == 64 &&
+      !(privateKey.split('x')[1] && privateKey.split('x')[0] === '0')
+    )
       privateKey = '0x' + privateKey
     var signingKey = privateKey
     if (!(privateKey instanceof SigningKey)) {
       signingKey = new SigningKey(privateKey)
     }
     Object.defineProperties(this, {
-            'privateKey' : {
+      privateKey: {
         enumerable: true,
         writable: false,
         value: signingKey.privateKey
       },
-            'address' : {
+      address: {
         enumerable: true,
         writable: false,
-                value : signingKey.address,
+        value: signingKey.address
       },
-            'url' : {
+      url: {
         enumerable: true,
-                get: function() { return this._url },
+        get: function () {
+          return this._url
+        },
         set: function (url) {
-                    if (typeof(url) !== 'string') { throw new Error('invalid url') }
+          if (typeof url !== 'string') {
+            throw new Error('invalid url')
+          }
           this._url = url
+        }
       },
-            },      
+      defaultGasFee: {
-            'defaultGasFee' : { 
         enumerable: true,
-                get: function() { return this._defaultGasFee },
+        get: function () {
+          return this._defaultGasFee
+        },
         set: function (value) {
-                    if (typeof(value) !== 'number') { throw new Error('invalid defaultGasFee') }
+          if (typeof value !== 'number') {
+            throw new Error('invalid defaultGasFee')
+          }
           this._defaultGasFee = value
         }
       }
@@ -68,8 +79,11 @@ class ETH {
   }
   static generateNewAccount (option = { path: defaultPath }) {
     //major path as default path >/0'/0/0
-        var mnemonic =  Ticrypto.randomSecword()
+    var mnemonic = ticc.randomize_secword()
-        return Object.assign(ETH.fromMnemonic(mnemonic, option),{mnemonic,mnemonic})
+    return Object.assign(ETH.fromMnemonic(mnemonic, option), {
+      mnemonic,
+      mnemonic
+    })
   }
   static fromMnemonic (mnemonic, option = { path: defaultPath }) {
     HDNode.isValidMnemonic(mnemonic) //check valid mnemonic,will throw Error if not valid
@@ -77,27 +91,32 @@ class ETH {
     return new ETH(HDNode.fromSeed(seed).derivePath(option.path).privateKey)
   }
   static async getBalance (address) {
-        if(!address){ throw new Error('Address is required') }
+    if (!address) {
-        let res = (await axios.post(ETH_NODE,{
+      throw new Error('Address is required')
-            "jsonrpc":"2.0","method":"eth_getBalance","params":[address, "latest"],"id":1
+    }
-        })).data
+    let res = (
-        if(res)
+      await axios.post(ETH_NODE, {
-        return parseInt(res.result)/1e18    //1000000000000000000
+        jsonrpc: '2.0',
+        method: 'eth_getBalance',
+        params: [address, 'latest'],
+        id: 1
+      })
+    ).data
+    if (res) return parseInt(res.result) / 1e18
+    //1000000000000000000
     else return null
   }
   static async getActions (address) {
     let tx = await eth.account.txlist(address, 0, 'latast')
-        if(tx && tx.message === 'OK')
+    if (tx && tx.message === 'OK') return tx.result
-            return tx.result
     else return []
   }
   static fromEncryptedWallet (json, password, progressCallback) {
-        if (progressCallback && typeof(progressCallback) !== 'function') {
+    if (progressCallback && typeof progressCallback !== 'function') {
       throw new Error('invalid callback')
     }
 
     return new Promise(function (resolve, reject) {
-    
       if (secretStorage.isCrowdsaleWallet(json)) {
         try {
           var privateKey = secretStorage.decryptCrowdsale(json, password)
@@ -105,10 +124,11 @@ class ETH {
         } catch (error) {
           reject(error)
         }
-    
       } else if (secretStorage.isValidWallet(json)) {
-    
+        secretStorage
-                secretStorage.decrypt(json, password, progressCallback).then(function(signingKey) {
+          .decrypt(json, password, progressCallback)
+          .then(
+            function (signingKey) {
               var wallet = new ETH(signingKey)
               if (signingKey.mnemonic && signingKey.path) {
                 utils.defineProperty(wallet, 'mnemonic', signingKey.mnemonic)
@@ -116,10 +136,14 @@ class ETH {
               }
               resolve(wallet)
               return null
-                }, function(error) {
+            },
+            function (error) {
               reject(error)
-                }).catch(function(error) { reject(error) })
+            }
-    
+          )
+          .catch(function (error) {
+            reject(error)
+          })
       } else {
         reject('invalid wallet JSON')
       }
@@ -128,7 +152,9 @@ class ETH {
   static parseTransaction (rawTransaction) {
     rawTransaction = utils.hexlify(rawTransaction, 'rawTransaction')
     var signedTransaction = utils.RLP.decode(rawTransaction)
-        if (signedTransaction.length !== 9) { throw new Error('invalid transaction') }
+    if (signedTransaction.length !== 9) {
+      throw new Error('invalid transaction')
+    }
 
     var raw = []
 
@@ -146,8 +172,10 @@ class ETH {
       }
     }
 
-        ['gasPrice', 'gasLimit', 'nonce', 'value'].forEach(function(name) {
+    ;['gasPrice', 'gasLimit', 'nonce', 'value'].forEach(function (name) {
-            if (!transaction[name]) { return }
+      if (!transaction[name]) {
+        return
+      }
       if (transaction[name].length === 0) {
         transaction[name] = utils.bigNumberify(0)
       } else {
@@ -165,13 +193,21 @@ class ETH {
     var r = utils.arrayify(signedTransaction[7])
     var s = utils.arrayify(signedTransaction[8])
 
-        if (v.length >= 1 && r.length >= 1 && r.length <= 32 && s.length >= 1 && s.length <= 32) {
+    if (
+      v.length >= 1 &&
+      r.length >= 1 &&
+      r.length <= 32 &&
+      s.length >= 1 &&
+      s.length <= 32
+    ) {
       transaction.v = utils.bigNumberify(v).toNumber()
       transaction.r = signedTransaction[7]
       transaction.s = signedTransaction[8]
 
       var chainId = (transaction.v - 35) / 2
-            if (chainId < 0) { chainId = 0 }
+      if (chainId < 0) {
+        chainId = 0
+      }
       chainId = parseInt(chainId)
 
       transaction.chainId = chainId
@@ -193,25 +229,29 @@ class ETH {
       }
     }
 
-    
     return transaction
   }
   static encrypt (data, key) {
     if (!data || !key) throw new Error('Required Params Missing')
-        return Ticrypto.encrypt(data,key)
+    return ticc.encrypt_easy({ data, key })
   }
   static decrypt (data, key) {
-        return Ticrypto.decrypt(data, key, {format:"json"})  //return null for wrong key
+    return ticc.decrypt_easy(data, key, { format: 'json' }) //return null for wrong key
   }
   static async estimateGasPrice () {
     try {
-            return parseInt((await axios.post(ETH_NODE, {
+      return (
-                "method": "eth_gasPrice",
+        parseInt(
-                "id": "6842",
+          (
-                "jsonrpc": "2.0"
+            await axios.post(ETH_NODE, {
-            })).data.result)/1e9
+              method: 'eth_gasPrice',
-        }
+              id: '6842',
-        catch(err){
+              jsonrpc: '2.0'
+            })
+          ).data.result
+        ) / 1e9
+      )
+    } catch (err) {
       return 1
     }
   }
@@ -228,24 +268,41 @@ class ETH {
     return ETH.getActions(this.address)
   }
   async getTransactionCount () {
-        if(!this._url){ throw new Error('Base url required') }
+    if (!this._url) {
+      throw new Error('Base url required')
+    }
     var self = this
-        return (await axios.post(this._url,{
+    return (
-            "jsonrpc":"2.0","method":"eth_getTransactionCount","params":[self.address, "latest"],"id":1
+      (
-        })).data.result||null
+        await axios.post(this._url, {
+          jsonrpc: '2.0',
+          method: 'eth_getTransactionCount',
+          params: [self.address, 'latest'],
+          id: 1
+        })
+      ).data.result || null
+    )
   }
   signTransaction (transaction) {
     var chainId = transaction.chainId
-        if (chainId == null && this.provider) { chainId = this.provider.chainId }
+    if (chainId == null && this.provider) {
-        if (!chainId) { chainId = 0 }
+      chainId = this.provider.chainId
+    }
+    if (!chainId) {
+      chainId = 0
+    }
 
     var raw = []
     transactionFields.forEach(function (fieldInfo) {
-            var value = transaction[fieldInfo.name] || ([])
+      var value = transaction[fieldInfo.name] || []
       value = utils.arrayify(utils.hexlify(value), fieldInfo.name)
 
       // Fixed-width field
-            if (fieldInfo.length && value.length !== fieldInfo.length && value.length > 0) {
+      if (
+        fieldInfo.length &&
+        value.length !== fieldInfo.length &&
+        value.length > 0
+      ) {
         var error = new Error('invalid ' + fieldInfo.name)
         error.reason = 'wrong length'
         error.value = value
@@ -303,9 +360,8 @@ class ETH {
     if (!option.gasPrice || !option.gasLimit) {
       //Normal Mode:use customized gasFee( ether ) to caculate gasPrice( wei ), gasLimit use default value
       gasLimit = GAS_LIMIT
-            gasPrice = String(option.gasFee * GAS_UNIT_WEI / gasLimit)
+      gasPrice = String((option.gasFee * GAS_UNIT_WEI) / gasLimit)
-        }
+    } else {
-        else{
       //Advance Mode:specified the gasLimit and gasPrice( gwei )
       gasLimit = option.gasLimit
       gasPrice = String(GAS_UNIT_GWEI * option.gasPrice)
@@ -316,21 +372,21 @@ class ETH {
       gasPrice: utils.bigNumberify(gasPrice),
       to: toAddress,
 
-            value: utils.parseEther(String(amount)),
+      value: utils.parseEther(String(amount))
     }
     try {
       let signedTransaction = this.signTransaction(transaction)
-            let ethTxRes = (await axios.post(ETH_NODE,{
+      let ethTxRes = (
-                "jsonrpc":"2.0",
+        await axios.post(ETH_NODE, {
-                "method":"eth_sendRawTransaction",
+          jsonrpc: '2.0',
-                "params":[signedTransaction.toString('hex')],
+          method: 'eth_sendRawTransaction',
-                "id":6842
+          params: [signedTransaction.toString('hex')],
-            })).data
+          id: 6842
-            if(ethTxRes && ethTxRes.result)
+        })
-                return ethTxRes
+      ).data
+      if (ethTxRes && ethTxRes.result) return ethTxRes
       return null
-        }
+    } catch (err) {
-        catch(err){
       return null
     }
   }
@@ -351,25 +407,26 @@ class ERC20 extends ETH{
   }
   static async getDecimals (contractAddress) {
     if (!contractAddress) throw new Error('Missing params')
-        let queryAddress = '0x313ce567' + (contractAddress.split('x')[1]).padStart(64,'0')
+    let queryAddress =
-        let params = [{"to":contractAddress, "data":queryAddress},"latest"]
+      '0x313ce567' + contractAddress.split('x')[1].padStart(64, '0')
+    let params = [{ to: contractAddress, data: queryAddress }, 'latest']
     let queryData = {
-            "jsonrpc":"2.0",
+      jsonrpc: '2.0',
-            "method":"eth_call",
+      method: 'eth_call',
-            "params":params,
+      params: params,
-            "id":6842
+      id: 6842
     }
     return parseInt((await axios.post(ETH_NODE, queryData)).data.result)
   }
   static async getBalance (address, contractAddress) {
     if (!address || !contractAddress) throw new Error('Missing params')
-        let queryAddress = '0x70a08231' + (address.split('x')[1]).padStart(64,'0')
+    let queryAddress = '0x70a08231' + address.split('x')[1].padStart(64, '0')
-        let params = [{"to":contractAddress, "data":queryAddress},"latest"]
+    let params = [{ to: contractAddress, data: queryAddress }, 'latest']
     let queryData = {
-            "jsonrpc":"2.0",
+      jsonrpc: '2.0',
-            "method":"eth_call",
+      method: 'eth_call',
-            "params":params,
+      params: params,
-            "id":6842
+      id: 6842
     }
     // return parseInt(erc20res.result)/Number('10'.padEnd(ERC20Table[obj.name].decimals+1,'0'))
     let res = (await axios.post(ETH_NODE, queryData)).data.result
@@ -378,11 +435,9 @@ class ERC20 extends ETH{
   }
   static async getActions (address, contractAddress) {
     try {
-            let res = (await eth.account.tokentx(address,contractAddress))
+      let res = await eth.account.tokentx(address, contractAddress)
-            if(res && res.result)
+      if (res && res.result) return res.result
-                return res.result
+    } catch (err) {
-        }
-        catch(err){
       return []
     }
     return
@@ -402,10 +457,13 @@ class ERC20 extends ETH{
         value: decimals,
         writable: false
       })
-        else
+    else return 0 // any good idea?
-            return 0    // any good idea?
   }
-    async sendTransaction(toAddress, amount, option = {gasFee : GAS_Fee_ERC20}){
+  async sendTransaction (
+    toAddress,
+    amount,
+    option = { gasFee: GAS_Fee_ERC20 }
+  ) {
     /****************************************************************   
             1 Ether = 1e18 wei  
             1 Gwei = 1e9 wei   
@@ -413,20 +471,28 @@ class ERC20 extends ETH{
             minimum gaslimit for erc20transaction is 6e4
         ****************************************************************/
     var nonce = await this.getTransactionCount()
-        var gasPrice, gasLimit, decimals, contractAddress = this.contractAddress
+    var gasPrice,
+      gasLimit,
+      decimals,
+      contractAddress = this.contractAddress
     if (!nonce) nonce = '0x0'
     if (!option.gasPrice || !option.gasLimit) {
       //Normal Mode:use customized gasFee( ether ) to caculate gasPrice( wei ), gasLimit use default value
       gasLimit = GAS_LIMIT_ERC20
-            gasPrice = String(option.gasFee * GAS_UNIT_WEI / gasLimit)
+      gasPrice = String((option.gasFee * GAS_UNIT_WEI) / gasLimit)
-        }
+    } else {
-        else{
       //Advance Mode:specified the gasLimit and gasPrice( gwei )
       gasLimit = option.gasLimit
       gasPrice = String(GAS_UNIT_GWEI * option.gasPrice)
     }
     if (!option.decimals) decimals = await ERC20.getDecimals(contractAddress)
-        let txBody = '0x' + 'a9059cbb' + toAddress.split('x')[1].padStart(64,'0')+ Number(amount*Math.pow(10,decimals)).toString(16).padStart(64,'0')
+    let txBody =
+      '0x' +
+      'a9059cbb' +
+      toAddress.split('x')[1].padStart(64, '0') +
+      Number(amount * Math.pow(10, decimals))
+        .toString(16)
+        .padStart(64, '0')
     let transaction = {
       nonce: nonce,
       gasLimit: gasLimit,
@@ -437,25 +503,24 @@ class ERC20 extends ETH{
     }
     let signedTransaction = this.signTransaction(transaction)
     try {
-            let erc20TxRes = (await axios.post(ETH_NODE, {
+      let erc20TxRes = (
-                "jsonrpc":"2.0",
+        await axios.post(ETH_NODE, {
-                "method":"eth_sendRawTransaction",
+          jsonrpc: '2.0',
-                "params":[signedTransaction.toString('hex')],
+          method: 'eth_sendRawTransaction',
-                "id":6842
+          params: [signedTransaction.toString('hex')],
-            })).data
+          id: 6842
-            if(erc20TxRes && erc20TxRes.result)
+        })
-                return erc20TxRes.result
+      ).data
+      if (erc20TxRes && erc20TxRes.result) return erc20TxRes.result
       console.log(erc20TxRes)
       return null
-        }
+    } catch (err) {
-        catch(err){
       return null
     }
   }
-
 }
 
 module.exports = {
-    ETH, ERC20
+  ETH,
+  ERC20
 }
-

index.js

@@ -1,16 +1,16 @@
 'use strict'
 
-const TIC = require('./tic.js').TIC;
+const TIC = require('./tic.js').TIC
-const ETH = require('./eth.js').ETH;
+const ETH = require('./eth.js').ETH
-const ERC20 = require('./eth.js').ERC20;
+const ERC20 = require('./eth.js').ERC20
-const BTC = require('./btc.js').BTC;
+const BTC = require('./btc.js').BTC
-const Account = require('./Account').Account;
+const Account = require('./Account').Account
-const Crypto = require('tic.crypto');
+const Crypto = require('tic-crypto')
 module.exports = {
   TIC,
   ETH,
   BTC,
   ERC20,
   Account,
-    Crypto,
+  Crypto
 }

package.json

@@ -1,5 +1,5 @@
 {
-  "name": "tic.tool4chain",
+  "name": "tic-chaintool",
   "version": "1.2.1",
   "dependencies": {
     "aes-js": "^3.1.1",
@@ -10,16 +10,12 @@
     "js-sha3": "^0.8.0",
     "scrypt-js": "^2.0.3",
     "setimmediate": "^1.0.5",
-    "tic.action": "git+https://git.faronear.org/tic/tic.action#20190714_release_passtoken",
+    "tic.action": "git+https://git.faronear.org/npm/tic.action#20190714_release_passtoken",
-    "tic.crypto": "git+https://git.faronear.org/tic/tic.crypto#20190109_preview",
+    "tic-crypto": "git+https://git.faronear.org/npm/tic-crypto#20190109_preview",
-    "uuid": "^3.3.2"
+    "uuid": "^8.3.1"
   },
   "deprecated": false,
   "description": "blockchain tool for ticwallet",
-  "keywords": [
+  "keywords": ["tool", "blockchain", "tic"],
-    "tool",
-    "blockchain",
-    "tic"
-  ],
   "main": "index.js"
 }

seafile-ignore.txt

@@ -0,0 +1,68 @@
+# https://help.seafile.com/syncing_client/excluding_files/
+# 注释。通配符：* 匹配0到若干个字符，包括代表目录的/。? 匹配1个字符，包括/。
+# seafile-ignore.txt 只能控制在客户端需要忽略哪些文件。你依然可以在 seahub 的 web 界面创建这些被客户端忽略的文件。
+# 在这种情况下，
+# 这些文件会被同步到客户端，但是用户在客户端对这些文件的后续修改会被忽略，不会被同步回服务器。
+# 文件在服务器端的后续更改会被同步到客户端，如果客户端也同时修改了这些文件，系统会生成冲突文件。
+# seafile-ignore.txt 只能忽略还没有被同步的文件。对于已经被同步的文件，如果后来把它添加到 seafile-ignore.txt 中，系统只会忽略后续更改，已经上传的版本不会受影响。
+
+### seafile-ignore.global.txt ###
+
+# 自定义的后缀名，凡有 sfignore 后缀的都不进行同步
+*.sfignore
+*.sfignore/
+*.sfignore.*
+*.sfignore.*/
+*.sfomit
+*.sfomit.*
+*.sfomit/
+*.sfomit.*/
+
+.DS_Store
+*/.DS_Store
+
+.thumbnails
+*/.thumbnails
+
+Thumbs.db
+*/Thumbs.db
+thumbs.db
+*/thumbs.db
+
+_desktop.ini
+*/_desktop.ini
+
+._*
+*/._*
+
+.$*
+*/.$*
+
+~$*
+*/~$*
+
+node_modules/
+*/node_modules/
+package-lock.json
+
+pages4loader.json5
+
+.deploy_git/
+*/.deploy_git/
+
+# HBuilder 目录
+unpackage/
+*/unpackage/
+
+Icon
+OneDrive/Icon
+
+# wrangler project
+
+.dev.vars*
+*/.dev.vars*
+.wrangler/
+*/.wrangler/
+
+### seafile-ignore.local.txt ###
+

tic.js

@@ -1,27 +1,29 @@
 'use strict'
 const axios = require('axios')
-const ticCrypto = require('tic.crypto')
+const ticc = require('tic-crypto')
 const ticActionTransfer = require('tic.action').ActionTransfer
 
-const TIC_TXFEE = 10;
+const TIC_TXFEE = 10
 const TIC_NODE = require('./netConfig').TIC_NODE
 
 class TIC {
-    constructor(seckey,option={}){
+  constructor (prikey, option = {}) {
-        if(!seckey||!ticCrypto.isSeckey(seckey)) throw "ERROR:Invalid Seckey"
+    if (!prikey || !ticc.is_prikey({ prikey })) throw 'ERROR:Invalid Seckey'
     Object.defineProperties(this, {
-            'seckey' : {
+      prikey: {
-                value : seckey,
+        value: prikey,
         enumerable: true,
-                writable : false,
+        writable: false
       },
-            'pubkey' : {
+      pubkey: {
-                value : ticCrypto.seckey2pubkey(seckey), 
+        value: ticc.prikey_to_pubkey({ prikey }),
         enumerable: true,
-                writable : false,
+        writable: false
       },
-            'address' : {
+      address: {
-                value : ticCrypto.pubkey2address(ticCrypto.seckey2pubkey(seckey)),
+        value: ticc.pubkey_to_address({
+          pubkey: ticc.prikey_to_pubkey(prikey)
+        }),
         enumerable: true,
         writable: false
       }
@@ -31,68 +33,87 @@ class TIC {
       _defaultFee: option.fee || TIC_TXFEE //fee cannot be zero
     })
   }
-    get url(){return this._url}
+  get url () {
-    set url(newURL){this._url = newURL}
+    return this._url
-    get txfee(){return this._defaultFee}
+  }
-    set txfee(fee){this._defaultFee = fee}
+  set url (newURL) {
+    this._url = newURL
+  }
+  get txfee () {
+    return this._defaultFee
+  }
+  set txfee (fee) {
+    this._defaultFee = fee
+  }
 
   static generateNewAccount () {
-        var secword = ticCrypto.randomSecword()
+    var secword = ticc.randomize_secword()
-        return Object.assign(new TIC(ticCrypto.secword2keypair(secword).seckey),{secword:secword})
+    return Object.assign(new TIC(ticc.secword_to_keypair({ secword }).prikey), {
+      secword: secword
+    })
   }
   static fromMnemonic (secword) {
-        if(!secword||!ticCrypto.isSecword(secword)) throw "ERROR:Invalid Secword"
+    if (!secword || !ticc.is_secword(secword)) throw 'ERROR:Invalid Secword'
-        return new TIC(ticCrypto.secword2keypair(secword).seckey)
+    return new TIC(ticc.secword_to_keypair({ secword }).prikey)
   }
   static async getBalance (address) {
-        if(!address){ throw new Error('Address is required'); }
+    if (!address) {
-        return (await axios.post(TIC_NODE+'/Account/getBalance',{
+      throw new Error('Address is required')
-            "Account" : {
-                "address":address
     }
-        })).data
+    return (
+      await axios.post(TIC_NODE + '/Account/getBalance', {
+        Account: {
+          address: address
+        }
+      })
+    ).data
   }
   static async getActions (address) {
-        if(!address){ throw new Error('Address is required'); }
+    if (!address) {
-        return (await axios.post(TIC_NODE+'/Action/getActionList',{
+      throw new Error('Address is required')
-            "Action" : {
-                "actorAddress" : address,
-                "toAddress" : address
-            },
-            "config":{
-                "logic":"OR"
     }
-        })).data 
+    return (
+      await axios.post(TIC_NODE + '/Action/getActionList', {
+        Action: {
+          actorAddress: address,
+          toAddress: address
+        },
+        config: {
+          logic: 'OR'
+        }
+      })
+    ).data
   }
   static encrypt (data, key) {
     if (!data || !key) throw new Error('Required Params Missing')
-        return ticCrypto.encrypt(data,key)
+    return ticc.encrypt_easy({ data, key })
   }
   static decrypt (data, key) {
-        return ticCrypto.decrypt(data, key, {format:"json"})  //return null for wrong key
+    return ticc.decrypt_easy(data, key, { format: 'json' }) //return null for wrong key
   }
 
   static isValidAddress (address) {
-        return ticCrypto.isAddress(address)
+    return ticc.which_chain_address({ address })
   }
 
   async sendTransaction (toAddress, amount, option = { gasFee: TIC_TXFEE }) {
-        if(!toAddress||!amount){throw new Error("ERROR:RequiredParamsMissing")}  //amount cannot be zero
+    if (!toAddress || !amount) {
+      throw new Error('ERROR:RequiredParamsMissing')
+    } //amount cannot be zero
     let action = new ticActionTransfer({
       amount: parseInt(amount),
       toAddress: toAddress,
-            fee: option.gasFee,
+      fee: option.gasFee
     })
     //对交易数据签名,packMe 内的参数是交易发起人的keypair
     action.packMe({
-            seckey: this.seckey,
+      prikey: this.prikey,
-            pubkey: this.pubkey,
+      pubkey: this.pubkey
     })
     let data = {
       Action: action
     }
     try {
-
       let res = (await axios.post(this._url + '/Action/prepare', data)).data
       return res
     } catch (err) {
@@ -106,30 +127,31 @@ class TIC {
     return TIC.getActions(this.address)
   }
   getSerializedTx (option) {
-        if(!option.toAddress||!option.amount){throw new Error("ERROR:RequiredParamsMissing")}
+    if (!option.toAddress || !option.amount) {
+      throw new Error('ERROR:RequiredParamsMissing')
+    }
     let action = new ticActionTransfer({
       amount: parseInt(option.amount),
       toAddress: option.toAddress,
-            fee: option.fee||this._defaultFee,
+      fee: option.fee || this._defaultFee
     })
     //sign for txBody use function packMe, which needs actor's keypair as parameter
     action.packMe({
-          seckey: this.seckey,
+      prikey: this.prikey,
-          pubkey: this.pubkey,
+      pubkey: this.pubkey
     })
     return action
   }
-    //default key for sign&encrypt is account's seckey,other keys are optional.
+  //default key for sign&encrypt is account's prikey,other keys are optional.
-    sign(message,key = this.seckey){
+  sign (message, key = this.prikey) {
-        return ticCrypto.sign(message,key)
+    return ticc.sign_easy({ data: message, prikey: key })
   }
   verify (message, signature) {
-        return ticCrypto.sign(message,signature,this.seckey)
+    return ticc.sign_easy({ data: message, signature, prikey: this.prikey })
   }
   encrypt (key) {
     return TIC.encrypt(this, key)
   }
-    
 }
 
 module.exports = { TIC }

utils/solidity.js

@@ -1,97 +1,111 @@
-'use strict';
+'use strict'
 
-var bigNumberify = require('./bignumber').bigNumberify;
+var bigNumberify = require('./bignumber').bigNumberify
-var convert = require('./convert');
+var convert = require('./convert')
-var getAddress = require('./address').getAddress;
+var getAddress = require('./address').getAddress
-var utf8 = require('./utf8');
+var utf8 = require('./utf8')
 
-var hashKeccak256 = require('./keccak256');
+var hashKeccak256 = require('./keccak256')
-var hashSha256 = require('./sha2').sha256;
+var hashSha256 = require('./sha2').sha256
 
-var regexBytes = new RegExp("^bytes([0-9]+)$");
+var regexBytes = new RegExp('^bytes([0-9]+)$')
-var regexNumber = new RegExp("^(u?int)([0-9]*)$");
+var regexNumber = new RegExp('^(u?int)([0-9]*)$')
-var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
+var regexArray = new RegExp('^(.*)\\[([0-9]*)\\]$')
 
-var Zeros = '0000000000000000000000000000000000000000000000000000000000000000';
+var Zeros = '0000000000000000000000000000000000000000000000000000000000000000'
 
 function _pack (type, value, isArray) {
   switch (type) {
     case 'address':
-            if (isArray) { return convert.padZeros(value, 32); }
+      if (isArray) {
-            return convert.arrayify(value);
+        return convert.padZeros(value, 32)
+      }
+      return convert.arrayify(value)
     case 'string':
-            return utf8.toUtf8Bytes(value);
+      return utf8.toUtf8Bytes(value)
     case 'bytes':
-            return convert.arrayify(value);
+      return convert.arrayify(value)
     case 'bool':
-            value = (value ? '0x01': '0x00');
+      value = value ? '0x01' : '0x00'
-            if (isArray) { return convert.padZeros(value, 32); }
+      if (isArray) {
-            return convert.arrayify(value);
+        return convert.padZeros(value, 32)
+      }
+      return convert.arrayify(value)
   }
 
-    var match =  type.match(regexNumber);
+  var match = type.match(regexNumber)
   if (match) {
-        var signed = (match[1] === 'int')
+    var signed = match[1] === 'int'
-        var size = parseInt(match[2] || "256")
+    var size = parseInt(match[2] || '256')
-        if ((size % 8 != 0) || size === 0 || size > 256) {
+    if (size % 8 != 0 || size === 0 || size > 256) {
-            throw new Error('invalid number type - ' + type);
+      throw new Error('invalid number type - ' + type)
     }
 
-        if (isArray) { size = 256; }
+    if (isArray) {
-
+      size = 256
-        value = bigNumberify(value).toTwos(size);
-
-        return convert.padZeros(value, size / 8);
     }
 
-    match = type.match(regexBytes);
+    value = bigNumberify(value).toTwos(size)
+
+    return convert.padZeros(value, size / 8)
+  }
+
+  match = type.match(regexBytes)
   if (match) {
-        var size = match[1];
+    var size = match[1]
     if (size != parseInt(size) || size === 0 || size > 32) {
-            throw new Error('invalid number type - ' + type);
+      throw new Error('invalid number type - ' + type)
     }
-        size = parseInt(size);
+    size = parseInt(size)
-        if (convert.arrayify(value).byteLength !== size) { throw new Error('invalid value for ' + type); }
+    if (convert.arrayify(value).byteLength !== size) {
-        if (isArray) { return (value + Zeros).substring(0, 66); }
+      throw new Error('invalid value for ' + type)
-        return value;
+    }
+    if (isArray) {
+      return (value + Zeros).substring(0, 66)
+    }
+    return value
   }
 
-    match = type.match(regexArray);
+  match = type.match(regexArray)
   if (match) {
-        var baseType = match[1];
+    var valueType = match[1]
-        var count = parseInt(match[2] || value.length);
+    var count = parseInt(match[2] || value.length)
-        if (count != value.length) { throw new Error('invalid value for ' + type); }
+    if (count != value.length) {
-        var result = [];
+      throw new Error('invalid value for ' + type)
+    }
+    var result = []
     value.forEach(function (value) {
-            value = _pack(baseType, value, true);
+      value = _pack(valueType, value, true)
-            result.push(value);
+      result.push(value)
-        });
+    })
-        return convert.concat(result);
+    return convert.concat(result)
   }
 
-    throw new Error('unknown type - ' + type);
+  throw new Error('unknown type - ' + type)
 }
 
 function pack (types, values) {
-    if (types.length != values.length) { throw new Error('type/value count mismatch'); }
+  if (types.length != values.length) {
-    var tight = [];
+    throw new Error('type/value count mismatch')
+  }
+  var tight = []
   types.forEach(function (type, index) {
-        tight.push(_pack(type, values[index]));
+    tight.push(_pack(type, values[index]))
-    });
+  })
-    return convert.hexlify(convert.concat(tight));
+  return convert.hexlify(convert.concat(tight))
 }
 
 function keccak256 (types, values) {
-    return hashKeccak256(pack(types, values));
+  return hashKeccak256(pack(types, values))
 }
 
 function sha256 (types, values) {
-    return hashSha256(pack(types, values));
+  return hashSha256(pack(types, values))
 }
 
 module.exports = {
   pack: pack,
 
   keccak256: keccak256,
-    sha256: sha256,
+  sha256: sha256
 }