edge-currency-plugins 1.0.0-rc.1

package/lib/common/plugin/serverScores.js

@@ -0,0 +1,328 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// Typescript translation from original code in edge-currency-bitcoin
+
+var _cleaners = require('cleaners');
+
+
+
+ const asServerInfo = _cleaners.asObject.call(void 0, {
+  serverUrl: _cleaners.asString,
+  serverScore: _cleaners.asNumber,
+  responseTime: _cleaners.asNumber,
+  numResponseTimes: _cleaners.asNumber
+}); exports.asServerInfo = asServerInfo
+
+ const asServerList = _cleaners.asObject.call(void 0, exports.asServerInfo); exports.asServerList = asServerList
+
+
+ const asServerCache = _cleaners.asObject.call(void 0, {
+  customServers: exports.asServerList,
+  internalServers: exports.asServerList
+}); exports.asServerCache = asServerCache
+
+const RESPONSE_TIME_UNINITIALIZED = 999999999
+const MAX_SCORE = 500
+const MIN_SCORE = -100
+const DROPPED_SERVER_SCORE = -100
+const RE_ADDED_SERVER_SCORE = -10
+
+
+
+
+
+
+ class ServerScores {
+  
+  
+  
+  
+
+  constructor(options) {
+    const { log, onDirtyServer = () => {} } = options
+    this.log = log
+    this.scoresLastLoaded = Date.now()
+    this.lastScoreUpTime = Date.now()
+    this.onDirtyServer = onDirtyServer
+  }
+
+  /**
+   * Loads the server scores with new and old servers, mutates the passed in
+   * list of known servers.
+   * @param knownServers: Map of ServerInfo objects by serverUrl. This should come from disk
+   * @param newServers: Array<string> of new servers downloaded from the info server
+   */
+  serverScoresLoad(knownServers, newServers = []) {
+    //
+    // Add any new servers coming out of the info server
+    //
+    for (const newServer of newServers) {
+      if (knownServers[newServer] === undefined) {
+        const serverScoreObj = {
+          serverUrl: newServer,
+          serverScore: 0,
+          responseTime: RESPONSE_TIME_UNINITIALIZED,
+          numResponseTimes: 0
+        }
+        knownServers[newServer] = serverScoreObj
+      }
+    }
+
+    //
+    // If there is a known server that is not on the newServers array, then
+    // reduce it's score to reduce chances of using it.
+    //
+    for (const knownServerUrl in knownServers) {
+      const knownServer = knownServers[knownServerUrl]
+      let match = false
+      for (const newServerUrl of newServers) {
+        if (newServerUrl === knownServerUrl) {
+          match = true
+          break
+        }
+      }
+
+      let serverScore = knownServer.serverScore
+      if (!match) {
+        if (serverScore > DROPPED_SERVER_SCORE) {
+          serverScore = DROPPED_SERVER_SCORE
+        }
+      } else {
+        if (serverScore < RE_ADDED_SERVER_SCORE) {
+          serverScore = RE_ADDED_SERVER_SCORE
+        }
+      }
+
+      if (this.scoresLastLoaded === 0) {
+        serverScore = Math.min(serverScore, MAX_SCORE - 100)
+      }
+
+      if (knownServerUrl.startsWith('ws') && serverScore > 0) {
+        serverScore = 0
+        knownServer.responseTime = RESPONSE_TIME_UNINITIALIZED
+      }
+
+      knownServer.serverScore = serverScore
+      this.onDirtyServer(knownServerUrl)
+    }
+  }
+
+  clearServerScoreTimes() {
+    this.scoresLastLoaded = Date.now()
+    this.lastScoreUpTime = Date.now()
+  }
+
+  printServers(servers) {
+    this.log('**** printServers ****')
+    const serverInfos = []
+    for (const s in servers) {
+      serverInfos.push(servers[s])
+    }
+    // Sort by score
+    serverInfos.sort((a, b) => {
+      return b.serverScore - a.serverScore
+    })
+
+    for (const s of serverInfos) {
+      const score = s.serverScore.toString()
+      const response = s.responseTime.toString()
+      const numResponse = s.numResponseTimes.toString()
+      const url = s.serverUrl
+      this.log(`ServerInfo ${score} ${response}ms ${numResponse} ${url}`)
+    }
+    this.log('**************************')
+  }
+
+  serverScoreUp(
+    servers,
+    serverUrl,
+    responseTimeMilliseconds,
+    changeScore = 1
+  ) {
+    const serverInfo = servers[serverUrl]
+
+    serverInfo.serverScore += changeScore
+    if (serverInfo.serverScore > MAX_SCORE) {
+      serverInfo.serverScore = MAX_SCORE
+    }
+    this.lastScoreUpTime = Date.now()
+
+    if (responseTimeMilliseconds !== 0) {
+      this.setResponseTime(servers, serverUrl, responseTimeMilliseconds)
+    }
+
+    this.log(
+      `${serverUrl}: score UP to ${serverInfo.serverScore} ${responseTimeMilliseconds}ms`
+    )
+    this.onDirtyServer(serverUrl)
+  }
+
+  serverScoreDown(
+    servers,
+    serverUrl,
+    changeScore = 10
+  ) {
+    const currentTime = Date.now()
+    if (currentTime - this.lastScoreUpTime > 60000) {
+      // It has been over 1 minute since we got an up-vote for any server.
+      // Assume the network is down and don't penalize anyone for now
+      this.log(`${serverUrl}: score DOWN cancelled`)
+      return
+    }
+    const serverInfo = servers[serverUrl]
+    serverInfo.serverScore -= changeScore
+    if (serverInfo.serverScore < MIN_SCORE) {
+      serverInfo.serverScore = MIN_SCORE
+    }
+
+    if (serverInfo.numResponseTimes === 0) {
+      this.setResponseTime(servers, serverUrl, 9999)
+    }
+
+    this.log(`${serverUrl}: score DOWN to ${serverInfo.serverScore}`)
+    this.onDirtyServer(serverUrl)
+  }
+
+  setResponseTime(
+    servers,
+    serverUrl,
+    responseTimeMilliseconds
+  ) {
+    const serverInfo = servers[serverUrl]
+    serverInfo.numResponseTimes++
+
+    const oldTime = serverInfo.responseTime
+    let newTime = 0
+    if (RESPONSE_TIME_UNINITIALIZED === oldTime) {
+      newTime = responseTimeMilliseconds
+    } else {
+      // Every 10th setting of response time, decrease effect of prior values by 5x
+      if (serverInfo.numResponseTimes % 10 === 0) {
+        newTime = (oldTime + responseTimeMilliseconds * 4) / 5
+      } else {
+        newTime = (oldTime + responseTimeMilliseconds) / 2
+      }
+    }
+    serverInfo.responseTime = newTime
+    this.onDirtyServer(serverUrl)
+  }
+
+  getServers(
+    servers,
+    numServersWanted,
+    includePatterns = []
+  ) {
+    if (servers == null || Object.keys(servers).length === 0) {
+      return []
+    }
+
+    let serverInfos = []
+    let newServerInfos = []
+    //
+    // Find new servers from the passed in servers
+    //
+    for (const s in servers) {
+      const server = servers[s]
+      serverInfos.push(server)
+      if (
+        server.responseTime === RESPONSE_TIME_UNINITIALIZED &&
+        server.serverScore === 0
+      ) {
+        newServerInfos.push(server)
+      }
+    }
+    if (serverInfos.length === 0) {
+      return []
+    }
+    if (includePatterns.length > 0) {
+      const filter = (server) => {
+        for (const pattern of includePatterns) {
+          // make sure that the server URL starts with the required pattern
+          if (server.serverUrl.indexOf(pattern) === 0) return true
+        }
+        return false
+      }
+      serverInfos = serverInfos.filter(filter)
+      newServerInfos = newServerInfos.filter(filter)
+    }
+    // Sort by score
+    serverInfos.sort((a, b) => {
+      return b.serverScore - a.serverScore
+    })
+
+    //
+    // Take the top 50% of servers that have
+    // 1. A score within 100 points of the highest score
+    // 2. And a positive score of at least 5
+    // 3. And a response time that is not RESPONSE_TIME_UNINITIALIZED
+    //
+    // Then sort those top servers by response time from lowest to highest
+    //
+
+    const startServerInfo = serverInfos[0]
+    let numServerPass = 0
+    let serverEnd = 0
+    for (let i = 0; i < serverInfos.length; i++) {
+      const serverInfo = serverInfos[i]
+      if (serverInfo.serverScore < startServerInfo.serverScore - 100) {
+        continue
+      }
+      if (serverInfo.serverScore < 5) {
+        continue
+      }
+      if (serverInfo.responseTime >= RESPONSE_TIME_UNINITIALIZED) {
+        continue
+      }
+      numServerPass++
+      if (numServerPass < numServersWanted) {
+        continue
+      }
+      if (numServerPass >= serverInfos.length / 2) {
+        continue
+      }
+      serverEnd = i
+    }
+
+    let topServerInfos = serverInfos.slice(0, serverEnd)
+    topServerInfos.sort((a, b) => {
+      return a.responseTime - b.responseTime
+    })
+    topServerInfos = topServerInfos.concat(serverInfos.slice(serverEnd))
+
+    const selectedServers = []
+    let numServers = 0
+    let numNewServers = 0
+    for (const serverInfo of topServerInfos) {
+      numServers++
+      selectedServers.push(serverInfo.serverUrl)
+      if (
+        serverInfo.responseTime === RESPONSE_TIME_UNINITIALIZED &&
+        serverInfo.serverScore === 0
+      ) {
+        numNewServers++
+      }
+
+      if (numServers >= numServersWanted) {
+        break
+      }
+
+      if (numServers >= numServersWanted / 2 && numNewServers === 0) {
+        if (newServerInfos.length >= numServersWanted - numServers) {
+          break
+        }
+      }
+    }
+
+    // If this list does not have a new server in it, try to add one as we always want to give new
+    // servers a try.
+    if (numNewServers === 0) {
+      for (const serverInfo of newServerInfos) {
+        selectedServers.unshift(serverInfo.serverUrl)
+        numServers++
+        if (numServers >= numServersWanted) {
+          break
+        }
+      }
+    }
+
+    return selectedServers
+  }
+} exports.ServerScores = ServerScores;

package/lib/common/plugin/types.js

@@ -0,0 +1,173 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+var _cleaners = require('cleaners');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const asCurrencyFormat = _cleaners.asValue.call(void 0, 'bip32', 'bip44', 'bip49', 'bip84'); exports.asCurrencyFormat = asCurrencyFormat
+
+// Path up to changeIndex
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const asFeeRates = _cleaners.asObject.call(void 0, {
+  lowFee: _cleaners.asString,
+  standardFeeLow: _cleaners.asString,
+  standardFeeHigh: _cleaners.asString,
+  highFee: _cleaners.asString
+}); exports.asFeeRates = asFeeRates
+
+
+ const asSimpleFeeSettings = _cleaners.asObject.call(void 0, {
+  ...exports.asFeeRates.shape,
+  standardFeeLowAmount: _cleaners.asString,
+  standardFeeHighAmount: _cleaners.asString
+}); exports.asSimpleFeeSettings = asSimpleFeeSettings
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const asLocalWalletMetadata = _cleaners.asObject.call(void 0, {
+  balance: _cleaners.asString,
+  lastSeenBlockHeight: _cleaners.asNumber
+}); exports.asLocalWalletMetadata = asLocalWalletMetadata

package/lib/common/plugin/utils.js

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }var _all = require('../utxobased/info/all');
+
+ const getFormatsForNetwork = (coinName) => {
+  for (const plugin of _all.all) {
+    if (plugin.coinInfo.name === coinName)
+      return _nullishCoalesce(plugin.engineInfo.formats, () => ( []))
+  }
+  return []
+}; exports.getFormatsForNetwork = getFormatsForNetwork
+
+
+
+
+
+ const removeItem = (obj, key) => {
+  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+  delete obj[key]
+}; exports.removeItem = removeItem

package/lib/common/utxobased/db/Models/ProcessorTransaction.js

@@ -0,0 +1,122 @@
+"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 _defaultValidateConfirmations = require('../../engine/util/defaultValidateConfirmations');
+var _keymanager = require('../../keymanager/keymanager');
+
+
+
+ const fromEdgeTransaction = (
+  tx
+) => {
+  const otherParams = tx.otherParams 
+  if (otherParams == null) throw new Error('Invalid transaction data')
+  if (otherParams.psbt == null)
+    throw new Error('Missing PSBT in edge transaction data')
+
+  /**
+   * [1]: Buffer.from is necessary because Buffers are converted to Uint8Arrays
+   * after through passing the bridge.
+   */
+  const inputs = otherParams.psbt.inputs.map((input, n) => ({
+    amount: input.value.toString(),
+    scriptPubkey: Buffer.from(input.scriptPubkey).toString('hex'), // [1]
+    n,
+    txId: Buffer.from(input.hash).reverse().toString('hex'), // [1]
+    outputIndex: input.index
+  }))
+  const outputs = otherParams.psbt.outputs.map((output, n) => ({
+    amount: output.value.toString(),
+    scriptPubkey: Buffer.from(output.scriptPubkey).toString('hex'), // [1]
+    n
+  }))
+
+  return {
+    txid: tx.txid,
+    hex: tx.signedTx,
+    blockHeight: tx.blockHeight,
+    date: tx.date,
+    fees: tx.networkFee,
+    inputs: inputs,
+    outputs: outputs,
+    // We can leave ourIns/ourOuts blank because they'll be updated by the
+    // processor when receiving the transaction from blockbook.
+    // We may want to calculate these preemptively, but for now this will work.
+    ourIns: [],
+    ourOuts: [],
+    ourAmount: _nullishCoalesce(tx.nativeAmount, () => ( '0'))
+  }
+}; exports.fromEdgeTransaction = fromEdgeTransaction
+
+
+
+
+
+
+
+
+
+
+ const toEdgeTransaction = async (
+  args
+) => {
+  const { tx, processor, walletBlockHeight, walletTools, pluginInfo } = args
+  const { currencyInfo, engineInfo } = pluginInfo
+  const { validateConfirmations = _defaultValidateConfirmations.defaultValidateConfirmations } = engineInfo
+  const { requiredConfirmations } = currencyInfo
+
+  const ourReceiveAddresses = []
+  for (const out of tx.ourOuts) {
+    const { scriptPubkey } = tx.outputs[parseInt(out)]
+    const address = await processor.fetchAddress(scriptPubkey)
+
+    /*
+    Hack to set replay protection tx to the correct script type through the
+    address format.
+
+    We use a function which can determine whether the derivationLevelScriptHash
+    was used for the path's change index in order to detect whether an address
+    is used for replay protection. We need to detect this because we must treat
+    the address format as bip49 because the script is P2SH even though the
+    address is on the bip44 derivation chain.
+    */
+    const scriptTemplate = _optionalChain([engineInfo, 'access', _ => _.scriptTemplates, 'optionalAccess', _2 => _2.replayProtection])
+    if (
+      scriptTemplate != null &&
+      _optionalChain([address, 'optionalAccess', _3 => _3.path]) != null &&
+      _keymanager.isPathUsingDerivationLevelScriptHash.call(void 0, scriptTemplate, address.path)
+    ) {
+      address.path.format = 'bip49'
+    }
+
+    if (_optionalChain([address, 'optionalAccess', _4 => _4.path]) != null) {
+      const { address: addrStr } = walletTools.scriptPubkeyToAddress({
+        scriptPubkey,
+        format: address.path.format
+      })
+      ourReceiveAddresses.push(addrStr)
+    }
+  }
+
+  const confirmations = validateConfirmations(
+    tx,
+    walletBlockHeight,
+    requiredConfirmations
+  )
+
+  const edgeTx = {
+    currencyCode: args.currencyCode,
+    txid: args.tx.txid,
+    confirmations,
+    blockHeight: args.tx.blockHeight,
+    date: args.tx.date,
+    nativeAmount: args.tx.ourAmount,
+    networkFee: args.tx.fees,
+    signedTx: args.tx.hex,
+    ourReceiveAddresses
+  }
+
+  return edgeTx
+}; exports.toEdgeTransaction = toEdgeTransaction

package/lib/common/utxobased/db/Models/baselet.js

@@ -0,0 +1,81 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+ const addressPathToPrefix = (path) =>
+  `${path.format}_${path.changeIndex}`; exports.addressPathToPrefix = addressPathToPrefix
+
+
+ const scriptPubkeyByPathOptions = {
+  name: 'scriptPubkeyByPath',
+  bucketSize: 50
+}; exports.scriptPubkeyByPathOptions = scriptPubkeyByPathOptions
+
+
+ const addressByScriptPubkeyOptions = {
+  name: 'addressByScriptPubkey',
+  prefixSize: 4
+}; exports.addressByScriptPubkeyOptions = addressByScriptPubkeyOptions
+
+
+ const lastUsedByFormatPathOptions = {
+  name: 'lastUsedByFormatPath',
+  prefixSize: 2
+}; exports.lastUsedByFormatPathOptions = lastUsedByFormatPathOptions
+
+
+
+
+
+
+
+
+
+
+ const txIdsByBlockHeightOptions
+
+
+ = {
+  name: 'txIdByBlockHeight',
+  bucketSize: 100000,
+  rangeKey: 'blockHeight',
+  idKey: 'txid'
+}; exports.txIdsByBlockHeightOptions = txIdsByBlockHeightOptions
+
+
+ const txByIdOptions = {
+  name: 'txById',
+  prefixSize: 2
+}; exports.txByIdOptions = txByIdOptions
+
+
+
+
+
+
+ const txIdsByDateOptions = {
+  name: 'txIdsByDate',
+  bucketSize: 30 * 24 * 60 * 60, // 30 days
+  rangeKey: 'date',
+  idKey: 'txid'
+}; exports.txIdsByDateOptions = txIdsByDateOptions
+
+
+ const utxoByIdOptions = {
+  name: 'utxoById',
+  prefixSize: 2
+}; exports.utxoByIdOptions = utxoByIdOptions
+
+
+ const utxoIdsByScriptPubkeyOptions = {
+  name: 'utxoIdsByScriptPubkey',
+  prefixSize: 4
+}; exports.utxoIdsByScriptPubkeyOptions = utxoIdsByScriptPubkeyOptions