edge-currency-plugins 1.0.0-rc.1

package/lib/common/plugin/makeEngineEmitter.js

@@ -0,0 +1,102 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _events = require('events');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ class EngineEmitter extends _events.EventEmitter {} exports.EngineEmitter = EngineEmitter;
+
+var EngineEvent; (function (EngineEvent) {
+  const TRANSACTIONS_CHANGED = 'transactions:changed'; EngineEvent["TRANSACTIONS_CHANGED"] = TRANSACTIONS_CHANGED;
+  const WALLET_BALANCE_CHANGED = 'wallet:balance:changed'; EngineEvent["WALLET_BALANCE_CHANGED"] = WALLET_BALANCE_CHANGED;
+  const ADDRESS_BALANCE_CHANGED = 'address:balance:changed'; EngineEvent["ADDRESS_BALANCE_CHANGED"] = ADDRESS_BALANCE_CHANGED;
+  const BLOCK_HEIGHT_CHANGED = 'block:height:changed'; EngineEvent["BLOCK_HEIGHT_CHANGED"] = BLOCK_HEIGHT_CHANGED;
+  const NEW_ADDRESS_TRANSACTION = 'address:transaction:changed'; EngineEvent["NEW_ADDRESS_TRANSACTION"] = NEW_ADDRESS_TRANSACTION;
+  const ADDRESSES_CHECKED = 'addresses:checked'; EngineEvent["ADDRESSES_CHECKED"] = ADDRESSES_CHECKED;
+  const TXIDS_CHANGED = 'txids:changed'; EngineEvent["TXIDS_CHANGED"] = TXIDS_CHANGED;
+  const CONNECTION_OPEN = 'connection:open'; EngineEvent["CONNECTION_OPEN"] = CONNECTION_OPEN;
+  const CONNECTION_CLOSE = 'connection:close'; EngineEvent["CONNECTION_CLOSE"] = CONNECTION_CLOSE;
+  const CONNECTION_TIMER = 'connection:timer'; EngineEvent["CONNECTION_TIMER"] = CONNECTION_TIMER;
+})(EngineEvent || (exports.EngineEvent = EngineEvent = {}));
+
+ const makeEngineEmitter = (
+  callbacks
+) => {
+  const emitter = new EngineEmitter()
+
+  emitter.on(EngineEvent.TRANSACTIONS_CHANGED, callbacks.onTransactionsChanged)
+  emitter.on(EngineEvent.WALLET_BALANCE_CHANGED, callbacks.onBalanceChanged)
+  emitter.on(EngineEvent.ADDRESSES_CHECKED, callbacks.onAddressesChecked)
+  emitter.on(EngineEvent.TXIDS_CHANGED, callbacks.onTxidsChanged)
+
+  return emitter
+}; exports.makeEngineEmitter = makeEngineEmitter

package/lib/common/plugin/makeMetadata.js

@@ -0,0 +1,99 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _biggystring = require('biggystring'); var bs = _interopRequireWildcard(_biggystring);
+
+
+var _memlet = require('memlet');
+
+var _awaitlock = require('../utxobased/engine/await-lock'); var _awaitlock2 = _interopRequireDefault(_awaitlock);
+var _makeEngineEmitter = require('./makeEngineEmitter');
+var _types3 = require('./types');
+
+const metadataPath = `metadata.json`
+
+
+
+
+
+
+
+
+
+
+
+ const makeMetadata = async (
+  config
+) => {
+  const { disklet, emitter, log } = config
+  const memlet = _memlet.makeMemlet.call(void 0, disklet)
+  const lock = new (0, _awaitlock2.default)()
+
+  const instance = {
+    get balance() {
+      return cache.balance
+    },
+    get lastSeenBlockHeight() {
+      return cache.lastSeenBlockHeight
+    },
+    clear: async () => {
+      await memlet.delete(metadataPath)
+      const cleanCache = await resetMetadata()
+      Object.assign(cache, cleanCache)
+    }
+  }
+
+  emitter.on(
+    _makeEngineEmitter.EngineEvent.ADDRESS_BALANCE_CHANGED,
+    async (currencyCode, balanceDiff) => {
+      await lock.acquireAsync()
+      try {
+        cache.balance = bs.add(cache.balance, balanceDiff)
+        emitter.emit(
+          _makeEngineEmitter.EngineEvent.WALLET_BALANCE_CHANGED,
+          currencyCode,
+          cache.balance
+        )
+        await setMetadata(cache)
+      } catch (err) {
+        log.error(err)
+      } finally {
+        lock.release()
+      }
+    }
+  )
+
+  emitter.on(
+    _makeEngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED,
+    async (_uri, height) => {
+      if (height > cache.lastSeenBlockHeight) {
+        cache.lastSeenBlockHeight = height
+        await setMetadata(cache)
+      }
+    }
+  )
+
+  const fetchMetadata = async () => {
+    try {
+      const metadata = await memlet.getJson(metadataPath)
+      return _types3.asLocalWalletMetadata.call(void 0, metadata)
+    } catch (err) {
+      log.error(err)
+      return await resetMetadata()
+    }
+  }
+
+  const resetMetadata = async () => {
+    const data = {
+      balance: '0',
+      lastSeenBlockHeight: 0
+    }
+    await memlet.setJson(metadataPath, data)
+    return data
+  }
+
+  const setMetadata = async (data) => {
+    await memlet.setJson(metadataPath, data)
+  }
+
+  const cache = await fetchMetadata()
+
+  return instance
+}; exports.makeMetadata = makeMetadata

package/lib/common/plugin/pluginState.js

@@ -0,0 +1,253 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// Typescript translation from original code in edge-currency-bitcoin
+
+var _cleaners = require('cleaners');
+
+
+var _memlet = require('memlet');
+
+
+
+
+
+
+
+
+var _serverScores = require('./serverScores');
+
+// Info server endpoint to getting ServerListInfo data
+const serverListInfoUrl = 'https://info1.edge.app/v1/blockBook/'
+// The filename for ServerInfoCache data (see serverScores.ts)
+// Perhaps this should be in serverScores.ts file, but that'll take some refactoring
+const SERVER_CACHE_FILE = 'serverCache.json'
+
+// ServerListInfo data structure from info server and saved to disk
+const asServerListInfo = _cleaners.asObject.call(void 0, _cleaners.asEither.call(void 0, _cleaners.asArray.call(void 0, _cleaners.asString), _cleaners.asNull))
+
+/** A JSON object (as opposed to an array or primitive). */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ function makePluginState(settings) {
+  const {
+    io,
+    defaultSettings,
+    currencyCode,
+    pluginId,
+    pluginDisklet,
+    log
+  } = settings
+  const builtInServers = defaultSettings.blockbookServers
+  let customServers = []
+  let enableCustomServers = defaultSettings.enableCustomServers
+  let engines = []
+  const memlet = _memlet.makeMemlet.call(void 0, pluginDisklet)
+
+  let serverCache = {
+    customServers: {},
+    internalServers: {}
+  }
+  let serverCacheDirty = false
+  let knownServers = {}
+
+  const saveServerCache = async () => {
+    serverScores.printServers(knownServers)
+    if (serverCacheDirty) {
+      await memlet.setJson(SERVER_CACHE_FILE, serverCache).catch(e => {
+        log(`${pluginId} - ${JSON.stringify(e.toString())}`)
+      })
+      serverCacheDirty = false
+      serverScores.scoresLastLoaded = Date.now()
+      log(`${pluginId} - Saved server cache`)
+    }
+  }
+
+  const onDirtyServer = (serverUrl) => {
+    serverCacheDirty = true
+    for (const engine of engines) {
+      if (engine.processedPercent === 1) {
+        const isFound = engine.getServerList().includes(serverUrl)
+        if (isFound) {
+          saveServerCache().catch(e => {
+            log(`${pluginId} - ${JSON.stringify(e.toString())}`)
+          })
+          // Early exit because the server cache is no longer dirty after
+          // calling saveServerCache
+          return
+        }
+      }
+    }
+  }
+
+  const serverScores = new (0, _serverScores.ServerScores)({
+    log,
+    onDirtyServer
+  })
+
+  const fetchServers = async () => {
+    log(`${pluginId} - GET ${serverListInfoUrl}`)
+
+    const response = await io.fetch(serverListInfoUrl)
+    const responseBody = await (async () => {
+      try {
+        if (response.ok) {
+          return await response.json()
+        }
+        log(
+          `${pluginId} - Fetching ${serverListInfoUrl} failed with status ${response.status}`
+        )
+      } catch (err) {
+        log(`${pluginId} - Fetching ${serverListInfoUrl} failed: ${err}`)
+      }
+      return {}
+    })()
+
+    const serverListInfo = asServerListInfo(responseBody)
+
+    return _nullishCoalesce(serverListInfo[currencyCode], () => ( []))
+  }
+
+  const refreshServers = async () => {
+    let newServers
+    if (enableCustomServers) {
+      newServers = customServers
+    } else {
+      const fetchedServers = await fetchServers()
+      newServers = fetchedServers.length > 0 ? fetchedServers : builtInServers
+    }
+
+    const serverCacheIndex = enableCustomServers
+      ? 'customServers'
+      : 'internalServers'
+
+    knownServers = serverCache[serverCacheIndex]
+    serverScores.serverScoresLoad(knownServers, newServers)
+    await saveServerCache()
+
+    // Tell the engines about the new servers:
+    for (const engine of engines) {
+      engine.refillServers()
+    }
+  }
+
+  return {
+    /**
+     * Begins notifying the engine of state changes. Used at connection time.
+     */
+    addEngine(engineState) {
+      engines.push(engineState)
+    },
+
+    /**
+     * Stops notifying the engine of state changes. Used at disconnection time.
+     */
+    removeEngine(engineState) {
+      engines = engines.filter(engine => engine !== engineState)
+    },
+
+    dumpData() {
+      return {
+        'pluginState.servers_': knownServers
+      }
+    },
+
+    async load() {
+      try {
+        serverCache = _serverScores.asServerCache.call(void 0, await memlet.getJson(SERVER_CACHE_FILE))
+      } catch (e) {
+        log(`${pluginId}: Failed to load server cache: ${JSON.stringify(e)}`)
+      }
+
+      // Fetch servers in the background:
+      refreshServers().catch(e => {
+        log(`${pluginId} - ${JSON.stringify(e.toString())}`)
+      })
+
+      return this
+    },
+
+    serverScoreDown(uri) {
+      serverScores.serverScoreDown(knownServers, uri)
+    },
+
+    serverScoreUp(uri, score) {
+      serverScores.serverScoreUp(knownServers, uri, score)
+    },
+
+    async clearCache() {
+      serverScores.clearServerScoreTimes()
+      knownServers = {}
+      serverCacheDirty = true
+      await memlet.delete(SERVER_CACHE_FILE)
+    },
+
+    getLocalServers(
+      numServersWanted,
+      includePatterns = []
+    ) {
+      return serverScores.getServers(
+        knownServers,
+        numServersWanted,
+        includePatterns
+      )
+    },
+
+    refreshServers,
+
+    async updateServers(settings) {
+      enableCustomServers = settings.enableCustomServers
+      customServers = settings.blockbookServers
+
+      const enginesToBeStopped = []
+      const disconnects = []
+      for (const engine of engines) {
+        enginesToBeStopped.push(engine)
+        engine.setServerList([])
+        disconnects.push(engine.stop())
+      }
+      await Promise.all(disconnects)
+      serverScores.clearServerScoreTimes()
+      // We must always clear custom servers in order to enforce a policy of
+      // only using the exact customServers provided.
+      serverCache = {
+        ...serverCache,
+        customServers: {}
+      }
+      serverCacheDirty = true
+      await saveServerCache()
+      await refreshServers()
+      for (const engine of enginesToBeStopped) {
+        await engine.stop()
+      }
+    }
+  }
+} exports.makePluginState = makePluginState;