edge-currency-accountbased 2.2.4 → 2.4.0

package/lib/piratechain/PiratechainEngine.js

@@ -0,0 +1,469 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var _biggystring = require('biggystring');
+
+
+
+
+
+
+
+
+
+
+
+var _types = require('edge-core-js/types');
+
+var _CurrencyEngine = require('../common/CurrencyEngine');
+
+var _upgradeMemos = require('../common/upgradeMemos');
+var _utils = require('../common/utils');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _piratechainTypes = require('./piratechainTypes');
+
+ class PiratechainEngine extends _CurrencyEngine.CurrencyEngine
+
+
+ {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+
+
+
+  constructor(
+    env,
+    tools,
+    walletInfo,
+    opts,
+    makeSynchronizer
+  ) {
+    super(env, tools, walletInfo, opts)
+    const { networkInfo } = env
+    this.pluginId = this.currencyInfo.pluginId
+    this.networkInfo = networkInfo
+    this.makeSynchronizer = makeSynchronizer
+    this.queryMutex = false
+  }
+
+  setOtherData(raw) {
+    this.otherData = _piratechainTypes.asPiratechainWalletOtherData.call(void 0, raw)
+  }
+
+  initData() {
+    const { birthdayHeight, alias } = this.initializer
+
+    // walletLocalData
+    if (this.otherData.blockRange.first === 0) {
+      this.otherData.blockRange = {
+        first: birthdayHeight,
+        last: birthdayHeight
+      }
+    }
+
+    // Engine variables
+    this.alias = alias
+    this.initialNumBlocksToDownload = -1
+    this.synchronizerStatus = 'DISCONNECTED'
+    this.availableZatoshi = '0'
+    this.progressRatio = 0
+  }
+
+  initSubscriptions() {
+    this.synchronizer.on('update', async payload => {
+      const { lastDownloadedHeight, scanProgress, networkBlockHeight } = payload
+      this.onUpdateBlockHeight(networkBlockHeight)
+      this.onUpdateProgress(
+        lastDownloadedHeight,
+        scanProgress,
+        networkBlockHeight
+      )
+      await this.queryAll()
+    })
+    this.synchronizer.on('statusChanged', async payload => {
+      this.synchronizerStatus = payload.name
+      await this.queryAll()
+    })
+  }
+
+  async queryAll() {
+    if (this.queryMutex) return
+    this.queryMutex = true
+    try {
+      await this.queryBalance()
+      await this.queryTransactions()
+      this.onUpdateTransactions()
+    } catch (e) {}
+    this.queryMutex = false
+  }
+
+  onUpdateBlockHeight(networkBlockHeight) {
+    if (this.walletLocalData.blockHeight !== networkBlockHeight) {
+      this.walletLocalData.blockHeight = networkBlockHeight
+      this.walletLocalDataDirty = true
+      this.currencyEngineCallbacks.onBlockHeightChanged(
+        this.walletLocalData.blockHeight
+      )
+    }
+  }
+
+  onUpdateTransactions() {
+    if (this.transactionsChangedArray.length > 0) {
+      this.currencyEngineCallbacks.onTransactionsChanged(
+        this.transactionsChangedArray
+      )
+      this.transactionsChangedArray = []
+    }
+  }
+
+  onUpdateProgress(
+    lastDownloadedHeight,
+    scanProgress,
+    networkBlockHeight
+  ) {
+    if (!this.addressesChecked && !this.isSynced()) {
+      // Sync status is split up between downloading blocks (40%), scanning blocks (49.5%),
+      // getting balance (0.5%), and querying transactions (10%).
+      this.tokenCheckBalanceStatus[this.currencyInfo.currencyCode] =
+        (scanProgress * 0.99) / 100
+
+      let downloadProgress = 0
+      if (lastDownloadedHeight > 0) {
+        // Initial lastDownloadedHeight value is -1
+        const currentNumBlocksToDownload =
+          networkBlockHeight - lastDownloadedHeight
+        if (this.initialNumBlocksToDownload < 0) {
+          this.initialNumBlocksToDownload = currentNumBlocksToDownload
+        }
+
+        downloadProgress =
+          currentNumBlocksToDownload === 0 ||
+          this.initialNumBlocksToDownload === 0
+            ? 1
+            : 1 - currentNumBlocksToDownload / this.initialNumBlocksToDownload
+      }
+      this.tokenCheckTransactionsStatus[this.currencyInfo.currencyCode] =
+        downloadProgress * 0.8
+
+      const percent =
+        (this.tokenCheckTransactionsStatus[this.currencyInfo.currencyCode] +
+          this.tokenCheckBalanceStatus[this.currencyInfo.currencyCode]) /
+        2
+      if (percent !== this.progressRatio) {
+        if (Math.abs(percent - this.progressRatio) > 0.1 || percent === 1) {
+          this.progressRatio = percent
+          this.updateOnAddressesChecked()
+        }
+      }
+    }
+  }
+
+  async startEngine() {
+    this.initData()
+    // this.synchronizer = await this.makeSynchronizer(this.initializer)
+    // await this.synchronizer.start()
+    // this.initSubscriptions()
+    await super.startEngine()
+  }
+
+  isSynced() {
+    // Synchronizer status is updated regularly and should be checked before accessing the db to avoid errors
+    return this.synchronizerStatus === 'SYNCED'
+  }
+
+  async queryBalance() {
+    if (!this.isSynced()) return
+    try {
+      const balances = await this.synchronizer.getShieldedBalance()
+      if (balances.totalZatoshi === '-1') return
+      this.availableZatoshi = balances.availableZatoshi
+      this.updateBalance(this.currencyInfo.currencyCode, balances.totalZatoshi)
+    } catch (e) {
+      this.warn('Failed to update balances', e)
+      this.updateBalance(this.currencyInfo.currencyCode, '0')
+    }
+  }
+
+  async queryTransactions() {
+    try {
+      let first = this.otherData.blockRange.first
+      let last = this.otherData.blockRange.last
+      while (this.isSynced() && last <= this.walletLocalData.blockHeight) {
+        const transactions = await this.synchronizer.getTransactions({
+          first,
+          last
+        })
+
+        transactions.forEach(tx => this.processTransaction(tx))
+
+        if (last === this.walletLocalData.blockHeight) {
+          first = this.walletLocalData.blockHeight
+          this.walletLocalDataDirty = true
+          this.tokenCheckTransactionsStatus[this.currencyInfo.currencyCode] = 1
+          this.updateOnAddressesChecked()
+          break
+        }
+
+        first = last + 1
+        last =
+          last + this.networkInfo.transactionQueryLimit <
+          this.walletLocalData.blockHeight
+            ? last + this.networkInfo.transactionQueryLimit
+            : this.walletLocalData.blockHeight
+
+        this.otherData.blockRange = {
+          first,
+          last
+        }
+        this.walletLocalDataDirty = true
+      }
+    } catch (e) {
+      this.error(
+        `Error querying ${this.currencyInfo.currencyCode} transactions `,
+        e
+      )
+    }
+  }
+
+  processTransaction(tx) {
+    let netNativeAmount = tx.value
+    const ourReceiveAddresses = []
+    if (tx.toAddress != null) {
+      // check if tx is a spend
+      netNativeAmount = `-${_biggystring.add.call(void 0, 
+        netNativeAmount,
+        this.networkInfo.defaultNetworkFee
+      )}`
+    } else {
+      ourReceiveAddresses.push(this.walletInfo.keys.publicKey)
+    }
+
+    const memos = []
+    if (tx.memo != null) {
+      memos.push({
+        type: 'text',
+        value: tx.memo
+      })
+    }
+
+    const edgeTransaction = {
+      txid: tx.rawTransactionId,
+      date: tx.blockTimeInSeconds,
+      currencyCode: this.currencyInfo.currencyCode,
+      blockHeight: tx.minedHeight,
+      nativeAmount: netNativeAmount,
+      isSend: netNativeAmount.startsWith('-'),
+      memos,
+      networkFee: this.networkInfo.defaultNetworkFee,
+      ourReceiveAddresses, // blank if you sent money otherwise array of addresses that are yours in this transaction
+      signedTx: '',
+      otherParams: {},
+      walletId: this.walletId
+    }
+    this.addTransaction(this.currencyInfo.currencyCode, edgeTransaction)
+  }
+
+  async killEngine() {
+    // await this.synchronizer.stop()
+    await super.killEngine()
+  }
+
+  async clearBlockchainCache() {
+    await super.clearBlockchainCache()
+  }
+
+  async resyncBlockchain() {
+    // Don't bother stopping and restarting the synchronizer for a resync
+    await super.killEngine()
+    await this.clearBlockchainCache()
+    await this.startEngine()
+    // this.synchronizer
+    //   .rescan(this.walletInfo.keys.birthdayHeight)
+    //   .catch((e: any) => this.warn('resyncBlockchain failed: ', e))
+  }
+
+  async getMaxSpendable() {
+    if (!this.isSynced()) throw new Error('Cannot spend until wallet is synced')
+    const spendableBalance = _biggystring.sub.call(void 0, 
+      this.availableZatoshi,
+      this.networkInfo.defaultNetworkFee
+    )
+    if (_biggystring.lte.call(void 0, spendableBalance, '0')) throw new (0, _types.InsufficientFundsError)()
+
+    return spendableBalance
+  }
+
+  async makeSpend(edgeSpendInfoIn) {
+    edgeSpendInfoIn = _upgradeMemos.upgradeMemos.call(void 0, edgeSpendInfoIn, this.currencyInfo)
+    if (!this.isSynced()) throw new Error('Cannot spend until wallet is synced')
+    const { edgeSpendInfo, currencyCode } = this.makeSpendCheck(edgeSpendInfoIn)
+    const { memos = [] } = edgeSpendInfo
+    const spendTarget = edgeSpendInfo.spendTargets[0]
+    const { publicAddress, nativeAmount } = spendTarget
+
+    if (publicAddress == null)
+      throw new Error('makeSpend Missing publicAddress')
+    if (nativeAmount == null) throw new (0, _types.NoAmountSpecifiedError)()
+
+    if (_biggystring.eq.call(void 0, nativeAmount, '0')) throw new (0, _types.NoAmountSpecifiedError)()
+
+    const totalTxAmount = _biggystring.add.call(void 0, nativeAmount, this.networkInfo.defaultNetworkFee)
+
+    if (
+      _biggystring.gt.call(void 0, 
+        totalTxAmount,
+        _nullishCoalesce(this.walletLocalData.totalBalances[this.currencyInfo.currencyCode], () => (
+          '0'))
+      )
+    ) {
+      throw new (0, _types.InsufficientFundsError)()
+    }
+
+    if (_biggystring.gt.call(void 0, totalTxAmount, this.availableZatoshi)) {
+      throw new (0, _types.InsufficientFundsError)('Amount exceeds available balance')
+    }
+
+    // **********************************
+    // Create the unsigned EdgeTransaction
+
+    const spendTargets = edgeSpendInfo.spendTargets.map(si => ({
+      uniqueIdentifier: si.uniqueIdentifier,
+      memo: si.memo,
+      nativeAmount: _nullishCoalesce(si.nativeAmount, () => ( '0')),
+      currencyCode,
+      publicAddress
+    }))
+
+    const edgeTransaction = {
+      txid: '', // txid
+      date: 0, // date
+      currencyCode, // currencyCode
+      blockHeight: 0, // blockHeight
+      nativeAmount: `-${totalTxAmount}`, // nativeAmount
+      isSend: nativeAmount.startsWith('-'),
+      memos,
+      networkFee: this.networkInfo.defaultNetworkFee, // networkFee
+      ourReceiveAddresses: [], // ourReceiveAddresses
+      signedTx: '', // signedTx
+      spendTargets,
+      walletId: this.walletId
+    }
+
+    return edgeTransaction
+  }
+
+  async signTx(edgeTransaction) {
+    // Transaction is signed and broadcast at the same time
+    return edgeTransaction
+  }
+
+  async broadcastTx(
+    edgeTransaction,
+    opts
+  ) {
+    if (!this.isSynced())
+      throw new Error('Cannot broadcast until wallet is synced')
+    const { memos } = edgeTransaction
+    const piratechainPrivateKeys = _piratechainTypes.asPiratechainPrivateKeys.call(void 0, this.pluginId)(
+      _optionalChain([opts, 'optionalAccess', _ => _.privateKeys])
+    )
+    if (
+      edgeTransaction.spendTargets == null ||
+      edgeTransaction.spendTargets.length !== 1
+    )
+      throw new Error('Invalid spend targets')
+
+    const memo = _optionalChain([memos, 'access', _2 => _2[0], 'optionalAccess', _3 => _3.type]) === 'text' ? memos[0].value : ''
+    const spendTarget = edgeTransaction.spendTargets[0]
+    const txParams = {
+      zatoshi: _biggystring.sub.call(void 0, 
+        _biggystring.abs.call(void 0, edgeTransaction.nativeAmount),
+        edgeTransaction.networkFee
+      ),
+      toAddress: spendTarget.publicAddress,
+      memo,
+      fromAccountIndex: 0,
+      spendingKey: piratechainPrivateKeys.spendKey
+    }
+
+    try {
+      const signedTx = await this.synchronizer.sendToAddress(txParams)
+      edgeTransaction.txid = signedTx.txId
+      edgeTransaction.signedTx = signedTx.raw
+      edgeTransaction.date = Date.now() / 1000
+      this.warn(`SUCCESS broadcastTx\n${_utils.cleanTxLogs.call(void 0, edgeTransaction)}`)
+    } catch (e) {
+      this.warn('FAILURE broadcastTx failed: ', e)
+      throw e
+    }
+    return edgeTransaction
+  }
+
+  getDisplayPrivateSeed(privateKeys) {
+    const piratechainPrivateKeys = _piratechainTypes.asPiratechainPrivateKeys.call(void 0, this.pluginId)(
+      privateKeys
+    )
+    return piratechainPrivateKeys.mnemonic
+  }
+
+  getDisplayPublicSeed() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _4 => _4.walletInfo, 'access', _5 => _5.keys, 'access', _6 => _6.unifiedViewingKeys, 'optionalAccess', _7 => _7.extfvk]), () => ( ''))
+  }
+
+  async loadEngine() {
+    const { walletInfo } = this
+    await super.loadEngine()
+    this.engineOn = true
+
+    const { rpcNode } = this.networkInfo
+    this.initializer = {
+      fullViewingKey: walletInfo.keys.unifiedViewingKeys,
+      birthdayHeight: walletInfo.keys.birthdayHeight,
+      alias: walletInfo.keys.publicKey,
+      ...rpcNode
+    }
+  }
+} exports.PiratechainEngine = PiratechainEngine;
+ async function makeCurrencyEngine(
+  env,
+  tools,
+  walletInfo,
+  opts
+) {
+  const safeWalletInfo = _piratechainTypes.asSafePiratechainWalletInfo.call(void 0, walletInfo)
+  // const { makeSynchronizer } =
+  //   env.nativeIo['edge-currency-accountbased'].piratechain ?? {}
+
+  const engine = new PiratechainEngine(
+    env,
+    tools,
+    safeWalletInfo,
+    opts,
+    // makeSynchronizer
+    () => {}
+  )
+
+  // Do any async initialization necessary for the engine
+  await engine.loadEngine()
+
+  return engine
+} exports.makeCurrencyEngine = makeCurrencyEngine;

package/lib/piratechain/PiratechainTools.js

@@ -0,0 +1,239 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _createNamedExportFrom(obj, localName, importedName) { Object.defineProperty(exports, localName, {enumerable: true, get: () => obj[importedName]}); } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }var _biggystring = require('biggystring');
+var _bip39 = require('bip39');
+var _buffer = require('buffer');
+
+
+
+
+
+
+
+
+
+
+
+
+// import {
+//   AddressTool as AddressToolType,
+//   KeyTool as KeyToolType
+// } from 'react-native-piratechain'
+
+// import { asIntegerString } from '../common/types'
+var _uriHelpers = require('../common/uriHelpers');
+var _utils = require('../common/utils');
+
+
+
+
+
+
+var _piratechainTypes = require('./piratechainTypes');
+
+ class PiratechainTools  {
+  
+  
+  
+  
+
+  // KeyTool: typeof KeyToolType
+  // AddressTool: typeof AddressToolType
+
+  constructor(env) {
+    const { builtinTokens, currencyInfo, io, networkInfo } = env
+    this.builtinTokens = builtinTokens
+    this.currencyInfo = currencyInfo
+    this.io = io
+    this.networkInfo = networkInfo
+
+    const RNAccountbased = env.nativeIo['edge-currency-accountbased']
+    if (RNAccountbased == null) {
+      throw new Error('Need opts')
+    }
+    // const { KeyTool, AddressTool } = RNAccountbased.piratechain
+
+    // this.KeyTool = KeyTool
+    // this.AddressTool = AddressTool
+  }
+
+  async getNewWalletBirthdayBlockheight() {
+    throw new Error('getNewWalletBirthdayBlockheight is disabled')
+    // try {
+    //   return await this.KeyTool.getBirthdayHeight(
+    //     this.networkInfo.rpcNode.defaultHost,
+    //     this.networkInfo.rpcNode.defaultPort
+    //   )
+    // } catch (e: any) {
+    //   return this.networkInfo.defaultBirthday
+    // }
+  }
+
+  async isValidAddress(address) {
+    return false
+    // return (
+    //   (await this.AddressTool.isValidShieldedAddress(address)) ||
+    //   (await this.AddressTool.isValidTransparentAddress(address))
+    // )
+  }
+
+  // will actually use MNEMONIC version of private key
+  async importPrivateKey(
+    userInput,
+    opts = {}
+  ) {
+    throw new Error('importPrivateKey is disabled')
+    // const { pluginId } = this.currencyInfo
+    // const isValid = validateMnemonic(userInput)
+    // if (!isValid)
+    //   throw new Error(`Invalid ${this.currencyInfo.currencyCode} mnemonic`)
+    // const hexBuffer = await mnemonicToSeed(userInput)
+    // const hex = hexBuffer.toString('hex')
+    // const spendKey = await this.KeyTool.deriveSpendingKey(
+    //   hex,
+    //   this.networkInfo.rpcNode.networkName
+    // )
+    // if (typeof spendKey !== 'string') throw new Error('Invalid spendKey type')
+
+    // // Get current network height for the birthday height
+    // const currentNetworkHeight = await this.getNewWalletBirthdayBlockheight()
+
+    // let height = currentNetworkHeight
+
+    // const { birthdayHeight } = opts
+    // if (birthdayHeight != null) {
+    //   asIntegerString(birthdayHeight)
+
+    //   const birthdayHeightInt = parseInt(birthdayHeight)
+
+    //   if (birthdayHeightInt > currentNetworkHeight) {
+    //     throw new Error('InvalidBirthdayHeight') // must be less than current block height (assuming query was successful)
+    //   }
+    //   height = birthdayHeightInt
+    // }
+
+    // return {
+    //   [`${pluginId}Mnemonic`]: userInput,
+    //   [`${pluginId}SpendKey`]: spendKey,
+    //   [`${pluginId}BirthdayHeight`]: height
+    // }
+  }
+
+  async createPrivateKey(walletType) {
+    if (walletType !== this.currencyInfo.walletType) {
+      throw new Error('InvalidWalletType')
+    }
+
+    const entropy = _buffer.Buffer.from(this.io.random(32)).toString('hex')
+    const mnemonic = _bip39.entropyToMnemonic.call(void 0, entropy)
+    return await this.importPrivateKey(mnemonic)
+  }
+
+  async checkPublicKey(publicKey) {
+    try {
+      _piratechainTypes.asArrrPublicKey.call(void 0, publicKey)
+      return true
+    } catch (err) {
+      return false
+    }
+  }
+
+  async derivePublicKey(walletInfo) {
+    const { pluginId } = this.currencyInfo
+    const piratechainPrivateKeys = _piratechainTypes.asPiratechainPrivateKeys.call(void 0, pluginId)(
+      walletInfo.keys
+    )
+    if (walletInfo.type !== this.currencyInfo.walletType) {
+      throw new Error('InvalidWalletType')
+    }
+
+    return {
+      birthdayHeight: piratechainPrivateKeys.birthdayHeight,
+      publicKey: 'derivePublicKey is disabled',
+      unifiedViewingKeys: {
+        extfvk: '',
+        extpub: ''
+      }
+    }
+
+    // const mnemonic = piratechainPrivateKeys.mnemonic
+    // if (typeof mnemonic !== 'string') {
+    //   throw new Error('InvalidMnemonic')
+    // }
+    // const hexBuffer = await mnemonicToSeed(mnemonic)
+    // const hex = hexBuffer.toString('hex')
+    // const unifiedViewingKeys: UnifiedViewingKey =
+    //   await this.KeyTool.deriveViewingKey(
+    //     hex,
+    //     this.networkInfo.rpcNode.networkName
+    //   )
+    // const shieldedAddress = await this.AddressTool.deriveShieldedAddress(
+    //   unifiedViewingKeys.extfvk,
+    //   this.networkInfo.rpcNode.networkName
+    // )
+    // return {
+    //   birthdayHeight: piratechainPrivateKeys.birthdayHeight,
+    //   publicKey: shieldedAddress,
+    //   unifiedViewingKeys
+    // }
+  }
+
+  async parseUri(
+    uri,
+    currencyCode,
+    customTokens
+  ) {
+    const { pluginId } = this.currencyInfo
+    const networks = { [pluginId]: true }
+
+    const {
+      edgeParsedUri
+      // edgeParsedUri: { publicAddress }
+    } = _uriHelpers.parseUriCommon.call(void 0, 
+      this.currencyInfo,
+      uri,
+      networks,
+      _nullishCoalesce(currencyCode, () => ( this.currencyInfo.currencyCode)),
+      customTokens
+    )
+
+    // if (publicAddress == null || !(await this.isValidAddress(publicAddress))) {
+    //   throw new Error('InvalidPublicAddressError')
+    // }
+
+    return edgeParsedUri
+  }
+
+  async encodeUri(
+    obj,
+    customTokens = []
+  ) {
+    const { pluginId } = this.currencyInfo
+    const { nativeAmount, currencyCode /* publicAddress */ } = obj
+
+    // if (!(await this.isValidAddress(publicAddress))) {
+    //   throw new Error('InvalidPublicAddressError')
+    // }
+
+    let amount
+    if (nativeAmount != null) {
+      const denom = _utils.getLegacyDenomination.call(void 0, 
+        _nullishCoalesce(currencyCode, () => ( this.currencyInfo.currencyCode)),
+        this.currencyInfo,
+        customTokens
+      )
+      if (denom == null) {
+        throw new Error('InternalErrorInvalidCurrencyCode')
+      }
+      amount = _biggystring.div.call(void 0, nativeAmount, denom.multiplier, 18)
+    }
+    const encodedUri = _uriHelpers.encodeUriCommon.call(void 0, obj, `${pluginId}`, amount)
+    return encodedUri
+  }
+} exports.PiratechainTools = PiratechainTools;
+
+ async function makeCurrencyTools(
+  env
+) {
+  return new PiratechainTools(env)
+} exports.makeCurrencyTools = makeCurrencyTools;
+
+var _PiratechainEngine = require('./PiratechainEngine'); _createNamedExportFrom(_PiratechainEngine, 'makeCurrencyEngine', 'makeCurrencyEngine');