edge-currency-plugins 1.0.0-rc.1

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

@@ -0,0 +1,335 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+var _cleaners = require('cleaners');
+
+
+/**
+ * Websocket Task
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const asBlockbookAccountUtxo = (
+  asAddress = _cleaners.asString
+) =>
+  _cleaners.asObject.call(void 0, {
+    txid: _cleaners.asString,
+    vout: _cleaners.asNumber,
+    value: _cleaners.asString,
+    confirmations: _cleaners.asOptional.call(void 0, _cleaners.asNumber),
+    coinbase: _cleaners.asOptional.call(void 0, _cleaners.asBoolean),
+    height: _cleaners.asOptional.call(void 0, _cleaners.asNumber),
+    lockTime: _cleaners.asOptional.call(void 0, _cleaners.asNumber),
+    address: _cleaners.asOptional.call(void 0, asAddress),
+    path: _cleaners.asOptional.call(void 0, _cleaners.asString)
+  }); exports.asBlockbookAccountUtxo = asBlockbookAccountUtxo
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const asBlockbookTransaction = (
+  asAddress = _cleaners.asString
+) =>
+  _cleaners.asObject.call(void 0, {
+    txid: _cleaners.asString,
+    hex: _cleaners.asString,
+    blockHeight: _cleaners.asNumber,
+    confirmations: _cleaners.asNumber,
+    blockTime: _cleaners.asNumber,
+    fees: _cleaners.asString,
+    vin: _cleaners.asArray.call(void 0, 
+      _cleaners.asObject.call(void 0, {
+        txid: _cleaners.asString,
+        sequence: _cleaners.asOptional.call(void 0, _cleaners.asNumber),
+        n: _cleaners.asNumber,
+        vout: _cleaners.asOptional.call(void 0, _cleaners.asNumber, -1),
+        addresses: _cleaners.asArray.call(void 0, asAddress),
+        isAddress: _cleaners.asBoolean,
+        value: _cleaners.asString,
+        hex: _cleaners.asOptional.call(void 0, _cleaners.asString)
+      })
+    ),
+    vout: _cleaners.asArray.call(void 0, 
+      _cleaners.asObject.call(void 0, {
+        n: _cleaners.asNumber,
+        value: _cleaners.asString,
+        addresses: _cleaners.asArray.call(void 0, asAddress),
+        hex: _cleaners.asOptional.call(void 0, _cleaners.asString)
+      })
+    )
+  }); exports.asBlockbookTransaction = asBlockbookTransaction
+
+// ---------------------------------------------------------------------
+// Blockbook API Response Types
+// ---------------------------------------------------------------------
+
+/**
+ * Error Response
+ */
+
+ const asBlockbookErrorResponse = _cleaners.asObject.call(void 0, {
+  error: _cleaners.asObject.call(void 0, {
+    message: _cleaners.asString
+  })
+}); exports.asBlockbookErrorResponse = asBlockbookErrorResponse
+
+/**
+ * Blockbook Response Generic
+ */
+
+ const asBlockbookResponse = (asT) => raw => {
+  const errResponse = _cleaners.asMaybe.call(void 0, (0, exports.asBlockbookErrorResponse))(raw)
+
+  if (errResponse != null)
+    throw new Error(`Blockbook Error: ${errResponse.error.message}`)
+
+  return asT(raw)
+}; exports.asBlockbookResponse = asBlockbookResponse
+
+// ---------------------------------------------------------------------
+// Blockbook API Messages
+// ---------------------------------------------------------------------
+
+/**
+ * Ping Message
+ */
+ const pingMessage = () => {
+  return {
+    method: 'ping',
+    params: undefined,
+    cleaner: exports.asBlockbookResponse.call(void 0, exports.asPingResponse)
+  }
+}; exports.pingMessage = pingMessage
+
+ const asPingResponse = _cleaners.asObject.call(void 0, {}); exports.asPingResponse = asPingResponse
+
+/**
+ * Get Info
+ */
+ const infoMessage = () => {
+  return {
+    method: 'getInfo',
+    params: {},
+    cleaner: exports.asBlockbookResponse.call(void 0, exports.asInfoResponse)
+  }
+}; exports.infoMessage = infoMessage
+
+ const asInfoResponse = _cleaners.asObject.call(void 0, {
+  name: _cleaners.asString,
+  shortcut: _cleaners.asString,
+  decimals: _cleaners.asNumber,
+  version: _cleaners.asString,
+  bestHeight: _cleaners.asNumber,
+  bestHash: _cleaners.asString,
+  block0Hash: _cleaners.asString,
+  testnet: _cleaners.asBoolean,
+  backend: _cleaners.asOptional.call(void 0, 
+    _cleaners.asObject.call(void 0, {
+      version: _cleaners.asString,
+      subversion: _cleaners.asString
+    })
+  )
+}); exports.asInfoResponse = asInfoResponse
+
+/**
+ * Get Account UTXO
+ */
+ const addressUtxosMessage = (
+  address,
+  asAddress = _cleaners.asString
+) => {
+  const wasAddress = _cleaners.uncleaner.call(void 0, asAddress)
+  return {
+    method: 'getAccountUtxo',
+    params: { descriptor: wasAddress(address) },
+    cleaner: exports.asBlockbookResponse.call(void 0, exports.asAddressUtxosResponse.call(void 0, asAddress))
+  }
+}; exports.addressUtxosMessage = addressUtxosMessage
+
+ const asAddressUtxosResponse = (
+  asAddress = _cleaners.asString
+) => _cleaners.asArray.call(void 0, exports.asBlockbookAccountUtxo.call(void 0, asAddress)); exports.asAddressUtxosResponse = asAddressUtxosResponse
+
+/**
+ * Get Transaction
+ */
+ const transactionMessage = (
+  hash,
+  asAddress = _cleaners.asString
+) => ({
+  method: 'getTransaction',
+  params: { txid: hash },
+  cleaner: exports.asBlockbookResponse.call(void 0, exports.asTransactionResponse.call(void 0, asAddress))
+}); exports.transactionMessage = transactionMessage
+
+ const asTransactionResponse = exports.asBlockbookTransaction; exports.asTransactionResponse = asTransactionResponse
+
+/**
+ * Send Transaction
+ */
+ const broadcastTxMessage = (
+  transaction
+) => {
+  return {
+    method: 'sendTransaction',
+    params: { hex: transaction.signedTx },
+    cleaner: exports.asBlockbookResponse.call(void 0, exports.asBroadcastTxResponse)
+  }
+}; exports.broadcastTxMessage = broadcastTxMessage
+
+ const asBroadcastTxResponse = _cleaners.asObject.call(void 0, {
+  result: _cleaners.asString
+}); exports.asBroadcastTxResponse = asBroadcastTxResponse
+
+/**
+ * Get Account Info
+ */
+
+
+
+
+
+
+
+ const addressMessage = (
+  address,
+  asAddress = _cleaners.asString,
+  params = {}
+) => {
+  const wasAddress = _cleaners.uncleaner.call(void 0, asAddress)
+  return {
+    method: 'getAccountInfo',
+    params: {
+      ...{ details: 'basic', page: 1, pageSize: 100, ...params },
+      descriptor: wasAddress(address)
+    },
+    cleaner: exports.asBlockbookResponse.call(void 0, exports.asAddressResponse.call(void 0, asAddress))
+  }
+}; exports.addressMessage = addressMessage
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+ const asAddressResponse = (asAddress = _cleaners.asString) =>
+  _cleaners.asObject.call(void 0, {
+    // details: basic
+    address: asAddress,
+    balance: _cleaners.asString,
+    totalReceived: _cleaners.asString,
+    totalSent: _cleaners.asString,
+    txs: _cleaners.asNumber,
+    unconfirmedBalance: _cleaners.asString,
+    unconfirmedTxs: _cleaners.asNumber,
+    // details: txids
+    txids: _cleaners.asOptional.call(void 0, _cleaners.asArray.call(void 0, _cleaners.asString), []),
+    // details: txs
+    transactions: _cleaners.asOptional.call(void 0, _cleaners.asArray.call(void 0, exports.asBlockbookTransaction.call(void 0, asAddress)), []),
+    // Pagination (included with txids and txs requests)
+    page: _cleaners.asOptional.call(void 0, _cleaners.asNumber, NaN),
+    totalPages: _cleaners.asOptional.call(void 0, _cleaners.asNumber, NaN),
+    itemsOnPage: _cleaners.asOptional.call(void 0, _cleaners.asNumber, NaN)
+  }); exports.asAddressResponse = asAddressResponse
+
+/**
+ * Subscribe New Block
+ */
+ const subscribeNewBlockMessage = () => {
+  return {
+    method: 'subscribeNewBlock',
+    params: {},
+    cleaner: exports.asBlockbookResponse.call(void 0, exports.asSubscribeNewBlockResponse)
+  }
+}; exports.subscribeNewBlockMessage = subscribeNewBlockMessage
+
+
+
+ const asSubscribeNewBlockResponse = _cleaners.asObject.call(void 0, {
+  height: _cleaners.asNumber,
+  hash: _cleaners.asString
+}); exports.asSubscribeNewBlockResponse = asSubscribeNewBlockResponse
+
+/**
+ * Subscribe Address
+ */
+ const subscribeAddressesMessage = (
+  addresses,
+  asAddress = _cleaners.asString
+) => {
+  const wasAddress = _cleaners.uncleaner.call(void 0, asAddress)
+  return {
+    method: 'subscribeAddresses',
+    params: {
+      addresses: addresses.map(wasAddress)
+    },
+    cleaner: exports.asBlockbookResponse.call(void 0, exports.asSubscribeAddressResponse.call(void 0, asAddress))
+  }
+}; exports.subscribeAddressesMessage = subscribeAddressesMessage
+
+
+
+
+ const asSubscribeAddressResponse = (
+  asAddress = _cleaners.asString
+) =>
+  _cleaners.asObject.call(void 0, {
+    address: asAddress,
+    tx: exports.asBlockbookTransaction.call(void 0, asAddress)
+  }); exports.asSubscribeAddressResponse = asSubscribeAddressResponse

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

@@ -0,0 +1,29 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// Wrapper class for a Promise with external resolve/reject functions
+// Inspired by https://stackoverflow.com/questions/26150232/resolve-javascript-promise-outside-function-scope
+
+ class Deferred {constructor() { Deferred.prototype.__init.call(this);Deferred.prototype.__init2.call(this);Deferred.prototype.__init3.call(this); }
+   __init() {this._resolve = () => {
+    return
+  }}
+
+   __init2() {this._reject = () => {
+    return
+  }}
+
+    __init3() {this._promise = new Promise((resolve, reject) => {
+    this._reject = reject
+    this._resolve = resolve
+  })}
+
+   get promise() {
+    return this._promise
+  }
+
+   resolve(value) {
+    this._resolve(value)
+  }
+
+   reject(reason) {
+    this._reject(reason)
+  }
+} exports.default = Deferred;

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

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _events = require('events');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ class SocketEmitter extends _events.EventEmitter {} exports.SocketEmitter = SocketEmitter;
+
+var SocketEvent; (function (SocketEvent) {
+  const CONNECTION_OPEN = 'connection:open'; SocketEvent["CONNECTION_OPEN"] = CONNECTION_OPEN;
+  const CONNECTION_CLOSE = 'connection:close'; SocketEvent["CONNECTION_CLOSE"] = CONNECTION_CLOSE;
+  const CONNECTION_TIMER = 'connection:timer'; SocketEvent["CONNECTION_TIMER"] = CONNECTION_TIMER;
+})(SocketEvent || (exports.SocketEvent = SocketEvent = {}));