edge-currency-accountbased 0.7.72

package/lib/common/plugin.js

@@ -0,0 +1,152 @@
+/**
+ * Created by paul on 8/8/17.
+ */
+// 
+
+import { bns } from 'biggystring'
+
+
+
+
+
+
+
+
+
+
+
+import { serialize } from 'uri-js'
+import parse from 'url-parse'
+
+import { getDenomInfo } from '../common/utils.js'
+
+// TODO: pass in denoms pull code into common
+export class CurrencyPlugin {
+  
+  
+  
+  
+
+  constructor(io, pluginId, currencyInfo) {
+    this.io = io
+    this.pluginId = pluginId
+    this.currencyInfo = currencyInfo
+    this.highestTxHeight = 0
+  }
+
+  async createPrivateKey(walletType) {
+    throw new Error('Must implement createPrivateKey')
+  }
+
+  async derivePublicKey(walletInfo) {
+    throw new Error('Must implement derivePublicKey')
+  }
+
+  async makeEngine(
+    walletInfo,
+    opts
+  ) {
+    throw new Error('Must implement makeEngine')
+  }
+
+  async parseUri(uri) {
+    throw new Error('Must implement parseUri')
+  }
+
+  async encodeUri(obj) {
+    throw new Error('Must implement encodeUri')
+  }
+
+  parseUriCommon(
+    currencyInfo,
+    uri,
+    networks,
+    currencyCode,
+    customTokens
+  ) {
+    const parsedUri = parse(uri, {}, true)
+
+    // Remove ":" from protocol
+    if (parsedUri.protocol) {
+      parsedUri.protocol = parsedUri.protocol.replace(':', '')
+    }
+
+    if (parsedUri.protocol && !networks[parsedUri.protocol]) {
+      throw new Error('InvalidUriError') // possibly scanning wrong crypto type
+    }
+
+    // If no host and no path, then it's not a valid URI
+    if (parsedUri.host === '' && parsedUri.pathname === '') {
+      throw new Error('InvalidUriError')
+    }
+
+    // Address uses the host if present to support URLs with double-slashes (//)
+    const publicAddress =
+      parsedUri.host !== '' ? parsedUri.host : parsedUri.pathname.split('/')[0]
+
+    const edgeParsedUri = {
+      publicAddress
+    }
+
+    // Metadata query parameters
+    const label = parsedUri.query.label
+    const message = parsedUri.query.message
+    const category = parsedUri.query.category
+
+    if (label || message || category) {
+      edgeParsedUri.metadata = {}
+      edgeParsedUri.metadata.name = label || undefined
+      edgeParsedUri.metadata.notes = message || undefined
+      edgeParsedUri.metadata.category = category || undefined
+    }
+
+    const amountStr = parsedUri.query.amount
+    if (amountStr && typeof amountStr === 'string') {
+      if (!currencyCode) {
+        currencyCode = currencyInfo.currencyCode
+      }
+      const denom = getDenomInfo(currencyInfo, currencyCode, customTokens)
+      if (!denom) {
+        throw new Error('InternalErrorInvalidCurrencyCode')
+      }
+      let nativeAmount = bns.mul(amountStr, denom.multiplier)
+      nativeAmount = bns.toFixed(nativeAmount, 0, 0)
+
+      edgeParsedUri.nativeAmount = nativeAmount || undefined
+      edgeParsedUri.currencyCode = currencyCode || undefined
+    }
+
+    return { edgeParsedUri, parsedUri }
+  }
+
+  encodeUriCommon(obj, network, amount) {
+    if (!obj.publicAddress) {
+      throw new Error('InvalidPublicAddressError')
+    }
+    if (!amount && !obj.label && !obj.message) {
+      return obj.publicAddress
+    } else {
+      let queryString = ''
+      if (amount) {
+        queryString += 'amount=' + amount + '&'
+      }
+      if (obj.label || obj.message) {
+        if (typeof obj.label === 'string') {
+          queryString += 'label=' + obj.label + '&'
+        }
+        if (typeof obj.message === 'string') {
+          queryString += 'message=' + obj.message + '&'
+        }
+      }
+      queryString = queryString.substr(0, queryString.length - 1)
+
+      const serializeObj = {
+        scheme: network,
+        path: obj.publicAddress,
+        query: queryString
+      }
+      const url = serialize(serializeObj)
+      return url
+    }
+  }
+}

package/lib/common/schema.js

@@ -0,0 +1,108 @@
+// 
+
+import { asArray, asObject, asOptional, asString } from 'cleaners'
+
+export const CurrencyInfoSchema = {
+  type: 'object',
+  properties: {
+    walletTypes: {
+      type: 'array',
+      items: { type: 'string' }
+    },
+    currencyCode: { type: 'string' },
+    currencyName: { type: 'string' },
+    addressExplorer: { type: 'string' },
+    transactionExplorer: { type: 'string' },
+    defaultSettings: {
+      type: 'object'
+    },
+    denominations: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          multiplier: { type: 'string' },
+          symbol: { type: 'string' }
+        },
+        required: ['name', 'multiplier']
+      }
+    },
+    metaTokens: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          currencyCode: { type: 'string' },
+          currencyName: { type: 'string' },
+          denominations: {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                name: { type: 'string' },
+                multiplier: { type: 'string' },
+                symbol: { type: 'string' }
+              },
+              required: ['name', 'multiplier']
+            }
+          },
+          contractAddress: { type: 'string' }
+        },
+        required: ['currencyCode', 'currencyName', 'denominations']
+      }
+    }
+  },
+  required: [
+    'walletTypes',
+    'currencyCode',
+    'currencyName',
+    'defaultSettings',
+    'denominations',
+    'addressExplorer',
+    'transactionExplorer'
+  ]
+}
+
+export const asCurrencyCodeOptions = asObject({
+  currencyCode: asOptional(asString)
+})
+
+/**
+ * Does the same tests that the old JSON schema used to do,
+ * but with better error reporting.
+ */
+export function checkEdgeSpendInfo(raw) {
+  try {
+    asPartialSpendInfo(raw)
+  } catch (error) {
+    throw new TypeError('Invalid EdgeSpendInfo: ' + error.message)
+  }
+}
+
+export function checkCustomToken(raw) {
+  try {
+    asCustomToken(raw)
+  } catch (error) {
+    throw new TypeError('Invalid CustomToken: ' + error.message)
+  }
+}
+
+const asPartialSpendInfo = asObject({
+  currencyCode: asOptional(asString),
+  networkFeeOption: asOptional(asString),
+  spendTargets: asArray(
+    asObject({
+      currencyCode: asOptional(asString),
+      publicAddress: asString,
+      nativeAmount: asOptional(asString, '0')
+    })
+  )
+})
+
+const asCustomToken = asObject({
+  currencyCode: asString,
+  currencyName: asString,
+  multiplier: asString,
+  contractAddress: asString
+})

package/lib/common/types.js

@@ -0,0 +1,85 @@
+
+
+
+
+
+
+
+export const DATA_STORE_FILE = 'txEngineFolder/walletLocalData.json'
+export const TXID_MAP_FILE = 'txEngineFolder/txidMap.json'
+export const TXID_LIST_FILE = 'txEngineFolder/txidList.json'
+export const TRANSACTION_STORE_FILE = 'txEngineFolder/transactionList.json'
+
+
+
+
+
+
+
+
+
+
+
+
+export class WalletLocalData {
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+
+  constructor(jsonString, primaryCurrency) {
+    this.blockHeight = 0
+    const totalBalances = {}
+    this.totalBalances = totalBalances
+    this.lastAddressQueryHeight = 0
+    this.lastTransactionQueryHeight = {}
+    this.lastTransactionDate = {}
+    this.lastCheckedTxsDropped = 0
+    this.numUnconfirmedSpendTxs = 0
+    this.numTransactions = {}
+    this.otherData = {}
+    this.publicKey = ''
+    this.enabledTokens = [primaryCurrency]
+    if (jsonString !== null) {
+      const data = JSON.parse(jsonString)
+
+      if (typeof data.blockHeight === 'number') {
+        this.blockHeight = data.blockHeight
+      }
+      if (typeof data.lastCheckedTxsDropped === 'number') {
+        this.lastCheckedTxsDropped = data.lastCheckedTxsDropped
+      }
+      if (typeof data.numUnconfirmedSpendTxs === 'number') {
+        this.numUnconfirmedSpendTxs = data.numUnconfirmedSpendTxs
+      }
+      if (typeof data.numTransactions === 'object') {
+        this.numTransactions = data.numTransactions
+      }
+      if (typeof data.lastAddressQueryHeight === 'number') {
+        this.lastAddressQueryHeight = data.lastAddressQueryHeight
+      }
+      if (typeof data.publicKey === 'string') this.publicKey = data.publicKey
+      if (typeof data.totalBalances !== 'undefined') {
+        this.totalBalances = data.totalBalances
+      }
+      if (typeof data.enabledTokens !== 'undefined') {
+        this.enabledTokens = data.enabledTokens
+        if (!this.enabledTokens.includes(primaryCurrency)) {
+          this.enabledTokens.push(primaryCurrency)
+        }
+      }
+      if (typeof data.otherData !== 'undefined') this.otherData = data.otherData
+      if (typeof data.lastTransactionQueryHeight === 'object')
+        this.lastTransactionQueryHeight = data.lastTransactionQueryHeight
+      if (typeof data.lastTransactionDate === 'object')
+        this.lastTransactionDate = data.lastTransactionDate
+    }
+  }
+}

package/lib/common/utils.js

@@ -0,0 +1,378 @@
+/**
+ * Created by paul on 8/26/17.
+ * 
+ */
+
+import { bns } from 'biggystring'
+import { Buffer } from 'buffer'
+import { asArray, asObject, asOptional, asString } from 'cleaners'
+
+
+
+
+
+
+import { validate } from 'jsonschema'
+
+function normalizeAddress(address) {
+  return address.toLowerCase().replace('0x', '')
+}
+
+function addHexPrefix(value) {
+  if (value.indexOf('0x') === 0) {
+    return value
+  } else {
+    return '0x' + value
+  }
+}
+
+function shuffleArray(array) {
+  let currentIndex = array.length
+  let temporaryValue, randomIndex
+
+  // While there remain elements to shuffle...
+  while (currentIndex !== 0) {
+    // Pick a remaining element...
+    randomIndex = Math.floor(Math.random() * currentIndex)
+    currentIndex -= 1
+
+    // And swap it with the current element.
+    temporaryValue = array[currentIndex]
+    array[currentIndex] = array[randomIndex]
+    array[randomIndex] = temporaryValue
+  }
+
+  return array
+}
+function validateObject(object, schema) {
+  const result = validate(object, schema)
+
+  if (result.errors.length === 0) {
+    return true
+  } else {
+    for (const n in result.errors) {
+      const errMsg = result.errors[n].message
+      console.log('ERROR: validateObject:' + errMsg)
+    }
+    return false
+  }
+}
+
+export function isEmpty(map) {
+  return Object.keys(map).length !== 0
+}
+
+export function isHex(h) {
+  const out = /^[0-9A-F]+$/i.test(h)
+  return out
+}
+
+export function toHex(num) {
+  return bns.add(num, '0', 16)
+}
+
+export function hexToBuf(hex) {
+  const noHexPrefix = hex.replace('0x', '')
+  const buf = Buffer.from(noHexPrefix, 'hex')
+  return buf
+}
+
+export function padHex(hex, bytes) {
+  if (2 * bytes - hex.length > 0) {
+    return hex.padStart(2 * bytes, '0')
+  }
+  return hex
+}
+
+export function removeHexPrefix(value) {
+  if (value.indexOf('0x') === 0) {
+    return value.substring(2)
+  } else {
+    return value
+  }
+}
+
+export function hexToDecimal(num) {
+  return bns.add(num, '0', 10)
+}
+
+export function bufToHex(buf) {
+  const signedTxBuf = Buffer.from(buf)
+  const hex = '0x' + signedTxBuf.toString('hex')
+  return hex
+}
+
+function getDenomInfo(
+  currencyInfo,
+  denom,
+  customTokens
+) {
+  // Look in the primary currency denoms
+  let edgeDenomination = currencyInfo.denominations.find(element => {
+    return element.name === denom
+  })
+
+  // Look in the currencyInfo tokens
+  if (!edgeDenomination) {
+    for (const metaToken of currencyInfo.metaTokens) {
+      edgeDenomination = metaToken.denominations.find(element => {
+        return element.name === denom
+      })
+      if (edgeDenomination) {
+        break
+      }
+    }
+  }
+
+  // Look in custom tokens
+  if (!edgeDenomination && customTokens) {
+    for (const metaToken of customTokens) {
+      edgeDenomination = metaToken.denominations.find(element => {
+        return element.name === denom
+      })
+      if (edgeDenomination) {
+        break
+      }
+    }
+  }
+  return edgeDenomination
+}
+
+const snoozeReject = (ms) =>
+  new Promise((resolve, reject) => setTimeout(reject, ms))
+const snooze = (ms) =>
+  new Promise((resolve) => setTimeout(resolve, ms))
+
+function promiseAny(promises) {
+  return new Promise((resolve, reject) => {
+    let pending = promises.length
+    for (const promise of promises) {
+      promise.then(
+        value => {
+          resolve(value)
+        },
+        error => {
+          return --pending || reject(error)
+        }
+      )
+    }
+  })
+}
+
+/**
+ * Waits for the promises to resolve and uses a provided checkResult function
+ * to return a key to identify the result. The returned promise resolves when
+ * n number of promises resolve to identical keys.
+ */
+async function promiseNy(
+  promises,
+  checkResult,
+  n = promises.length
+) {
+  const map = {}
+  return new Promise((resolve, reject) => {
+    let resolved = 0
+    let failed = 0
+    let done = false
+    for (const promise of promises) {
+      promise.then(
+        result => {
+          const key = checkResult(result)
+          if (key !== undefined) {
+            resolved++
+            if (map[key] !== undefined) {
+              map[key]++
+            } else {
+              map[key] = 1
+            }
+            if (!done && map[key] >= n) {
+              done = true
+              resolve(result)
+            }
+          } else if (++failed + resolved === promises.length) {
+            reject(Error('Could not resolve n promises'))
+          }
+        },
+        error => {
+          if (++failed + resolved === promises.length) {
+            reject(error)
+          }
+        }
+      )
+    }
+  })
+}
+
+/**
+ * If the promise doesn't resolve in the given time,
+ * reject it with the provided error, or a generic error if none is provided.
+ */
+function timeout(
+  promise,
+  ms,
+  error = new Error(`Timeout of ${ms}ms exceeded`)
+) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(error), ms)
+    promise.then(
+      ok => {
+        resolve(ok)
+        clearTimeout(timer)
+      },
+      error => {
+        reject(error)
+        clearTimeout(timer)
+      }
+    )
+  })
+}
+
+
+
+async function asyncWaterfall(
+  asyncFuncs,
+  timeoutMs = 5000
+) {
+  let pending = asyncFuncs.length
+  const promises = []
+  for (const func of asyncFuncs) {
+    const index = promises.length
+    promises.push(
+      func().catch(e => {
+        e.index = index
+        throw e
+      })
+    )
+    if (pending > 1) {
+      promises.push(
+        new Promise(resolve => {
+          snooze(timeoutMs).then(() => {
+            resolve('async_waterfall_timed_out')
+          })
+        })
+      )
+    }
+    try {
+      const result = await Promise.race(promises)
+      if (result === 'async_waterfall_timed_out') {
+        promises.pop()
+        --pending
+      } else {
+        return result
+      }
+    } catch (e) {
+      const i = e.index
+      promises.splice(i, 1)
+      promises.pop()
+      --pending
+      if (!pending) {
+        throw e
+      }
+    }
+  }
+}
+
+export function pickRandom(list, count) {
+  if (list.length <= count) return list
+
+  // Algorithm from https://stackoverflow.com/a/48089/1836596
+  const out = []
+  for (let i = 0; i < list.length && out.length < count; ++i) {
+    const probability = (count - out.length) / (list.length - i)
+    if (Math.random() <= probability) out.push(list[i])
+  }
+  return out
+}
+
+function getEdgeInfoServer() {
+  return 'https://info1.edgesecure.co:8444'
+}
+
+/**
+ * Safely read `otherParams` from a transaction, throwing if it's missing.
+ */
+export function getOtherParams(tx) {
+  if (tx.otherParams == null) {
+    throw new TypeError('Transaction is missing otherParams')
+  }
+  return tx.otherParams
+}
+
+
+/**
+ * Constructs a mutex.
+ *
+ * The mutex is a function that accepts & runs a callback,
+ * ensuring that only one callback runs at a time. Use it like:
+ *
+ * const result = await mutex(() => {
+ *   // Critical code that must not run more than one copy.
+ *   return result
+ * })
+ */
+export function makeMutex() {
+  let busy = false
+  const queue = []
+  return async function lock(callback) {
+    if (busy) await new Promise(resolve => queue.push(resolve))
+    try {
+      busy = true
+      return callback()
+    } finally {
+      busy = false
+      const resolve = queue.shift()
+      if (resolve != null) resolve()
+    }
+  }
+}
+
+const asCleanTxLogs = asObject({
+  txid: asString,
+  spendTargets: asOptional(
+    asArray(
+      asObject({
+        currencyCode: asString,
+        nativeAmount: asString,
+        publicAddress: asString,
+        uniqueIdentifier: asOptional(asString)
+      })
+    )
+  ),
+  signedTx: asString,
+  otherParams: asOptional(
+    asObject({
+      gas: asOptional(asString),
+      gasPrice: asOptional(asString),
+      nonceUsed: asOptional(asString)
+    })
+  )
+})
+
+export function cleanTxLogs(tx) {
+  return JSON.stringify(asCleanTxLogs(tx), null, 2)
+}
+
+// Convert number strings in scientific notation to decimal notation using biggystring
+export function biggyScience(num) {
+  const [factor, exponent] = num.split('e')
+
+  // exit early if the number is not in scientific notation
+  if (exponent == null) return num
+
+  return bns.mul(factor, '1' + '0'.repeat(parseInt(exponent))).toString()
+}
+
+export {
+  normalizeAddress,
+  addHexPrefix,
+  validateObject,
+  getDenomInfo,
+  asyncWaterfall,
+  snooze,
+  shuffleArray,
+  snoozeReject,
+  getEdgeInfoServer,
+  promiseAny,
+  promiseNy,
+  timeout
+}