edge-currency-accountbased 0.7.72

package/lib/fio/fioError.js

@@ -0,0 +1,38 @@
+// 
+
+import { currencyInfo } from './fioInfo.js'
+
+export const fioApiErrorCodes = [400, 403, 404]
+export const fioRegApiErrorCodes = {
+  INVALID_FIO_NAME: currencyInfo.defaultSettings.errorCodes.INVALID_FIO_ADDRESS,
+  ALREADY_REGISTERED:
+    currencyInfo.defaultSettings.errorCodes.ALREADY_REGISTERED,
+  DOMAIN_IS_NOT_REGISTERED:
+    currencyInfo.defaultSettings.errorCodes.FIO_DOMAIN_IS_NOT_EXIST,
+  DOMAIN_IS_NOT_PUBLIC:
+    currencyInfo.defaultSettings.errorCodes.FIO_DOMAIN_IS_NOT_PUBLIC,
+  SERVER_ERROR: currencyInfo.defaultSettings.errorCodes.SERVER_ERROR,
+  ALREADY_SENT_REGISTRATION_REQ_FOR_DOMAIN:
+    currencyInfo.defaultSettings.errorCodes
+      .ALREADY_SENT_REGISTRATION_REQ_FOR_DOMAIN
+}
+
+export class FioError extends Error {
+  
+  
+  
+  
+
+  constructor(message, code, labelCode, json) {
+    super(message)
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, FioError)
+    }
+
+    this.name = 'FioError'
+    if (code) this.errorCode = code
+    if (labelCode) this.labelCode = labelCode
+    if (json) this.json = json
+  }
+}

package/lib/fio/fioInfo.js

@@ -0,0 +1,72 @@
+
+
+
+
+
+const defaultSettings = {
+  apiUrls: [
+    'https://fio.eu.eosamsterdam.net/v1/',
+    'https://fio.eosdac.io/v1/',
+    'https://fio.eosphere.io/v1/',
+    'https://fio.eosrio.io/v1/',
+    'https://fio.acherontrading.com/v1/',
+    'https://fio.eos.barcelona/v1/',
+    'https://api.fio.eosdetroit.io/v1/',
+    'https://fio.zenblocks.io/v1/',
+    'https://api.fio.alohaeos.com/v1/',
+    'https://fio.greymass.com/v1/',
+    'https://fio.eosusa.news/v1/',
+    'https://fio.eosargentina.io/v1/',
+    'https://fio.cryptolions.io/v1/',
+    'https://fio-mainnet.eosblocksmith.io/v1/',
+    'https://api.fio.currencyhub.io/v1/',
+    'https://fio.eoscannon.io/v1/',
+    'https://fio.eosdublin.io/v1/',
+    'https://api.fiosweden.org/v1/'
+  ],
+  historyNodeUrls: [
+    'https://fio.greymass.com/v1/',
+    'https://fio.greymass.com/v1/',
+    'https://fio.eosphere.io/v1/',
+    'https://fio.eossweden.org/v1/'
+  ],
+  fioRegApiUrl: 'https://reg.fioprotocol.io/public-api/',
+  fioDomainRegUrl: 'https://reg.fioprotocol.io/domain/',
+  fioAddressRegUrl: 'https://reg.fioprotocol.io/address/',
+  defaultRef: 'edge',
+  fallbackRef: 'edge',
+  freeAddressRef: 'edgefree',
+  errorCodes: {
+    INVALID_FIO_ADDRESS: 'INVALID_FIO_ADDRESS',
+    ALREADY_REGISTERED: 'ALREADY_REGISTERED',
+    FIO_ADDRESS_IS_NOT_EXIST: 'FIO_ADDRESS_IS_NOT_EXIST',
+    FIO_DOMAIN_IS_NOT_EXIST: 'FIO_DOMAIN_IS_NOT_EXIST',
+    FIO_DOMAIN_IS_NOT_PUBLIC: 'FIO_DOMAIN_IS_NOT_PUBLIC',
+    IS_DOMAIN_PUBLIC_ERROR: 'IS_DOMAIN_PUBLIC_ERROR',
+    FIO_ADDRESS_IS_NOT_LINKED: 'FIO_ADDRESS_IS_NOT_LINKED',
+    SERVER_ERROR: 'SERVER_ERROR'
+  }
+}
+
+export const currencyInfo = {
+  // Basic currency information:
+  currencyCode: 'FIO',
+  displayName: 'FIO',
+  pluginId: 'fio',
+  walletType: 'wallet:fio',
+
+  defaultSettings,
+
+  addressExplorer: 'https://fio.bloks.io/key/%s',
+  transactionExplorer: 'https://fio.bloks.io/transaction/%s',
+
+  denominations: [
+    // An array of Objects of the possible denominations for this currency
+    {
+      name: 'FIO',
+      multiplier: '1000000000',
+      symbol: 'ᵮ'
+    }
+  ],
+  metaTokens: []
+}

package/lib/fio/fioPlugin.js

@@ -0,0 +1,486 @@
+// 
+
+import { FIOSDK } from '@fioprotocol/fiosdk'
+import { Transactions } from '@fioprotocol/fiosdk/lib/transactions/Transactions'
+import { bns } from 'biggystring'
+import { validateMnemonic } from 'bip39'
+
+
+
+
+
+
+
+
+
+
+import ecc from 'eosjs-ecc'
+
+import { CurrencyPlugin } from '../common/plugin.js'
+import { asyncWaterfall, getDenomInfo, shuffleArray } from '../common/utils'
+import { FIO_REG_API_ENDPOINTS } from './fioConst.js'
+import { FioEngine } from './fioEngine'
+import { fioApiErrorCodes, FioError, fioRegApiErrorCodes } from './fioError.js'
+import { currencyInfo } from './fioInfo.js'
+
+const FIO_CURRENCY_CODE = 'FIO'
+const FIO_TYPE = 'fio'
+const FIO_REG_SITE_API_KEY = ''
+
+
+
+export function checkAddress(address) {
+  const start = address.startsWith(FIO_CURRENCY_CODE)
+  const length = address.length === 53
+  return start && length
+}
+
+export class FioPlugin extends CurrencyPlugin {
+  
+
+  constructor(io) {
+    super(io, FIO_TYPE, currencyInfo)
+  }
+
+  async importPrivateKey(userInput) {
+    const { pluginId } = this.currencyInfo
+    const keys = {}
+    if (/[0-9a-zA-Z]{51}$/.test(userInput)) {
+      if (!ecc.isValidPrivate(userInput)) {
+        throw new Error('Invalid private key')
+      }
+
+      keys.fioKey = userInput
+    } else {
+      // it looks like a mnemonic, so validate that way:
+      if (!validateMnemonic(userInput)) {
+        // "input" instead of "mnemonic" in case private key
+        // was just the wrong length
+        throw new Error('Invalid input')
+      }
+      const privKeys = await FIOSDK.createPrivateKeyMnemonic(userInput)
+      keys.fioKey = privKeys.fioKey
+      keys.mnemonic = privKeys.mnemonic
+    }
+
+    // Validate the address derivation:
+    const pubKeys = await this.derivePublicKey({
+      type: `wallet:${pluginId}`,
+      id: 'fake',
+      keys
+    })
+    keys.publicKey = pubKeys.publicKey
+
+    return keys
+  }
+
+  async createPrivateKey(walletType) {
+    const type = walletType.replace('wallet:', '')
+    if (type === FIO_TYPE) {
+      const buffer = this.io.random(32)
+      return FIOSDK.createPrivateKey(buffer)
+    } else {
+      throw new Error('InvalidWalletType')
+    }
+  }
+
+  async derivePublicKey(walletInfo) {
+    const type = walletInfo.type.replace('wallet:', '')
+    if (type === FIO_TYPE) {
+      return FIOSDK.derivedPublicKey(walletInfo.keys.fioKey)
+    } else {
+      throw new Error('InvalidWalletType')
+    }
+  }
+
+  async parseUri(uri) {
+    const { edgeParsedUri } = this.parseUriCommon(
+      currencyInfo,
+      uri,
+      {
+        fio: true
+      },
+      FIO_CURRENCY_CODE
+    )
+    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 = FIO_CURRENCY_CODE
+      const nativeAmount = obj.nativeAmount
+      const denom = getDenomInfo(currencyInfo, currencyCode)
+      if (!denom) {
+        throw new Error('InternalErrorInvalidCurrencyCode')
+      }
+      amount = bns.div(nativeAmount, denom.multiplier, 16)
+    }
+    const encodedUri = this.encodeUriCommon(obj, FIO_TYPE, amount)
+    return encodedUri
+  }
+}
+
+export function makeFioPlugin(opts) {
+  const { initOptions, io } = opts
+  const { fetchCors = io.fetch } = io
+  const { tpid = 'finance@edge', fioRegApiToken = FIO_REG_SITE_API_KEY } =
+    initOptions
+  const connection = new FIOSDK('', '', '', fetchCors, undefined, tpid)
+
+  let toolsPromise
+  function makeCurrencyTools() {
+    if (toolsPromise != null) return toolsPromise
+    toolsPromise = Promise.resolve(new FioPlugin(io))
+    return toolsPromise
+  }
+
+  async function multicastServers(
+    actionName,
+    params
+  ) {
+    const res = await asyncWaterfall(
+      shuffleArray(
+        currencyInfo.defaultSettings.apiUrls.map(apiUrl => async () => {
+          let out
+
+          Transactions.baseUrl = apiUrl
+
+          try {
+            out = await connection.genericAction(actionName, params)
+          } catch (e) {
+            // handle FIO API error
+            if (e.errorCode && fioApiErrorCodes.indexOf(e.errorCode) > -1) {
+              out = {
+                isError: true,
+                data: {
+                  code: e.errorCode,
+                  message: e.message,
+                  json: e.json,
+                  list: e.list
+                }
+              }
+            } else {
+              throw e
+            }
+          }
+
+          return out
+        })
+      )
+    )
+
+    if (res.isError) {
+      const error = new FioError(res.errorMessage)
+      error.json = res.data.json
+      error.list = res.data.list
+      error.errorCode = res.data.code
+
+      throw error
+    }
+
+    return res
+  }
+
+  async function makeCurrencyEngine(
+    walletInfo,
+    opts
+  ) {
+    const tools = await makeCurrencyTools()
+    const currencyEngine = new FioEngine(
+      tools,
+      walletInfo,
+      opts,
+      fetchCors,
+      tpid
+    )
+    await currencyEngine.loadEngine(tools, walletInfo, opts)
+
+    // This is just to make sure otherData is Flow type checked
+    currencyEngine.otherData = currencyEngine.walletLocalData.otherData
+
+    // Initialize otherData defaults if they weren't on disk
+    if (!currencyEngine.otherData.highestTxHeight) {
+      currencyEngine.otherData.highestTxHeight = 0
+    }
+    if (!currencyEngine.otherData.fioAddresses) {
+      currencyEngine.otherData.fioAddresses = []
+    }
+    if (!currencyEngine.otherData.fioDomains) {
+      currencyEngine.otherData.fioDomains = []
+    }
+    if (!currencyEngine.otherData.fioRequestsToApprove) {
+      currencyEngine.otherData.fioRequestsToApprove = {}
+    }
+
+    const out = currencyEngine
+    return out
+  }
+
+  const otherMethods = {
+    async getConnectedPublicAddress(
+      fioAddress,
+      chainCode,
+      tokenCode
+    ) {
+      try {
+        FIOSDK.isFioAddressValid(fioAddress)
+      } catch (e) {
+        throw new FioError(
+          '',
+          400,
+          currencyInfo.defaultSettings.errorCodes.INVALID_FIO_ADDRESS
+        )
+      }
+      try {
+        const isAvailableRes = await multicastServers('isAvailable', {
+          fioName: fioAddress
+        })
+        if (!isAvailableRes.is_registered) {
+          throw new FioError(
+            '',
+            404,
+            currencyInfo.defaultSettings.errorCodes.FIO_ADDRESS_IS_NOT_EXIST
+          )
+        }
+      } catch (e) {
+        if (
+          e.name === 'FioError' &&
+          e.json &&
+          e.json.fields &&
+          e.errorCode === 400
+        ) {
+          e.labelCode =
+            currencyInfo.defaultSettings.errorCodes.INVALID_FIO_ADDRESS
+        }
+
+        throw e
+      }
+      try {
+        const result = await multicastServers('getPublicAddress', {
+          fioAddress,
+          chainCode,
+          tokenCode
+        })
+        if (!result.public_address || result.public_address === '0') {
+          throw new FioError(
+            '',
+            404,
+            currencyInfo.defaultSettings.errorCodes.FIO_ADDRESS_IS_NOT_LINKED
+          )
+        }
+        return result
+      } catch (e) {
+        if (
+          (e.name === 'FioError' &&
+            e.labelCode ===
+              currencyInfo.defaultSettings.errorCodes
+                .FIO_ADDRESS_IS_NOT_LINKED) ||
+          e.errorCode === 404
+        ) {
+          throw new FioError(
+            '',
+            404,
+            currencyInfo.defaultSettings.errorCodes.FIO_ADDRESS_IS_NOT_LINKED
+          )
+        }
+        throw e
+      }
+    },
+    async isFioAddressValid(fioAddress) {
+      try {
+        return FIOSDK.isFioAddressValid(fioAddress)
+      } catch (e) {
+        return false
+      }
+    },
+    async validateAccount(
+      fioName,
+      isDomain = false
+    ) {
+      try {
+        if (isDomain) {
+          if (!FIOSDK.isFioDomainValid(fioName)) return false
+        } else {
+          if (!FIOSDK.isFioAddressValid(fioName)) return false
+        }
+      } catch (e) {
+        throw new FioError(
+          '',
+          400,
+          currencyInfo.defaultSettings.errorCodes.INVALID_FIO_ADDRESS
+        )
+      }
+      try {
+        const isAvailableRes = await multicastServers('isAvailable', {
+          fioName
+        })
+
+        return !isAvailableRes.is_registered
+      } catch (e) {
+        if (
+          e.name === 'FioError' &&
+          e.json &&
+          e.json.fields &&
+          e.errorCode === 400
+        ) {
+          e.labelCode =
+            currencyInfo.defaultSettings.errorCodes.INVALID_FIO_ADDRESS
+        }
+
+        throw e
+      }
+    },
+    async isDomainPublic(domain) {
+      const isAvailableRes = await multicastServers('isAvailable', {
+        fioName: domain
+      })
+      if (!isAvailableRes.is_registered)
+        throw new FioError(
+          '',
+          400,
+          currencyInfo.defaultSettings.errorCodes.FIO_DOMAIN_IS_NOT_EXIST
+        )
+      const result = await fetchCors(
+        `${currencyInfo.defaultSettings.fioRegApiUrl}${FIO_REG_API_ENDPOINTS.isDomainPublic}/${domain}`,
+        {
+          method: 'GET'
+        }
+      )
+      if (!result.ok) {
+        const data = await result.json()
+        throw new FioError(
+          '',
+          result.status,
+          currencyInfo.defaultSettings.errorCodes.IS_DOMAIN_PUBLIC_ERROR,
+          data
+        )
+      }
+      const { isPublic } = await result.json()
+      return isPublic
+    },
+    async doesAccountExist(fioName) {
+      try {
+        if (!FIOSDK.isFioAddressValid(fioName)) return false
+      } catch (e) {
+        return false
+      }
+      try {
+        const isAvailableRes = await multicastServers('isAvailable', {
+          fioName
+        })
+
+        return isAvailableRes.is_registered
+      } catch (e) {
+        this.log.error('doesAccountExist error: ' + e)
+        return false
+      }
+    },
+    async buyAddressRequest(
+      options
+
+
+
+
+,
+      isFree = false
+    ) {
+      const headers = {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+      if (isFree) {
+        options.apiToken = fioRegApiToken
+      }
+      try {
+        const result = await fetchCors(
+          `${currencyInfo.defaultSettings.fioRegApiUrl}${FIO_REG_API_ENDPOINTS.buyAddress}`,
+          {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(options)
+          }
+        )
+        if (!result.ok) {
+          const data = await result.json()
+
+          if (fioRegApiErrorCodes[data.errorCode]) {
+            throw new FioError(
+              data.error,
+              result.status,
+              fioRegApiErrorCodes[data.errorCode],
+              data
+            )
+          }
+
+          if (data.error === 'Already registered') {
+            throw new FioError(
+              data.error,
+              result.status,
+              fioRegApiErrorCodes.ALREADY_REGISTERED,
+              data
+            )
+          }
+
+          throw new Error(data.error)
+        }
+        return result.json()
+      } catch (e) {
+        if (e.labelCode) throw e
+        throw new FioError(
+          e.message,
+          500,
+          currencyInfo.defaultSettings.errorCodes.SERVER_ERROR
+        )
+      }
+    },
+    async getDomains(ref = '') {
+      if (!ref) ref = currencyInfo.defaultSettings.defaultRef
+      try {
+        const result = await fetchCors(
+          `${currencyInfo.defaultSettings.fioRegApiUrl}${FIO_REG_API_ENDPOINTS.getDomains}/${ref}`,
+          {
+            method: 'GET'
+          }
+        )
+        const json = await result.json()
+        if (!result.ok) {
+          if (fioRegApiErrorCodes[json.errorCode]) {
+            throw new FioError(
+              json.error,
+              result.status,
+              fioRegApiErrorCodes[json.errorCode],
+              json
+            )
+          }
+
+          throw new Error(json.error)
+        }
+        return json.domains
+      } catch (e) {
+        if (e.labelCode) throw e
+        throw new FioError(
+          e.message,
+          500,
+          currencyInfo.defaultSettings.errorCodes.SERVER_ERROR
+        )
+      }
+    }
+  }
+
+  return {
+    currencyInfo,
+    makeCurrencyEngine,
+    makeCurrencyTools,
+    otherMethods
+  }
+}

package/lib/fio/fioSchema.js

@@ -0,0 +1,56 @@
+// 
+
+import { asArray, asNumber, asObject, asOptional, asString } from 'cleaners'
+
+export const asGetFioName = asObject({
+  fio_domains: asArray(
+    asObject({
+      fio_domain: asString,
+      expiration: asString,
+      is_public: asNumber
+    })
+  ),
+  fio_addresses: asArray(
+    asObject({
+      fio_address: asString,
+      expiration: asString
+    })
+  )
+})
+
+
+
+export const asFioHistoryNodeAction = asObject({
+  account_action_seq: asNumber,
+  block_num: asNumber,
+  block_time: asString,
+  action_trace: asObject({
+    receiver: asString,
+    act: asObject({
+      account: asString,
+      name: asString,
+      data: asObject({
+        payee_public_key: asOptional(asString),
+        amount: asOptional(asNumber),
+        max_fee: asOptional(asNumber),
+        actor: asOptional(asString),
+        tpid: asOptional(asString),
+        quantity: asOptional(asString),
+        memo: asOptional(asString),
+        to: asOptional(asString),
+        from: asOptional(asString)
+      }),
+      hex_data: asString
+    }),
+    trx_id: asString,
+    block_num: asNumber,
+    block_time: asString,
+    producer_block_id: asString
+  })
+})
+
+export const asHistoryResponse = asObject({
+  actions: asArray(asFioHistoryNodeAction)
+})
+
+

package/lib/index.js

@@ -0,0 +1,44 @@
+/**
+ * Created by paul on 8/8/17.
+ */
+// 
+
+import 'regenerator-runtime/runtime'
+
+import { makeBinancePlugin } from './binance/bnbPlugin.js'
+import { makeEosPlugin } from './eos/eosInfo.js'
+import { makeTelosPlugin } from './eos/telosInfo.js'
+import { makeWaxPlugin } from './eos/waxInfo.js'
+import { makeEthereumClassicPlugin } from './ethereum/etcInfo.js'
+import { makeEthereumPlugin } from './ethereum/ethInfo.js'
+import { makeFantomPlugin } from './ethereum/ftminfo.js'
+import { makeRskPlugin } from './ethereum/rskInfo.js'
+import { makeFioPlugin } from './fio/fioPlugin'
+import { makeStellarPlugin } from './stellar/stellarPlugin.js'
+import { makeTezosPlugin } from './tezos/tezosPlugin.js'
+import { makeRipplePlugin } from './xrp/xrpPlugin.js'
+
+const plugins = {
+  eos: makeEosPlugin,
+  telos: makeTelosPlugin,
+  wax: makeWaxPlugin,
+  ethereum: makeEthereumPlugin,
+  ethereumclassic: makeEthereumClassicPlugin,
+  fantom: makeFantomPlugin,
+  fio: makeFioPlugin,
+  // "ripple" is network name. XRP is just an asset:
+  ripple: makeRipplePlugin,
+  stellar: makeStellarPlugin,
+  tezos: makeTezosPlugin,
+  rsk: makeRskPlugin,
+  binance: makeBinancePlugin
+}
+
+if (
+  typeof window !== 'undefined' &&
+  typeof window.addEdgeCorePlugins === 'function'
+) {
+  window.addEdgeCorePlugins(plugins)
+}
+
+export default plugins