edge-currency-plugins 1.0.0-rc.1

package/lib/common/utxobased/db/types.js

@@ -0,0 +1,67 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const makeIAddress = (
+  addressFields
+) => {
+  const { scriptPubkey, used = false, ...rest } = addressFields
+
+  return {
+    scriptPubkey,
+    used,
+    lastQueriedBlockHeight: 0,
+    lastQuery: 0,
+    lastTouched: 0,
+    balance: '0',
+    ...rest
+  }
+}; exports.makeIAddress = makeIAddress
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/lib/common/utxobased/engine/await-lock.js

@@ -0,0 +1,65 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});/**
+ * A mutex lock for coordination across async functions
+ */
+ class AwaitLock {constructor() { AwaitLock.prototype.__init.call(this);AwaitLock.prototype.__init2.call(this); }
+   __init() {this._acquired = false}
+    __init2() {this._waitingResolvers = []}
+
+  /**
+   * Whether the lock is currently acquired or not. Accessing this property does not affect the
+   * status of the lock.
+   */
+  get acquired() {
+    return this._acquired
+  }
+
+  /**
+   * Acquires the lock, waiting if necessary for it to become free if it is already locked. The
+   * returned promise is fulfilled once the lock is acquired.
+   *
+   * After acquiring the lock, you **must** call `release` when you are done with it.
+   */
+  async acquireAsync() {
+    if (!this._acquired) {
+      this._acquired = true
+      return await Promise.resolve()
+    }
+
+    return await new Promise(resolve => {
+      this._waitingResolvers.push(resolve)
+    })
+  }
+
+  /**
+   * Acquires the lock if it is free and otherwise returns immediately without waiting. Returns
+   * `true` if the lock was free and is now acquired, and `false` otherwise,
+   */
+  tryAcquire() {
+    if (!this._acquired) {
+      this._acquired = true
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Releases the lock and gives it to the next waiting acquirer, if there is one. Each acquirer
+   * must release the lock exactly once.
+   */
+  release() {
+    if (!this._acquired) {
+      throw new Error(`Cannot release an unacquired lock`)
+    }
+
+    if (this._waitingResolvers.length > 0) {
+      const resolve = this._waitingResolvers.shift()
+      if (resolve == null) {
+        throw new Error('Cannot release null lock')
+      }
+      resolve()
+    } else {
+      this._acquired = false
+    }
+  }
+} exports.default = AwaitLock;

package/lib/common/utxobased/engine/constants.js

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); const BLOCKBOOK_TXS_PER_PAGE = 100; exports.BLOCKBOOK_TXS_PER_PAGE = BLOCKBOOK_TXS_PER_PAGE
+
+ const CACHE_THROTTLE = 0.05; exports.CACHE_THROTTLE = CACHE_THROTTLE
+
+ const MAX_CONNECTIONS = 2; exports.MAX_CONNECTIONS = MAX_CONNECTIONS
+
+ const NEW_CONNECTIONS = 8; exports.NEW_CONNECTIONS = NEW_CONNECTIONS

package/lib/common/utxobased/engine/makeServerStates.js

@@ -0,0 +1,394 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+var _urijs = require('uri-js');
+
+var _makeEngineEmitter = require('../../plugin/makeEngineEmitter');
+
+
+var _utils = require('../../plugin/utils');
+
+var _BlockBook = require('../network/BlockBook');
+
+var _Deferred = require('../network/Deferred'); var _Deferred2 = _interopRequireDefault(_Deferred);
+var _MakeSocketEmitter = require('../network/MakeSocketEmitter');
+
+var _socketQueue = require('../network/socketQueue');
+var _constants = require('./constants');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ function makeServerStates(config) {
+  const { engineEmitter, log, pluginInfo, pluginState, walletInfo } = config
+  log('Making server states')
+
+  let serverStates = {}
+  let isEngineOn = true
+  let connections = {}
+  let serverList = []
+  let reconnectCounter = 0
+  let reconnectTimer = setTimeout(() => {
+    return
+  }, 0)
+  const socketEmitter = new (0, _MakeSocketEmitter.SocketEmitter)()
+
+  // set server specific event emitters
+  socketEmitter.on(_MakeSocketEmitter.SocketEvent.CONNECTION_OPEN, (uri) => {
+    reconnectCounter = 0
+    log(`${uri} ** Connected **`)
+  })
+  socketEmitter.on(
+    _MakeSocketEmitter.SocketEvent.CONNECTION_CLOSE,
+    (uri, error) => {
+      _utils.removeItem.call(void 0, connections, uri)
+      _utils.removeItem.call(void 0, serverStates, uri)
+
+      const msg =
+        error != null ? ` !! Connection ERROR !! ${error.message}` : ''
+      log(`${uri} onClose ${msg}`)
+      if (error != null) {
+        pluginState.serverScoreDown(uri)
+      }
+      reconnect()
+    }
+  )
+  socketEmitter.on(
+    _MakeSocketEmitter.SocketEvent.CONNECTION_TIMER,
+    (uri, queryDate) => {
+      const queryTime = Date.now() - queryDate
+      log(`${uri} returned healthCheck in ${queryTime}ms`)
+      pluginState.serverScoreUp(uri, queryTime)
+    }
+  )
+  engineEmitter.on(
+    _makeEngineEmitter.EngineEvent.NEW_ADDRESS_TRANSACTION,
+    (uri, newTx) => {
+      log(
+        `${uri} received received new transaction with id ${newTx.tx.txid} to address ${newTx.address}`
+      )
+      const serverState = serverStates[uri]
+      if (serverState != null) {
+        serverState.txids.add(newTx.tx.txid)
+      }
+    }
+  )
+  engineEmitter.on(
+    _makeEngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED,
+    (uri, blockHeight) => {
+      log(`${uri} block height changed to ${blockHeight}`)
+      serverStates[uri].blockHeight = blockHeight
+    }
+  )
+
+  let pickNextTaskCB
+
+
+
+
+  const makeServerState = () => ({
+    blockSubscriptionStatus: 'unsubscribed',
+    txids: new Set(),
+    addresses: new Set(),
+    blockHeight: 0
+  })
+  const setPickNextTaskCB = (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    callback
+  ) => {
+    pickNextTaskCB = callback
+  }
+
+  const stop = async () => {
+    isEngineOn = false
+    log(`stopping server states`)
+    _socketQueue.removeIdFromQueue.call(void 0, walletInfo.id)
+    clearTimeout(reconnectTimer)
+    for (const uri of Object.keys(connections)) {
+      const blockBook = connections[uri]
+      if (blockBook == null) continue
+      await blockBook.disconnect()
+    }
+    connections = {}
+    serverStates = {}
+  }
+
+  const reconnect = () => {
+    if (isEngineOn) {
+      log(`attempting server reconnect number ${reconnectCounter}`)
+      const reconnectionDelay = Math.max(5, reconnectCounter++) * 1000
+      reconnectTimer = setTimeout(() => {
+        clearTimeout(reconnectTimer)
+        refillServers()
+      }, reconnectionDelay)
+    }
+  }
+
+  const refillServers = () => {
+    log(`refilling servers...`)
+    _socketQueue.pushUpdate.call(void 0, {
+      id: walletInfo.id,
+      updateFunc: () => {
+        doRefillServers()
+      }
+    })
+  }
+
+  const doRefillServers = () => {
+    const includePatterns = ['wss:', 'ws:']
+    if (serverList.length === 0) {
+      serverList = pluginState.getLocalServers(_constants.NEW_CONNECTIONS, includePatterns)
+    }
+    log(`refillServers: Top ${_constants.NEW_CONNECTIONS} servers:`, serverList)
+    let chanceToBePicked = 1.25
+    while (Object.keys(connections).length < _constants.MAX_CONNECTIONS) {
+      if (serverList.length === 0) break
+      const uri = serverList.shift()
+      if (uri == null) {
+        reconnect()
+        break
+      }
+      if (connections[uri] != null) {
+        continue
+      }
+      // Validate the URI of server to make sure it is valid
+      const parsed = _urijs.parse.call(void 0, uri)
+      if (
+        parsed.scheme == null ||
+        parsed.scheme.length < 2 ||
+        parsed.host == null
+      ) {
+        continue
+      }
+      chanceToBePicked -= chanceToBePicked > 0.5 ? 0.25 : 0
+      if (Math.random() > chanceToBePicked) {
+        serverList.push(uri)
+        continue
+      }
+
+      serverStates[uri] = makeServerState()
+
+      const onQueueSpaceCB = async (
+
+
+) => {
+        const blockBook = connections[uri]
+        if (blockBook == null) {
+          return
+        }
+        const task = await pickNextTaskCB(uri)
+        if (task != null && typeof task !== 'boolean') {
+          const taskMessage = `${task.method} params: ${JSON.stringify(
+            task.params
+          )}`
+          log(`${uri} nextTask: ${taskMessage}`)
+        }
+        return task
+      }
+
+      connections[uri] = _BlockBook.makeBlockBook.call(void 0, {
+        wsAddress: uri,
+        socketEmitter,
+        engineEmitter,
+        log,
+        onQueueSpaceCB,
+        walletId: walletInfo.id,
+        asAddress: pluginInfo.engineInfo.asBlockbookAddress
+      })
+
+      const blockBook = connections[uri]
+      if (blockBook == null) continue
+
+      // Initialize blockbook connection for server
+      blockBook
+        .connect()
+        .then(async () => {
+          // Fetch block height from blockbook server
+          const startTime = Date.now()
+          const { bestHeight: blockHeight } = await blockBook.fetchInfo()
+          log('height:', blockHeight)
+
+          // Update server state
+          serverStates[uri].blockHeight = blockHeight
+
+          // Emit initial BLOCK_HEIGHT_CHANGED event
+          engineEmitter.emit(_makeEngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED, uri, blockHeight)
+
+          // Increment server score using response time
+          const responseTime = Date.now() - startTime
+          pluginState.serverScoreUp(uri, responseTime)
+        })
+        .catch(e => {
+          log.error(`${JSON.stringify(e.message)}`)
+        })
+    }
+  }
+
+  const serverCanGetTx = (uri, txid) => {
+    const serverState = serverStates[uri]
+    if (serverState == null) return false
+    if (serverState.txids.has(txid)) return true
+
+    for (const state of Object.values(serverStates)) {
+      if (state.txids.has(txid)) return false
+    }
+    return true
+  }
+
+  const serverCanGetAddress = (uri, address) => {
+    const serverState = serverStates[uri]
+    if (serverState == null) return false
+    if (serverState.addresses.has(address)) return true
+
+    for (const state of Object.values(serverStates)) {
+      if (state.addresses.has(address)) return false
+    }
+    return true
+  }
+
+  const serverScoreUp = (uri, score) => {
+    pluginState.serverScoreUp(uri, score)
+  }
+
+  const getServerState = (uri) => {
+    return serverStates[uri]
+  }
+
+  const getServerList = () => {
+    return serverList
+  }
+
+  const setServerList = (updatedServerList) => {
+    serverList = updatedServerList
+  }
+
+  const broadcastTx = async (transaction) => {
+    return await new Promise((resolve, reject) => {
+      const uris = Object.keys(connections).filter(uri => {
+        const blockBook = connections[uri]
+        if (blockBook == null) return false
+        return blockBook.isConnected
+      })
+      if (uris == null || uris.length < 1) {
+        reject(
+          new Error('No available connections\nCheck your internet signal')
+        )
+      }
+      let resolved = false
+      let bad = 0
+      for (const uri of uris) {
+        const blockBook = connections[uri]
+        if (blockBook == null) continue
+        blockBook
+          .broadcastTx(transaction)
+          .then(response => {
+            if (!resolved) {
+              resolved = true
+              resolve(response.result)
+            }
+          })
+          .catch((e) => {
+            if (++bad === uris.length) {
+              const msg = e != null ? `With error ${e.message}` : ''
+              log.error(
+                `broadcastTx fail: ${JSON.stringify(transaction)}\n${msg}`
+              )
+              reject(e)
+            }
+          })
+      }
+    })
+  }
+
+  const watchAddresses = (
+    uri,
+    addresses,
+    deferredAddressSub
+  ) => {
+    const blockbook = connections[uri]
+    if (blockbook == null)
+      throw new Error(`No blockbook connection with ${uri}`)
+    blockbook.watchAddresses(addresses, deferredAddressSub)
+  }
+
+  const watchBlocks = (uri) => {
+    const blockbook = connections[uri]
+    if (blockbook == null)
+      throw new Error(`No blockbook connection with ${uri}`)
+
+    const serverState = _nullishCoalesce(serverStates[uri], () => ( makeServerState()))
+    serverState.blockSubscriptionStatus = 'subscribing'
+
+    const queryTime = Date.now()
+    const deferred = new (0, _Deferred2.default)()
+    deferred.promise
+      .then(() => {
+        serverState.blockSubscriptionStatus = 'subscribed'
+        serverScoreUp(uri, Date.now() - queryTime)
+      })
+      .catch(() => {
+        serverState.blockSubscriptionStatus = 'unsubscribed'
+      })
+    blockbook.watchBlocks(deferred)
+  }
+
+  const getBlockHeight = (uri) => {
+    return serverStates[uri].blockHeight
+  }
+
+  return {
+    setPickNextTaskCB,
+    stop,
+    serverCanGetTx,
+    serverCanGetAddress,
+    serverScoreUp,
+    getServerState,
+    refillServers,
+    getServerList,
+    setServerList,
+    broadcastTx,
+    watchAddresses,
+    watchBlocks,
+    getBlockHeight
+  }
+} exports.makeServerStates = makeServerStates;