edge-currency-plugins 2.6.2 → 3.0.1

package/lib/common/utxobased/network/Blockbook.js

@@ -1,7 +1,10 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+"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 _EngineEmitter = require('../../plugin/EngineEmitter');
+var _constants = require('../engine/constants');
+
+
 
 
 
@@ -49,6 +52,42 @@ var _Socket = require('./Socket');
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -73,6 +112,7 @@ var _Socket = require('./Socket');
  function makeBlockbook(config) {
   const {
     asAddress,
+    asResponse,
     connectionUri,
     engineEmitter,
     log,
@@ -84,120 +124,153 @@ var _Socket = require('./Socket');
 
   const instance = {
     isConnected: false,
-    connect,
-    disconnect,
-    onQueueSpace,
-    fetchInfo,
-    fetchAddress,
-    watchAddresses,
-    watchBlocks,
-    fetchAddressUtxos,
-    fetchTransaction,
-    broadcastTx
+
+    async broadcastTx(
+      transaction
+    ) {
+      return await instance.promisifyWsMessage(
+        _blockbookApi.broadcastTxMessage.call(void 0, transaction.signedTx)
+      )
+    },
+
+    async connect() {
+      log(`connecting to blockbook socket with uri ${connectionUri}`)
+      if (instance.isConnected) return
+
+      await socket.connect()
+      instance.isConnected = socket.isConnected()
+    },
+
+    async disconnect() {
+      log(
+        `disconnecting from blockbook socket with uri ${connectionUri}, currently connected: ${instance.isConnected}`
+      )
+      if (!instance.isConnected) return
+
+      socket.disconnect()
+      instance.isConnected = false
+    },
+
+    async fetchAddress(
+      address,
+      params = {}
+    ) {
+      return await instance.promisifyWsMessage(
+        _blockbookApi.addressMessage.call(void 0, address, asAddress, params)
+      )
+    },
+
+    async fetchAddressUtxos(account) {
+      return await instance.promisifyWsMessage(_blockbookApi.addressUtxosMessage.call(void 0, account))
+    },
+
+    async fetchInfo() {
+      return await instance.promisifyWsMessage(_blockbookApi.infoMessage.call(void 0, ))
+    },
+
+    async fetchTransaction(hash) {
+      return await instance.promisifyWsMessage(_blockbookApi.transactionMessage.call(void 0, hash))
+    },
+
+    onQueueSpace(cb) {
+      socket.onQueueSpace(cb)
+    },
+
+    async promisifyWsMessage(message) {
+      const deferred = new _Deferred2.default()
+      socket.submitTask({ ...message, deferred })
+      return await deferred.promise
+    },
+
+    watchAddresses(
+      addresses,
+      deferredAddressSub
+    ) {
+      const socketCb = async (res) => {
+        engineEmitter.emit(
+          _EngineEmitter.EngineEvent.NEW_ADDRESS_TRANSACTION,
+          connectionUri,
+          res
+        )
+      }
+      socket.subscribe({
+        ..._blockbookApi.subscribeAddressesMessage.call(void 0, addresses, asAddress),
+        cb: socketCb,
+        deferred: deferredAddressSub,
+        subscribed: false
+      })
+    },
+
+    async watchBlocks(deferredBlockSub) {
+      const socketCb = async (
+        res
+      ) => {
+        engineEmitter.emit(
+          _EngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED,
+          connectionUri,
+          res.height
+        )
+      }
+      socket.subscribe({
+        ..._blockbookApi.subscribeNewBlockMessage.call(void 0, ),
+        cb: socketCb,
+        deferred: deferredBlockSub,
+        subscribed: false
+      })
+    },
+
+    //
+    // Task Methods:
+    //
+
+    addressQueryTask(address, params, deferred) {
+      return {
+        ..._blockbookApi.addressMessage.call(void 0, address, params.asBlockbookAddress, {
+          details: 'txs',
+          from: params.lastQueriedBlockHeight,
+          pageSize: _constants.BLOCKBOOK_TXS_PER_PAGE,
+          page: params.page
+        }),
+        deferred
+      }
+    },
+
+    transactionQueryTask(txId, deferred) {
+      return {
+        ..._blockbookApi.transactionMessage.call(void 0, txId),
+        deferred
+      }
+    },
+
+    transactionSpecialQueryTask(
+      txId,
+      deferred
+    ) {
+      return {
+        ..._blockbookApi.transactionMessageSpecific.call(void 0, txId),
+        deferred
+      }
+    },
+
+    utxoListQueryTask(address, params, deferred) {
+      return {
+        ..._blockbookApi.addressUtxosMessage.call(void 0, address, params.asBlockbookAddress),
+        deferred
+      }
+    }
   }
 
   const socket = _Socket.makeSocket.call(void 0, connectionUri, {
-    healthCheck: ping,
+    asResponse,
+    healthCheck: _nullishCoalesce(config.ping, () => ( ping)),
     onQueueSpaceCB,
     log,
     emitter: socketEmitter,
     walletId
   })
 
-  async function connect() {
-    log(`connecting to blockbook socket with uri ${connectionUri}`)
-    if (instance.isConnected) return
-
-    await socket.connect()
-    instance.isConnected = socket.isConnected()
-  }
-
-  async function disconnect() {
-    log(
-      `disconnecting from blockbook socket with uri ${connectionUri}, currently connected: ${instance.isConnected}`
-    )
-    if (!instance.isConnected) return
-
-    socket.disconnect()
-    instance.isConnected = false
-  }
-
-  function onQueueSpace(cb) {
-    socket.onQueueSpace(cb)
-  }
-
-  async function promisifyWsMessage(message) {
-    const deferred = new _Deferred2.default()
-    socket.submitTask({ ...message, deferred })
-    return await deferred.promise
-  }
-
   async function ping() {
-    await promisifyWsMessage(_blockbookApi.pingMessage.call(void 0, ))
-  }
-
-  async function fetchInfo() {
-    return await promisifyWsMessage(_blockbookApi.infoMessage.call(void 0, ))
-  }
-
-  async function fetchAddressUtxos(
-    account
-  ) {
-    return await promisifyWsMessage(_blockbookApi.addressUtxosMessage.call(void 0, account))
-  }
-
-  async function fetchTransaction(hash) {
-    return await promisifyWsMessage(_blockbookApi.transactionMessage.call(void 0, hash))
-  }
-
-  async function fetchAddress(
-    address,
-    params = {}
-  ) {
-    return await promisifyWsMessage(_blockbookApi.addressMessage.call(void 0, address, asAddress, params))
-  }
-
-  async function watchBlocks(
-    deferredBlockSub
-  ) {
-    const socketCb = async (res) => {
-      engineEmitter.emit(
-        _EngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED,
-        connectionUri,
-        res.height
-      )
-    }
-    socket.subscribe({
-      ..._blockbookApi.subscribeNewBlockMessage.call(void 0, ),
-      cb: socketCb,
-      deferred: deferredBlockSub,
-      subscribed: false
-    })
-  }
-
-  function watchAddresses(
-    addresses,
-    deferredAddressSub
-  ) {
-    const socketCb = async (res) => {
-      engineEmitter.emit(
-        _EngineEmitter.EngineEvent.NEW_ADDRESS_TRANSACTION,
-        connectionUri,
-        res
-      )
-    }
-    socket.subscribe({
-      ..._blockbookApi.subscribeAddressesMessage.call(void 0, addresses, asAddress),
-      cb: socketCb,
-      deferred: deferredAddressSub,
-      subscribed: false
-    })
-  }
-
-  async function broadcastTx(
-    transaction
-  ) {
-    return await promisifyWsMessage(_blockbookApi.broadcastTxMessage.call(void 0, transaction))
+    await instance.promisifyWsMessage(_blockbookApi.pingMessage.call(void 0, ))
   }
 
   return instance

package/lib/common/utxobased/network/BlockbookElectrum.js

@@ -0,0 +1,216 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _altcoinjs = require('altcoin-js');
+
+
+
+
+
+
+
+
+var _cleaners = require('cleaners');
+
+
+
+
+var _keymanager = require('../keymanager/keymanager');
+var _Blockbook = require('./Blockbook');
+
+var _Deferred = require('./Deferred'); var _Deferred2 = _interopRequireDefault(_Deferred);
+
+
+
+
+
+
+var _electrumApi = require('./electrumApi');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const asResponseMessage = (raw) => {
+  const message = _cleaners.asJSON.call(void 0, 
+    _cleaners.asObject.call(void 0, {
+      id: _cleaners.asString,
+      result: _cleaners.asUnknown,
+      error: _cleaners.asOptional.call(void 0, 
+        _cleaners.asEither.call(void 0, 
+          _cleaners.asObject.call(void 0, { message: _cleaners.asString }),
+          _cleaners.asObject.call(void 0, { connected: _cleaners.asString })
+        )
+      )
+    })
+  )(raw)
+
+  return {
+    id: message.id,
+    data: message.result,
+    error: message.error
+  }
+}
+
+const asResponse = (raw) => {
+  const payloadString = _cleaners.asString.call(void 0, raw).trimEnd()
+  const messageStrings = payloadString.split('\n')
+  const messages = messageStrings.map(asResponseMessage)
+  return messages
+}
+
+ function makeBlockbookElectrum(
+  config
+) {
+  const {
+    asAddress,
+    connectionUri,
+    engineEmitter,
+    log,
+    onQueueSpaceCB,
+    pluginInfo,
+    socketEmitter,
+    walletId
+  } = config
+  log(`makeBlockbookElectrum with uri ${connectionUri}`)
+
+  const addressToScriptHash = (address) => {
+    const scriptPubkey = _keymanager.addressToScriptPubkey.call(void 0, {
+      address,
+      coin: pluginInfo.coinInfo.name
+    })
+    const scriptHashBuffer = _altcoinjs.crypto.sha256(Buffer.from(scriptPubkey, 'hex'))
+    const scriptHash = scriptHashBuffer.reverse().toString('hex')
+    return scriptHash
+  }
+
+  const instance = _Blockbook.makeBlockbook.call(void 0, {
+    asAddress,
+    asResponse,
+    connectionUri,
+    engineEmitter,
+    log,
+    onQueueSpaceCB: async (
+      uri
+    ) => {
+      const task = await onQueueSpaceCB(uri)
+      if (task == null || typeof task === 'boolean') return task
+
+      // Translate getAccountUtxo to blockchain.scripthash.listunspent:
+      if (task.method === 'getAccountUtxo') {
+        const params = task.params 
+        const address =
+          asAddress != null ? asAddress(params.descriptor) : params.descriptor
+        const scriptHash = addressToScriptHash(address)
+
+        const deferred = new _Deferred2.default()
+        deferred.promise
+          .then((electrumUtxos) => {
+            const blockbookUtxos = electrumUtxos.map(
+              utxo => ({
+                txid: utxo.tx_hash,
+                vout: utxo.tx_pos,
+                value: utxo.value.toString(),
+                height: utxo.height
+              })
+            )
+            task.deferred.resolve(blockbookUtxos)
+          })
+          .catch((e) => {
+            task.deferred.reject(e)
+          })
+
+        const translatedTask = {
+          ..._electrumApi.listUnspentMessage.call(void 0, scriptHash),
+          deferred
+        }
+        return translatedTask
+      }
+
+      // Get Address Transactions:
+      if (task.method === 'getAccountInfo') {
+        const params = task.params 
+        const address =
+          asAddress != null ? asAddress(params.descriptor) : params.descriptor
+        const scriptHash = addressToScriptHash(address)
+
+        const deferred = new _Deferred2.default()
+        deferred.promise
+          .then((electrumUtxos) => {
+            const blockbookUtxos = {
+              address, // unused
+              balance: '0', // unused
+              totalReceived: '0', // unused
+              totalSent: '0', // unused
+              txs: electrumUtxos.length,
+              unconfirmedBalance: '0', // unused
+              unconfirmedTxs: electrumUtxos.reduce(
+                (sum, tx) => (sum + tx.height >= 0 ? 1 : 0),
+                0
+              ),
+              txids: [], // unused
+              transactions: [], // TODO: this requires an extra query per txid
+              page: 0, // unused
+              totalPages: 1,
+              itemsOnPage: 0 // unused
+            }
+            task.deferred.resolve(blockbookUtxos)
+          })
+          .catch((e) => {
+            task.deferred.reject(e)
+          })
+
+        const translatedTask = {
+          ..._electrumApi.addressTransactionsMessage.call(void 0, scriptHash),
+          deferred
+        }
+        return translatedTask
+      }
+
+      // Skip unsupported task and continue with the next one:
+      return true
+    },
+    ping: async () => {
+      return await instance.promisifyWsMessage(_electrumApi.pingMessage.call(void 0, ))
+    },
+    socketEmitter,
+    walletId
+  })
+
+  instance.broadcastTx = async () => {
+    throw new Error('broadcastTx not supported for Electrum connections')
+  }
+  instance.fetchAddress = async () => {
+    throw new Error('fetchAddress not supported for Electrum connections')
+  }
+  instance.fetchAddressUtxos = async () => {
+    throw new Error('fetchAddressUtxos not supported for Electrum connections')
+  }
+  instance.fetchInfo = async () => {
+    throw new Error('fetchInfo not supported for Electrum connections')
+  }
+  instance.fetchTransaction = async () => {
+    throw new Error('fetchTransaction not supported for Electrum connections')
+  }
+
+  instance.watchAddresses = async () => {
+    return // Fail gracefully
+  }
+  instance.watchBlocks = async () => {
+    return // Fail gracefully
+  }
+
+  return instance
+} exports.makeBlockbookElectrum = makeBlockbookElectrum;