edge-currency-accountbased 0.7.72

package/lib/tezos/tezosEngine.js

@@ -0,0 +1,497 @@
+// 
+import { bns } from 'biggystring'
+import {
+
+
+
+
+
+  InsufficientFundsError,
+  NoAmountSpecifiedError
+} from 'edge-core-js/types'
+import { eztz } from 'eztz.js'
+
+import { CurrencyEngine } from '../common/engine.js'
+import {
+  asyncWaterfall,
+  cleanTxLogs,
+  getOtherParams,
+  makeMutex,
+  promiseAny
+} from '../common/utils.js'
+import { TezosPlugin } from '../tezos/tezosPlugin.js'
+import { currencyInfo } from './tezosInfo.js'
+import {
+
+
+
+
+  asXtzGetTransaction
+} from './tezosTypes.js'
+
+const ADDRESS_POLL_MILLISECONDS = 15000
+const BLOCKCHAIN_POLL_MILLISECONDS = 30000
+const TRANSACTION_POLL_MILLISECONDS = 5000
+
+const makeSpendMutex = makeMutex()
+
+const PRIMARY_CURRENCY = currencyInfo.currencyCode
+
+
+
+
+
+
+
+
+
+export class TezosEngine extends CurrencyEngine {
+  
+  
+
+  constructor(
+    currencyPlugin,
+    walletInfo,
+    opts,
+    fetchCors
+  ) {
+    super(currencyPlugin, walletInfo, opts)
+    this.tezosPlugin = currencyPlugin
+    this.fetchCors = fetchCors
+  }
+
+  async multicastServers(func, ...params) {
+    let out = { result: '', server: 'no server' }
+    let funcs
+    switch (func) {
+      // Functions that should waterfall from top to low priority servers
+      case 'getHead': {
+        // relevant nodes, disabling first node due to caching / polling issue
+        // need to re-enable once that nodes issue is fixed
+        const nonCachedNodes = this.tezosPlugin.tezosRpcNodes
+        funcs = nonCachedNodes.map(server => async () => {
+          const result = await this.io
+            .fetch(server + '/chains/main/blocks/head/header')
+            .then(function (response) {
+              return response.json()
+            })
+            .then(function (json) {
+              return json
+            })
+          return { server, result }
+        })
+        out = await asyncWaterfall(funcs)
+        break
+      }
+
+      case 'getBalance': {
+        const usableNodes = this.tezosPlugin.tezosRpcNodes
+        funcs = usableNodes.map(server => async () => {
+          eztz.node.setProvider(server)
+          const result = await eztz.rpc.getBalance(params[0])
+          return { server, result }
+        })
+        out = await asyncWaterfall(funcs)
+        break
+      }
+
+      case 'getNumberOfOperations':
+        funcs = this.tezosPlugin.tezosApiServers.map(server => async () => {
+          const result = await this.fetchCors(
+            `${server}/v1/accounts/${params[0]}`
+          )
+            .then(function (response) {
+              return response.json()
+            })
+            .then(function (json) {
+              return json.numTransactions
+            })
+          return { server, result }
+        })
+        out = await asyncWaterfall(funcs)
+        break
+
+      case 'getTransactions':
+        funcs = this.tezosPlugin.tezosApiServers.map(server => async () => {
+          const pagination = /tzkt/.test(server)
+            ? ''
+            : `&p='${params[1]}&number=50`
+          const result = await this.fetchCors(
+            `${server}/v1/accounts/${params[0]}/operations?type=transaction` +
+              pagination
+          ).then(function (response) {
+            return response.json()
+          })
+          return { server, result }
+        })
+        out = await asyncWaterfall(funcs)
+        break
+
+      case 'createTransaction':
+        funcs = this.tezosPlugin.tezosRpcNodes.map(server => async () => {
+          eztz.node.setProvider(server)
+          const result = await eztz.rpc
+            .transfer(
+              params[0],
+              params[1],
+              params[2],
+              params[3],
+              params[4],
+              null,
+              this.currencyInfo.defaultSettings.limit.gas,
+              this.currencyInfo.defaultSettings.limit.storage,
+              this.currencyInfo.defaultSettings.fee.reveal
+            )
+            .then(function (response) {
+              return response
+            })
+          return { server, result }
+        })
+        out = await asyncWaterfall(funcs)
+        break
+
+      // Functions that should multicast to all servers
+      case 'injectOperation': {
+        let preApplyError = ''
+        funcs = this.tezosPlugin.tezosRpcNodes.map(server => async () => {
+          eztz.node.setProvider(server)
+          const result = await eztz.rpc
+            .inject(params[0], params[1])
+            .catch((e) => {
+              this.log.error(
+                'Error when injection operation: ' + e.name + e.message
+              )
+              const errorMessage = this.formatError(e)
+              if (!preApplyError && errorMessage !== '') {
+                preApplyError = errorMessage
+              }
+              throw e
+            })
+          // Preapply passed -> Broadcast to all remaining nodes in the waterfall
+          this.multicastServers('silentInjection', server, params[1])
+          return { server, result }
+        })
+        out = await asyncWaterfall(funcs).catch((e) => {
+          this.log.error('Error from waterfall: ' + e.name + e.message)
+          if (preApplyError !== '') {
+            throw new Error(preApplyError)
+          } else {
+            throw e
+          }
+        })
+        break
+      }
+
+      case 'silentInjection': {
+        const index = this.tezosPlugin.tezosRpcNodes.indexOf(params[0])
+        const remainingRpcNodes = this.tezosPlugin.tezosRpcNodes.slice(
+          index + 1
+        )
+        out = await promiseAny(
+          remainingRpcNodes.map(async server => {
+            eztz.node.setProvider(server)
+            const result = await eztz.rpc.silentInject(params[1])
+            this.log.warn('Injected silently to: ' + server)
+            return { server, result }
+          })
+        )
+        break
+      }
+    }
+    this.log(
+      `XTZ multicastServers ${func} ${out.server} won with result ${out.result}`
+    )
+    return out.result
+  }
+
+  formatError(e) {
+    if (typeof e === 'string') {
+      return e
+    }
+    try {
+      if (
+        e.error &&
+        e.error === 'Operation Failed' &&
+        e.errors &&
+        e.errors[0].id
+      ) {
+        return 'Failed in preapply with an error code (' + e.errors[0].id + ')'
+      } else if (e[0] && e[0].kind && e[0].kind === 'branch' && e[0].id) {
+        return 'Failed in preapply with an error code (' + e[0].id + ')'
+      }
+    } catch (e) {}
+    return ''
+  }
+
+  processTezosTransaction(tx) {
+    const transaction = asXtzGetTransaction(tx)
+    const pkh = this.walletLocalData.publicKey
+    const ourReceiveAddresses = []
+    const currencyCode = PRIMARY_CURRENCY
+    const date = new Date(transaction.timestamp).getTime() / 1000
+    const blockHeight = transaction.level
+    let nativeAmount = transaction.amount.toString()
+    const networkFee = (
+      transaction.bakerFee + transaction.allocationFee
+    ).toString()
+    const failedOperation = transaction.status === 'failed'
+    if (pkh === transaction.target.address) {
+      ourReceiveAddresses.push(pkh)
+      if (transaction.sender.address === pkh) {
+        nativeAmount = '-' + networkFee
+      }
+    } else {
+      nativeAmount = '-' + bns.add(nativeAmount, networkFee)
+    }
+    const edgeTransaction = {
+      txid: tx.hash,
+      date,
+      currencyCode,
+      blockHeight,
+      nativeAmount,
+      networkFee,
+      ourReceiveAddresses,
+      signedTx: '',
+      otherParams: {}
+    }
+    if (!failedOperation) {
+      this.addTransaction(currencyCode, edgeTransaction)
+    }
+  }
+
+  async checkTransactionsInnerLoop() {
+    const pkh = this.walletLocalData.publicKey
+    if (!this.otherData.numberTransactions) {
+      this.otherData.numberTransactions = 0
+    }
+    const num = await this.multicastServers('getNumberOfOperations', pkh)
+    if (num !== this.otherData.numberTransactions) {
+      let txs = []
+      let page = 0
+      let transactions
+      this.tokenCheckTransactionsStatus.XTZ = 0.5
+      do {
+        transactions = await this.multicastServers(
+          'getTransactions',
+          pkh,
+          page++
+        )
+        txs = txs.concat(transactions)
+      } while (transactions.length > 0 && page < 10)
+      for (const tx of txs) {
+        this.processTezosTransaction(tx)
+      }
+      if (this.transactionsChangedArray.length > 0) {
+        this.currencyEngineCallbacks.onTransactionsChanged(
+          this.transactionsChangedArray
+        )
+        this.transactionsChangedArray = []
+      }
+      this.otherData.numberTransactions = num
+      this.walletLocalDataDirty = true
+    }
+    this.tokenCheckTransactionsStatus.XTZ = 1
+    this.updateOnAddressesChecked()
+  }
+
+  async checkUnconfirmedTransactionsFetch() {}
+
+  // Check all account balance and other relevant info
+  async checkAccountInnerLoop() {
+    this.tokenCheckBalanceStatus.XTZ = 0
+    const currencyCode = PRIMARY_CURRENCY
+    const pkh = this.walletLocalData.publicKey
+    if (
+      typeof this.walletLocalData.totalBalances[currencyCode] === 'undefined'
+    ) {
+      this.walletLocalData.totalBalances[currencyCode] = '0'
+    }
+    const balance = await this.multicastServers('getBalance', pkh)
+    if (this.walletLocalData.totalBalances[currencyCode] !== balance) {
+      this.walletLocalData.totalBalances[currencyCode] = balance
+      this.log.warn(`Updated ${currencyCode} balance ${balance}`)
+      this.currencyEngineCallbacks.onBalanceChanged(currencyCode, balance)
+    }
+    this.tokenCheckBalanceStatus.XTZ = 1
+  }
+
+  async checkBlockchainInnerLoop() {
+    const head = await this.multicastServers('getHead')
+    const blockHeight = head.level
+    if (this.walletLocalData.blockHeight !== blockHeight) {
+      this.walletLocalData.blockHeight = blockHeight
+      this.walletLocalDataDirty = true
+      this.currencyEngineCallbacks.onBlockHeightChanged(
+        this.walletLocalData.blockHeight
+      )
+    }
+  }
+
+  async clearBlockchainCache() {
+    await super.clearBlockchainCache()
+  }
+
+  async isBurn(op) {
+    if (op.kind === 'origination') {
+      return true
+    }
+    if (op.kind === 'transaction' && op.destination.slice(0, 2) === 'tz') {
+      const balance = await this.multicastServers('getBalance', op.destination)
+      if (balance === '0') {
+        return true
+      }
+    }
+    return false
+  }
+  // ****************************************************************************
+  // Public methods
+  // ****************************************************************************
+
+  async startEngine() {
+    this.engineOn = true
+    this.addToLoop('checkBlockchainInnerLoop', BLOCKCHAIN_POLL_MILLISECONDS)
+    this.addToLoop('checkAccountInnerLoop', ADDRESS_POLL_MILLISECONDS)
+    this.addToLoop('checkTransactionsInnerLoop', TRANSACTION_POLL_MILLISECONDS)
+    super.startEngine()
+  }
+
+  async resyncBlockchain() {
+    await this.killEngine()
+    await this.clearBlockchainCache()
+    await this.startEngine()
+  }
+
+  async makeSpend(edgeSpendInfoIn) {
+    return makeSpendMutex(() => this.makeSpendInner(edgeSpendInfoIn))
+  }
+
+  async makeSpendInner(
+    edgeSpendInfoIn
+  ) {
+    const { edgeSpendInfo, currencyCode, nativeBalance, denom } =
+      super.makeSpend(edgeSpendInfoIn)
+    if (edgeSpendInfo.spendTargets.length !== 1) {
+      throw new Error('Error: only one output allowed')
+    }
+    const publicAddress = edgeSpendInfo.spendTargets[0].publicAddress
+    let nativeAmount = '0'
+    if (typeof edgeSpendInfo.spendTargets[0].nativeAmount === 'string') {
+      nativeAmount = edgeSpendInfo.spendTargets[0].nativeAmount
+    } else {
+      throw new NoAmountSpecifiedError()
+    }
+    if (bns.eq(nativeAmount, '0')) {
+      throw new NoAmountSpecifiedError()
+    }
+    const keys = {
+      pk: this.walletInfo.keys.publicKeyEd,
+      pkh: this.walletInfo.keys.publicKey,
+      sk: false
+    }
+    let ops
+    let resendCounter = 0
+    let error
+    do {
+      try {
+        ops = await this.multicastServers(
+          'createTransaction',
+          keys.pkh,
+          keys,
+          publicAddress,
+          bns.div(nativeAmount, denom.multiplier, 6),
+          this.currencyInfo.defaultSettings.fee.transaction
+        )
+      } catch (e) {
+        error = e
+      }
+    } while (
+      (typeof ops === 'undefined' || ops.opOb.contents.length > 2) &&
+      resendCounter++ < 5
+    )
+    if (typeof ops === 'undefined') {
+      throw error
+    }
+    let networkFee = '0'
+    for (const operation of ops.opOb.contents) {
+      networkFee = bns.add(networkFee, operation.fee)
+      const burn = await this.isBurn(operation)
+      if (burn) {
+        networkFee = bns.add(
+          networkFee,
+          this.currencyInfo.defaultSettings.fee.burn
+        )
+      }
+    }
+    nativeAmount = bns.add(nativeAmount, networkFee)
+    if (bns.gt(nativeAmount, nativeBalance)) {
+      throw new InsufficientFundsError()
+    }
+    nativeAmount = '-' + nativeAmount
+
+    const edgeTransaction = {
+      txid: '',
+      date: 0,
+      currencyCode,
+      blockHeight: 0,
+      nativeAmount,
+      networkFee,
+      ourReceiveAddresses: [],
+      signedTx: '',
+      otherParams: {
+        idInternal: 0,
+        fromAddress: this.walletLocalData.publicKey,
+        toAddress: publicAddress,
+        fullOp: ops
+      }
+    }
+    return edgeTransaction
+  }
+
+  async signTx(edgeTransaction) {
+    const otherParams = getOtherParams(edgeTransaction)
+
+    if (edgeTransaction.signedTx === '') {
+      const sk = this.walletInfo.keys.privateKey
+      const signed = eztz.crypto.sign(
+        otherParams.fullOp.opbytes,
+        sk,
+        eztz.watermark.generic
+      )
+      otherParams.fullOp.opbytes = signed.sbytes
+      otherParams.fullOp.opOb.signature = signed.edsig
+      edgeTransaction.signedTx = signed.sbytes
+    }
+    this.log.warn(`signTx\n${cleanTxLogs(edgeTransaction)}`)
+    return edgeTransaction
+  }
+
+  async broadcastTx(
+    edgeTransaction
+  ) {
+    const otherParams = getOtherParams(edgeTransaction)
+
+    const opBytes = otherParams.fullOp.opbytes
+    const opOb = otherParams.fullOp.opOb
+    const result = await this.multicastServers('injectOperation', opOb, opBytes)
+    edgeTransaction.txid = result.hash
+    edgeTransaction.date = Date.now() / 1000
+    this.log.warn(`SUCCESS broadcastTx\n${cleanTxLogs(edgeTransaction)}`)
+    return edgeTransaction
+  }
+
+  getDisplayPrivateSeed() {
+    if (this.walletInfo.keys && this.walletInfo.keys.mnemonic) {
+      return this.walletInfo.keys.mnemonic
+    }
+    return ''
+  }
+
+  getDisplayPublicSeed() {
+    if (this.walletInfo.keys && this.walletInfo.keys.publicKey) {
+      return this.walletInfo.keys.publicKey
+    }
+    return ''
+  }
+}
+
+export { CurrencyEngine }

package/lib/tezos/tezosInfo.js

@@ -0,0 +1,60 @@
+
+
+
+
+
+const otherSettings = {
+  // Testnet (alphanet):
+  // tezosRpcNodes: [
+  //   'https://rpcalpha.tzbeta.net',
+  //   'https://alphanet-node.tzscan.io',
+  //   'https://alphanet.tezrpc.me'
+  // ],
+  // tezosApiServers: [
+  //   'https://api.alphanet.tzscan.io',
+  //   'http://node1.nyc.tezos.org.sg:8091'
+  // ]
+
+  // Mainnet:
+  tezosRpcNodes: [
+    'https://rpc.tzbeta.net',
+    //  'https://teznode.letzbake.com',
+    'https://mainnet.tezrpc.me'
+  ],
+  tezosApiServers: ['https://api.tzkt.io']
+}
+
+const defaultSettings = {
+  otherSettings,
+  fee: {
+    transaction: '1350',
+    reveal: '1300',
+    burn: '257000'
+  },
+  limit: {
+    gas: '10600',
+    storage: '277'
+  }
+}
+export const currencyInfo = {
+  // Basic currency information:
+  currencyCode: 'XTZ',
+  displayName: 'Tezos',
+  pluginId: 'tezos',
+  walletType: 'wallet:tezos',
+
+  defaultSettings,
+
+  addressExplorer: 'https://tzstats.com/%s',
+  transactionExplorer: 'https://tzstats.com/%s',
+
+  denominations: [
+    // An array of Objects of the possible denominations for this currency
+    {
+      name: 'XTZ',
+      multiplier: '1000000',
+      symbol: 't'
+    }
+  ],
+  metaTokens: []
+}