edge-currency-accountbased 0.7.72

package/lib/eos/eosInfo.js

@@ -0,0 +1,98 @@
+
+
+
+
+
+
+
+
+
+
+
+import { makeEosBasedPluginInner } from './eosPlugin'
+
+
+const GREYMASS_FUEL_ACTION = {
+  authorization: [
+    {
+      actor: 'greymassfuel',
+      permission: 'cosign'
+    }
+  ],
+  account: 'greymassnoop',
+  name: 'noop',
+  data: {}
+}
+
+// ----EOSIO MAIN NET----
+export const eosJsConfig = {
+  chainId: 'aca376f206b8fc25a6ed44dbdc66547c36c6c33e3a119ffbeaef943642f0e906', // eosio main net
+  keyProvider: [],
+  httpEndpoint: '', // main net
+  fetch: fetch,
+  verbose: false // verbose logging such as API activity
+}
+
+const denominations = [
+  // An array of Objects of the possible denominations for this currency
+  {
+    name: 'EOS',
+    multiplier: '10000',
+    symbol: 'E'
+  }
+]
+
+const otherSettings = {
+  eosActivationServers: ['https://eospay.edge.app'],
+  eosHyperionNodes: ['https://api.eossweden.org'],
+  eosNodes: [
+    'https://api.eoseoul.io',
+    'https://api.eoslaomao.com',
+    'https://mainnet.eoscannon.io',
+    'https://api.eos.wiki',
+    'https://mainnet.eosio.sg',
+    'https://eos.newdex.one',
+    'https://api.bitmars.one',
+    'https://node1.zbeos.com',
+    'https://api.eosn.io'
+  ],
+  eosFuelServers: ['https://eos.greymass.com'],
+  eosDfuseServers: ['https://eos.dfuse.eosnation.io'],
+  uriProtocol: 'eos',
+  fuelActions: [GREYMASS_FUEL_ACTION]
+}
+
+const defaultSettings = {
+  otherSettings
+}
+
+export const eosCurrencyInfo = {
+  // Basic currency information:
+  currencyCode: 'EOS',
+  displayName: 'EOS',
+  pluginId: 'eos',
+  pluginName: 'eos',
+  walletType: 'wallet:eos',
+
+  defaultSettings,
+
+  addressExplorer: 'https://bloks.io/account/%s',
+  transactionExplorer: 'https://bloks.io/transaction/%s',
+
+  denominations,
+  metaTokens: [
+    {
+      name: 'EOS',
+      currencyName: 'EOS',
+      multiplier: '10000',
+      symbol: 'E',
+      currencyCode: 'EOS',
+      contractAddress: 'eosio.token',
+      denominations
+    }
+  ]
+}
+
+export const makeEosPlugin = (opts) => {
+  return makeEosBasedPluginInner(opts, eosCurrencyInfo, eosJsConfig)
+}

package/lib/eos/eosPlugin.js

@@ -0,0 +1,314 @@
+/**
+ * Created by paul on 8/8/17.
+ */
+/* global */
+// 
+
+import { bns } from 'biggystring'
+
+
+
+
+
+
+
+
+
+
+
+
+import EosApi from 'eosjs-api'
+import ecc from 'eosjs-ecc'
+
+import { CurrencyPlugin } from '../common/plugin.js'
+import { asyncWaterfall, getDenomInfo } from '../common/utils.js'
+import { getFetchCors } from '../react-native-io.js'
+import { EosEngine } from './eosEngine'
+import {
+  asGetActivationCost,
+  asGetActivationSupportedCurrencies
+} from './eosSchema.js'
+
+
+const validCharacters = '12345abcdefghijklmnopqrstuvwxyz.'
+
+export function checkAddress(address) {
+  // TODO: Check for a valid address format. The passed in
+  // address would be a use visible displayed address such as what would
+  // go into a QR code
+
+  for (let i = 0; i < address.length; i++) {
+    const c = address.charAt(i)
+    if (!validCharacters.includes(c)) {
+      return false
+    }
+  }
+  return true
+}
+
+export class EosPlugin extends CurrencyPlugin {
+  
+  
+
+  constructor(
+    io,
+    fetchCors,
+    currencyInfo,
+    eosJsConfig
+  ) {
+    super(io, currencyInfo.pluginId, currencyInfo)
+
+    eosJsConfig.httpEndpoint =
+      this.currencyInfo.defaultSettings.otherSettings.eosNodes[0]
+    eosJsConfig.fetch = fetchCors
+    this.eosServer = EosApi(eosJsConfig)
+  }
+
+  async importPrivateKey(privateKey) {
+    const strippedPrivateKey = privateKey.replace(/ /g, '') // should be in WIF format
+    if (strippedPrivateKey.length !== 51) {
+      throw new Error('Private key wrong length')
+    }
+    if (!ecc.isValidPrivate(strippedPrivateKey)) {
+      throw new Error('Invalid private key')
+    }
+    return {
+      // best practice not to import owner key, only active
+      // note that signing is done by active key (eosKey, not eosOwnerKey)
+      eosKey: strippedPrivateKey // active private key
+    }
+  }
+
+  async createPrivateKey(walletType) {
+    const type = walletType.replace('wallet:', '')
+
+    const currencyInfoType = this.currencyInfo.walletType.replace('wallet:', '')
+    if (type === currencyInfoType) {
+      // TODO: User currency library to create private key as a string
+      // Use io.random() for random number generation
+      // Multiple keys can be created and stored here. ie. If there is both a mnemonic and key format,
+      // Generate and store them here by returning an arbitrary object with them.
+      let entropy = Buffer.from(this.io.random(32)).toString('hex')
+      const eosOwnerKey = ecc.seedPrivate(entropy) // returns WIF format
+      entropy = Buffer.from(this.io.random(32)).toString('hex')
+      const eosKey = ecc.seedPrivate(entropy)
+      return { eosOwnerKey, eosKey }
+    } else {
+      throw new Error('InvalidWalletType')
+    }
+  }
+
+  async derivePublicKey(walletInfo) {
+    const type = walletInfo.type.replace('wallet:', '')
+    const currencyInfoType = this.currencyInfo.walletType.replace('wallet:', '')
+    if (type === currencyInfoType) {
+      // TODO: User currency library to derive the public keys/addresses from the private key.
+      // Multiple keys can be generated and stored if needed. Do not store an HD chain
+      // but rather just different versions of the master public key
+      // const publicKey = derivePubkey(walletInfo.keys.eosKey)
+      // const publicKey = deriveAddress(walletInfo.keys.eosKey)
+      const publicKey = ecc.privateToPublic(walletInfo.keys.eosKey)
+      let ownerPublicKey
+      // usage of eosOwnerKey must be protected by conditional
+      // checking for its existence
+      if (walletInfo.keys.eosOwnerKey) {
+        ownerPublicKey = ecc.privateToPublic(walletInfo.keys.eosOwnerKey)
+      }
+      return { publicKey, ownerPublicKey }
+    } else {
+      throw new Error('InvalidWalletType')
+    }
+  }
+
+  async parseUri(uri) {
+    const { edgeParsedUri } = this.parseUriCommon(this.currencyInfo, uri, {
+      [this.currencyInfo.defaultSettings.otherSettings.uriProtocol]: true
+    })
+
+    const valid = checkAddress(edgeParsedUri.publicAddress || '')
+    if (!valid) {
+      throw new Error('InvalidPublicAddressError')
+    }
+    return edgeParsedUri
+  }
+
+  async encodeUri(obj) {
+    const valid = checkAddress(obj.publicAddress)
+    if (!valid) {
+      throw new Error('InvalidPublicAddressError')
+    }
+    let amount
+    if (typeof obj.nativeAmount === 'string') {
+      const currencyCode = this.currencyInfo.currencyCode
+      const nativeAmount = obj.nativeAmount
+      const denom = getDenomInfo(this.currencyInfo, currencyCode)
+      if (!denom) {
+        throw new Error('InternalErrorInvalidCurrencyCode')
+      }
+      amount = bns.div(nativeAmount, denom.multiplier, 4)
+    }
+    const encodedUri = this.encodeUriCommon(
+      obj,
+      this.currencyInfo.defaultSettings.otherSettings.uriProtocol,
+      amount
+    )
+    return encodedUri
+  }
+
+  // change to fetch call in the future
+  async getAccSystemStats(account) {
+    return new Promise((resolve, reject) => {
+      this.eosServer.getAccount(account, (error, result) => {
+        if (error) {
+          if (error.message.includes('unknown key')) {
+            error.code = 'ErrorUnknownAccount'
+          }
+          reject(error)
+        }
+        resolve(result)
+      })
+    })
+  }
+}
+
+export function makeEosBasedPluginInner(
+  opts,
+  currencyInfo,
+  eosJsConfig
+) {
+  const { io, log } = opts
+  const fetch = getFetchCors(opts)
+
+  let toolsPromise
+  function makeCurrencyTools() {
+    if (toolsPromise != null) return toolsPromise
+    toolsPromise = Promise.resolve(
+      new EosPlugin(io, fetch, currencyInfo, eosJsConfig)
+    )
+    return toolsPromise
+  }
+
+  async function makeCurrencyEngine(
+    walletInfo,
+    opts
+  ) {
+    const tools = await makeCurrencyTools()
+    const currencyEngine = new EosEngine(
+      tools,
+      walletInfo,
+      opts,
+      fetch,
+      eosJsConfig
+    )
+    await currencyEngine.loadEngine(tools, walletInfo, opts)
+
+    currencyEngine.otherData = currencyEngine.walletLocalData.otherData
+    // currencyEngine.otherData is an opaque utility object for use for currency
+    // specific data that will be persisted to disk on this one device.
+    // Commonly stored data would be last queried block height or nonce values for accounts
+    // Edit the flow type EosWalletOtherData and initialize those values here if they are
+    // undefined
+    // TODO: Initialize anything specific to this currency
+    // if (!currencyEngine.otherData.nonce) currencyEngine.otherData.nonce = 0
+    if (!currencyEngine.otherData.accountName) {
+      currencyEngine.otherData.accountName = ''
+    }
+    if (!currencyEngine.otherData.lastQueryActionSeq) {
+      currencyEngine.otherData.lastQueryActionSeq = {}
+    }
+    if (!currencyEngine.otherData.highestTxHeight) {
+      currencyEngine.otherData.highestTxHeight = {}
+    }
+
+    const out = currencyEngine
+    return out
+  }
+
+  const otherMethods = {
+    getActivationSupportedCurrencies: async () => {
+      try {
+        const out = await asyncWaterfall(
+          currencyInfo.defaultSettings.otherSettings.eosActivationServers.map(
+            server => async () => {
+              const uri = `${server}/api/v1/getSupportedCurrencies`
+              const response = await fetch(uri)
+              const result = await response.json()
+              return {
+                result
+              }
+            }
+          )
+        )
+        return asGetActivationSupportedCurrencies(out)
+      } catch (e) {
+        log.error('UnableToGetSupportedCurrencies error: ', e)
+        throw new Error('UnableToGetSupportedCurrencies')
+      }
+    },
+    getActivationCost: async (currencyCode) => {
+      try {
+        const out = await asyncWaterfall(
+          currencyInfo.defaultSettings.otherSettings.eosActivationServers.map(
+            server => async () => {
+              const uri = `${server}/api/v1/eosPrices/${currencyCode}`
+              const response = await fetch(uri)
+              const prices = asGetActivationCost(await response.json())
+              const startingResourcesUri = `${server}/api/v1/startingResources/${currencyCode}`
+              const startingResourcesResponse = await fetch(
+                startingResourcesUri
+              )
+              const startingResources = asGetActivationCost(
+                await startingResourcesResponse.json()
+              )
+              const totalEos =
+                Number(prices.ram) * startingResources.ram +
+                Number(prices.net) * startingResources.net +
+                Number(prices.cpu) * startingResources.cpu
+              const totalEosString = totalEos.toString()
+              const price = bns.toFixed(totalEosString, 0, 4)
+              return price
+            }
+          )
+        )
+        return out
+      } catch (e) {
+        log.error('ErrorUnableToGetCost: ', e)
+        throw new Error('ErrorUnableToGetCost')
+      }
+    },
+    validateAccount: async (account) => {
+      const valid = checkAddress(account) && account.length === 12
+      const out = { result: '' }
+      if (!valid) {
+        const e = new Error('ErrorInvalidAccountName')
+        e.name = 'ErrorInvalidAccountName'
+        throw e
+      }
+      try {
+        const tools = await makeCurrencyTools()
+        const result = await tools.getAccSystemStats(account)
+        if (result) {
+          const e = new Error('ErrorAccountUnavailable')
+          e.name = 'ErrorAccountUnavailable'
+          throw e
+        }
+        throw new Error('ErrorUnknownError')
+      } catch (e) {
+        if (e.code === 'ErrorUnknownAccount') {
+          out.result = 'AccountAvailable'
+        } else {
+          throw e
+        }
+      }
+      log.warn(`validateAccount: result=${out.result}`)
+      return out
+    }
+  }
+
+  return {
+    currencyInfo,
+    makeCurrencyEngine,
+    makeCurrencyTools,
+    otherMethods
+  }
+}

package/lib/eos/eosSchema.js

@@ -0,0 +1,190 @@
+/**
+ * Created by paul on 8/27/17.
+ */
+
+import {
+  asArray,
+  asBoolean,
+  asMap,
+  asNumber,
+  asObject,
+  asOptional,
+  asString
+} from 'cleaners'
+
+export const asGetAccountActivationQuote = asObject({
+  amount: asString,
+  currencyCode: asString,
+  expireTime: asNumber,
+  paymentAddress: asString
+})
+
+export const asGetActivationSupportedCurrencies = asObject({
+  result: asMap(asBoolean)
+})
+
+export const asGetActivationCost = asObject({
+  cpu: asNumber,
+  net: asNumber,
+  ram: asNumber
+})
+
+export const asHyperionTransaction = asObject({
+  trx_id: asString,
+  '@timestamp': asString,
+  block_num: asNumber,
+  act: asObject({
+    authorization: asOptional(
+      asArray(
+        asObject({
+          actor: asString,
+          permission: asString
+        })
+      )
+    ),
+    data: asObject({
+      from: asString,
+      to: asString,
+      amount: asNumber,
+      symbol: asString,
+      memo: asString
+    })
+  })
+})
+
+export const asHyperionGetTransactionResponse = asObject({
+  actions: asArray(asHyperionTransaction)
+})
+
+export const asDfuseGetKeyAccountsResponse = asObject({
+  account_names: asArray(asString)
+})
+
+export const asDfuseTransaction = asObject({
+  trace: asObject({
+    block: asObject({
+      num: asNumber,
+      timestamp: asString
+    }),
+    id: asString,
+    matchingActions: asArray(
+      asObject({
+        json: asObject({
+          from: asString,
+          memo: asString,
+          quantity: asString,
+          to: asString
+        }),
+        authorization: asArray(
+          asObject({
+            actor: asString,
+            permission: asString
+          })
+        )
+      })
+    )
+  })
+})
+
+export const asDfuseGetTransactionsResponse = asObject({
+  data: asObject({
+    searchTransactionsBackward: asObject({
+      results: asArray(asDfuseTransaction)
+    })
+  })
+})
+
+export const asDfuseGetTransactionsErrorResponse = asObject({
+  errors: asArray(
+    asObject({
+      message: asString,
+      extensions: asObject({
+        code: asString,
+        terminal: asBoolean
+      })
+    })
+  )
+})
+
+export const dfuseGetTransactionsQueryString = `
+query ($query: String!, $limit: Int64, $low: Int64, $high: Int64) {
+  searchTransactionsBackward(query: $query, lowBlockNum: $low, highBlockNum: $high, limit: $limit) {
+    results {
+      trace {
+        block {
+          num
+          timestamp
+        }
+        id
+        matchingActions {
+          json
+        }
+      }
+    }
+  }
+}
+`
+
+// export const EosGetBalancesSchema = {
+//   type: 'array',
+//   items: {
+//     type: 'object',
+//     properties: {
+//       currency: { type: 'string' },
+//       value: { type: 'string' }
+//     }
+//   }
+// }
+
+// note that transfers are regular EOS transactions
+export const EosTransactionSuperNodeSchema = {
+  type: 'object',
+  properties: {
+    act: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          properties: {
+            from: { type: 'string' },
+            to: { type: 'string' },
+            amount: { type: 'number' },
+            symbol: { type: 'string' },
+            memo: { type: 'string' }
+          },
+          required: ['from', 'to', 'amount'],
+          authorization: { type: 'object' }
+        }
+      },
+      required: ['data']
+    },
+    trx_id: { type: 'string' },
+    '@timestamp': { type: 'string' },
+    block_num: { type: 'number' },
+    required: ['act', 'trx_id', '@timestamp', 'block_num']
+  }
+}
+
+// export const EosGetTransactionsSchema = {
+//   type: 'array',
+//   items: {
+//     type: 'object',
+//     properties: {
+//       type: { type: 'string' },
+//       address: { type: 'string' },
+//       id: { type: 'string' },
+//       outcome: {
+//         type: 'object',
+//         properties: {
+//           result: { type: 'string' },
+//           timestamp: { type: 'string' },
+//           fee: { type: 'string' },
+//           ledgerVersion: { type: 'number' },
+//           balanceChanges: {
+//             type: 'object'
+//           }
+//         }
+//       }
+//     }
+//   }
+// }

package/lib/eos/eosTypes.js

@@ -0,0 +1,88 @@
+/**
+ * Created by paul on 8/26/17.
+ */
+// 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+