edge-currency-plugins 3.2.0 → 3.3.0

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

@@ -10,13 +10,16 @@
 
 var _cleaners = require('cleaners');
 
+var _urlparse = require('url-parse'); var _urlparse2 = _interopRequireDefault(_urlparse);
 
+var _uriKeyParams = require('../../../util/uriKeyParams');
 var _utils = require('../../plugin/utils');
 
+
 var _nodejsWS = require('./nodejsWS');
 var _SocketEmitter = require('./SocketEmitter');
 var _socketQueue = require('./socketQueue');
-var _types3 = require('./types');
+var _types5 = require('./types');
 var _windowWS = require('./windowWS');
 
 const TIMER_SLACK = 500
@@ -76,6 +79,12 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
 
 
 
+
+
+
+
+
+
 
 
 
@@ -118,7 +127,6 @@ const asResponseDefault = (raw) => [
   const version = ''
   const socketQueueId = walletId + '==' + uri
   const subscriptions = {}
-  let onQueueSpace = config.onQueueSpaceCB
   let pendingRequests = {}
   let nextId = 0
   let lastKeepAlive = 0
@@ -126,12 +134,12 @@ const asResponseDefault = (raw) => [
   let connected = false
   let cancelConnect = false
   const timeout = 1000 * (_nullishCoalesce(config.timeout, () => ( 30)))
-  let error
+  let trackedError
   let timer
 
   const handleError = (e) => {
-    if (error == null) error = e
-    if (connected && socket != null && socket.readyState === _types3.ReadyState.OPEN)
+    if (trackedError == null) trackedError = e
+    if (connected && socket != null && socket.readyState === _types5.ReadyState.OPEN)
       disconnect()
     else cancelConnect = true
     log.error('handled error!', e)
@@ -146,22 +154,26 @@ const asResponseDefault = (raw) => [
   }
 
   const onSocketClose = () => {
-    const err = _nullishCoalesce(error, () => ( new Error('Socket close')))
-    log.warn(`onSocketClose due to ${err.message} with server ${uri}`)
+    const errObj =
+      trackedError != null
+        ? trackedError instanceof Error
+          ? trackedError
+          : new Error(String(trackedError))
+        : new Error('Socket closed without error')
+    log.warn(`onSocketClose with server ${uri}: ${errObj.message}`)
     clearTimeout(timer)
     connected = false
     socket = null
     cancelConnect = false
+    trackedError = undefined
     for (const request of Object.values(pendingRequests)) {
-      try {
-        request.task.deferred.reject(err)
-      } catch (e) {
+      request.generator.throw(errObj).catch(e => {
         log.error(e.message)
-      }
+      })
     }
     pendingRequests = {}
     try {
-      emitter.emit(_SocketEmitter.SocketEvent.CONNECTION_CLOSE, uri, err)
+      emitter.emit(_SocketEmitter.SocketEvent.CONNECTION_CLOSE, uri, errObj)
     } catch (e) {
       log.error(e.message)
     }
@@ -205,20 +217,21 @@ const asResponseDefault = (raw) => [
     lastWakeUp = Date.now()
     if (connected && version != null) {
       while (Object.keys(pendingRequests).length < queueSize) {
-        const task = await onQueueSpace(uri)
-        if (task == null) break
+        const generator = await config.taskGeneratorFn(uri)
+        const result = await generator.next()
+        const task = result.value
         if (typeof task === 'boolean') {
           if (task) continue
-          break
+          else break
         }
-        submitTask(task)
+        instance.submitTask(task, generator)
       }
     }
   }
 
   // add any exception, since the passed in template parameter needs to be re-assigned
   const subscribe = (subscription) => {
-    if (socket != null && socket.readyState === _types3.ReadyState.OPEN && connected) {
+    if (socket != null && socket.readyState === _types5.ReadyState.OPEN && connected) {
       const id = subscription.method
       const message = {
         id,
@@ -230,19 +243,11 @@ const asResponseDefault = (raw) => [
     }
   }
 
-  // add any exception, since the passed in template parameter needs to be re-assigned
-  const submitTask = (task) => {
-    const id = (nextId++).toString()
-    const request = { task, startTime: Date.now() }
-    pendingRequests[id] = request
-    transmitRequest(id, request)
-  }
-
   const transmitRequest = (id, request) => {
     const now = Date.now()
     if (
       socket != null &&
-      socket.readyState === _types3.ReadyState.OPEN &&
+      socket.readyState === _types5.ReadyState.OPEN &&
       connected &&
       !cancelConnect
     ) {
@@ -267,16 +272,16 @@ const asResponseDefault = (raw) => [
         .then(() => {
           emitter.emit(_SocketEmitter.SocketEvent.CONNECTION_TIMER, uri, now)
         })
-        .catch((e) => handleError(e))
+        .catch(e => handleError(e))
     }
 
     for (const [id, request] of Object.entries(pendingRequests)) {
       if (request.startTime + timeout < now) {
-        try {
-          request.task.deferred.reject(new Error(`Timeout for request ${id}`))
-        } catch (e) {
-          log.error(e.message)
-        }
+        request.generator
+          .throw(new Error(`Timeout for request ${id}`))
+          .catch(e => {
+            log.error(e.message)
+          })
         _utils.removeItem.call(void 0, pendingRequests, id)
       }
     }
@@ -341,16 +346,29 @@ const asResponseDefault = (raw) => [
                   'message' in error ? error.message : error.connected
                 throw new Error(errorMessage)
               }
+              let nextValue
               if (request.task.cleaner != null) {
-                request.task.deferred.resolve(
-                  request.task.cleaner(responseMessage.data)
-                )
+                nextValue = request.task.cleaner(responseMessage.data)
               } else {
-                request.task.deferred.resolve(responseMessage.data)
+                nextValue = responseMessage.data
               }
+              request.generator
+                .next(nextValue)
+                .then(result => {
+                  const task = result.value
+                  if (typeof task === 'boolean') {
+                    return
+                  }
+                  instance.submitTask(task, request.generator)
+                })
+                .catch(e => {
+                  log.error(e.message)
+                })
             } catch (error) {
               console.log({ uri, error, response: responseMessage, request })
-              request.task.deferred.reject(error)
+              request.generator.throw(error).catch(e => {
+                log.error(e.message)
+              })
             }
             continue
           }
@@ -369,9 +387,9 @@ const asResponseDefault = (raw) => [
   setupTimer()
 
   // return a Socket
-  return {
+  const instance = {
     get readyState() {
-      return _nullishCoalesce(_optionalChain([socket, 'optionalAccess', _2 => _2.readyState]), () => ( _types3.ReadyState.CLOSED))
+      return _nullishCoalesce(_optionalChain([socket, 'optionalAccess', _2 => _2.readyState]), () => ( _types5.ReadyState.CLOSED))
     },
 
     async connect() {
@@ -384,17 +402,29 @@ const asResponseDefault = (raw) => [
             resolve()
           },
           onMessage: onMessage,
-          onError: event => {
-            error = new Error(JSON.stringify(event))
+          onError: err => {
+            trackedError = new Error(String(err))
           },
           onClose: onSocketClose
         }
 
-        // Append "/websocket" if needed:
+        // Append "/websocket" if the uri has no explicit path:
+        // We treat URIs with any path or a single trailing slash as having
+        // an explicit path.
         let fullUri = uri
         if (uri.startsWith('wss:') || uri.startsWith('ws:')) {
-          fullUri = uri.replace(/\/websocket\/?$/, '') + '/websocket'
+          // There is no path and the uri has no trailing slash
+          const pathIsExplicitlyEmpty =
+            !uri.endsWith('/') && _urlparse2.default.call(void 0, uri).pathname === '/'
+          // If path is explicitly empty, then append /websocket
+          if (pathIsExplicitlyEmpty) {
+            fullUri = uri + '/websocket'
+          }
         }
+
+        // Replace any "key params" in the URIs (e.g. `%{nowNodesApiKey}`)
+        fullUri = _uriKeyParams.replaceKeyParams.call(void 0, fullUri, config.initOptions)
+
         if (uri.startsWith('electrumwss:')) {
           fullUri = uri.replace(/^electrumwss:/, 'wss:')
         }
@@ -417,15 +447,21 @@ const asResponseDefault = (raw) => [
     },
 
     isConnected() {
-      return _optionalChain([socket, 'optionalAccess', _7 => _7.readyState]) === _types3.ReadyState.OPEN
+      return _optionalChain([socket, 'optionalAccess', _7 => _7.readyState]) === _types5.ReadyState.OPEN
     },
 
-    submitTask,
-
-    onQueueSpace(cb) {
-      onQueueSpace = cb
+    submitTask: (
+      task,
+      generator
+    ) => {
+      const id = (nextId++).toString()
+      const request = { task, startTime: Date.now(), generator }
+      pendingRequests[id] = request
+      transmitRequest(id, request)
     },
 
     subscribe
   }
+
+  return instance
 } exports.makeSocket = makeSocket;

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

@@ -14,8 +14,8 @@
   socket.onmessage = (message) => {
     callbacks.onMessage(message.data.toString())
   }
-  socket.onerror = () => {
-    callbacks.onError()
+  socket.onerror = event => {
+    callbacks.onError(event)
   }
   socket.onclose = () => {
     callbacks.onClose()

package/lib/src/common/plugin/PluginState.d.ts

@@ -1,7 +1,7 @@
 import { Disklet } from 'disklet';
 import { EdgeIo, EdgeLog } from 'edge-core-js/types';
 import { UtxoUserSettings } from '../utxobased/engine/types';
-import { UtxoEngineState } from '../utxobased/engine/UtxoEngineState';
+import { UtxoEngineProcessor } from '../utxobased/engine/UtxoEngineProcessor';
 /** A JSON object (as opposed to an array or primitive). */
 interface JsonObject {
     [name: string]: unknown;
@@ -19,15 +19,15 @@ export interface PluginStateSettings {
     log: EdgeLog;
 }
 export interface PluginState {
-    addEngine: (engineState: UtxoEngineState) => void;
-    removeEngine: (engineState: UtxoEngineState) => void;
+    addEngine: (engineProcessor: UtxoEngineProcessor) => void;
+    removeEngine: (engineProcessor: UtxoEngineProcessor) => void;
     dumpData: () => JsonObject;
     load: () => Promise<PluginState>;
     serverScoreDown: (uri: string) => void;
     serverScoreUp: (uri: string, score: number) => void;
     clearCache: () => Promise<void>;
     getLocalServers: (numServersWanted: number, includePatterns?: Array<string | RegExp>) => string[];
-    refreshServers: () => Promise<void>;
+    refreshServers: (updatedCustomServers?: string[]) => Promise<void>;
     updateServers: (settings: UtxoUserSettings) => Promise<void>;
 }
 export declare function makePluginState(settings: PluginStateSettings): PluginState;

package/lib/src/common/plugin/ServerScores.d.ts

@@ -25,6 +25,7 @@ export declare const asServerCache: import("cleaners").ObjectCleaner<{
             numResponseTimes: any;
         };
     };
+    enableCustomServers: boolean;
     internalServers: {
         [keys: string]: {
             serverUrl: any;

package/lib/src/common/plugin/types.d.ts

@@ -5,7 +5,7 @@ import { Cleaner } from 'cleaners';
 import { Disklet } from 'disklet';
 import { EdgeCurrencyEngineOptions, EdgeCurrencyInfo, EdgeCurrencyTools, EdgeIo, EdgeParsedUri, EdgeWalletInfo } from 'edge-core-js/types';
 import * as wif from 'wif';
-import { IProcessorTransaction, IUTXO } from '../utxobased/db/types';
+import { TransactionData, UtxoData } from '../utxobased/db/types';
 import { UtxoInitOptions } from '../utxobased/engine/types';
 import { ScriptTemplates } from '../utxobased/info/scriptTemplates/types';
 import { UtxoPicker } from '../utxobased/keymanager/utxopicker';
@@ -23,7 +23,7 @@ export interface AddressPath {
     addressIndex: number;
 }
 export interface TxOptions {
-    utxos?: IUTXO[];
+    utxos?: UtxoData[];
     subtractFee?: boolean;
     CPFP?: string;
 }
@@ -110,10 +110,10 @@ export interface EngineInfo {
      * Some currencies require an additional blockbook payload
      * 'getTransactionSpecific' in order to provide all relevant transaction
      * data. If this function is defined, it should merge the unknown `specialTx`
-     * data from the Blockbook endpoint with the `IProcessorTransaction` object
+     * data from the Blockbook endpoint with the `TransactionData` object
      * which is stored to disk.
      **/
-    txSpecificHandling?: (tx: IProcessorTransaction, specialTx: unknown) => IProcessorTransaction;
+    txSpecificHandling?: (tx: TransactionData, specialTx: unknown) => TransactionData;
 }
 export interface ServerConfig {
     type: 'blockbook-nownode';

package/lib/src/common/utxobased/db/{Processor.d.ts → DataLayer.d.ts}

@@ -1,12 +1,12 @@
 import { Disklet } from 'disklet';
 import { EdgeGetTransactionsOptions } from 'edge-core-js/types';
 import { AddressPath, ChangePath } from '../../plugin/types';
-import { IAddress, IProcessorTransaction, IUTXO } from './types';
-interface ProcessorConfig {
+import { AddressData, TransactionData, UtxoData } from './types';
+interface DataLayerConfig {
     disklet: Disklet;
 }
 interface SaveTransactionArgs {
-    tx: IProcessorTransaction;
+    tx: TransactionData;
     scriptPubkeys?: string[];
 }
 interface FetchTransactionArgs {
@@ -28,20 +28,26 @@ interface DumpDataReturn {
     databaseName: string;
     data: unknown;
 }
-export interface Processor {
+/**
+ * The Data Access Layer for the UTXO-based wallet engine.
+ *
+ * It provides all the methods necessary to interact with underlying
+ * database/storage mechanism.
+ */
+export interface DataLayer {
     clearAll: () => Promise<void>;
     dumpData: () => Promise<DumpDataReturn[]>;
-    saveUtxo: (utxo: IUTXO) => Promise<void>;
+    saveUtxo: (utxo: UtxoData) => Promise<void>;
     removeUtxos: (utxoIds: string[]) => Promise<void>;
-    fetchUtxos: (args: FetchUtxosArgs) => Promise<Array<IUTXO | undefined>>;
-    saveTransaction: (args: SaveTransactionArgs) => Promise<IProcessorTransaction>;
+    fetchUtxos: (args: FetchUtxosArgs) => Promise<Array<UtxoData | undefined>>;
+    saveTransaction: (args: SaveTransactionArgs) => Promise<TransactionData>;
     numTransactions: () => number;
     removeTransaction: (txId: string) => Promise<void>;
-    fetchTransactions: (args: FetchTransactionArgs) => Promise<Array<IProcessorTransaction | undefined>>;
-    saveAddress: (args: IAddress) => Promise<void>;
+    fetchTransactions: (args: FetchTransactionArgs) => Promise<Array<TransactionData | undefined>>;
+    saveAddress: (args: AddressData) => Promise<void>;
     numAddressesByFormatPath: (path: ChangePath) => number;
     lastUsedIndexByFormatPath: (path: ChangePath) => Promise<number>;
-    fetchAddress: (args: AddressPath | string) => Promise<IAddress | undefined>;
+    fetchAddress: (args: AddressPath | string) => Promise<AddressData | undefined>;
 }
-export declare function makeProcessor(config: ProcessorConfig): Promise<Processor>;
+export declare function makeDataLayer(config: DataLayerConfig): Promise<DataLayer>;
 export {};

package/lib/src/common/utxobased/db/Models/{ProcessorTransaction.d.ts → TransactionData.d.ts}

@@ -1,14 +1,14 @@
 import { EdgeTransaction } from 'edge-core-js/types';
 import { PluginInfo } from '../../../plugin/types';
 import { UtxoWalletTools } from '../../engine/UtxoWalletTools';
-import { Processor } from '../Processor';
-import { IProcessorTransaction } from '../types';
-export declare const fromEdgeTransaction: (tx: EdgeTransaction) => IProcessorTransaction;
+import { DataLayer } from '../DataLayer';
+import { TransactionData } from '../types';
+export declare const fromEdgeTransaction: (tx: EdgeTransaction) => TransactionData;
 interface ToEdgeTransactionArgs {
     walletId: string;
-    tx: IProcessorTransaction;
+    tx: TransactionData;
     walletTools: UtxoWalletTools;
-    processor: Processor;
+    dataLayer: DataLayer;
     pluginInfo: PluginInfo;
 }
 export declare const toEdgeTransaction: (args: ToEdgeTransactionArgs) => Promise<EdgeTransaction>;

package/lib/src/common/utxobased/db/Models/baselet.d.ts

@@ -1,10 +1,10 @@
 import { CountBase, CountBaseOptions, HashBase, HashBaseOptions, RangeBase, RangeBaseOptions } from 'baselet';
 import { ChangePath } from '../../../plugin/types';
-import { IAddress, IProcessorTransaction, IUTXO } from '../types';
+import { AddressData, TransactionData, UtxoData } from '../types';
 export declare const addressPathToPrefix: (path: ChangePath) => string;
 export declare type ScriptPubkeyByPathBaselet = CountBase<string>;
 export declare const scriptPubkeyByPathOptions: CountBaseOptions;
-export declare type AddressByScriptPubkeyBaselet = HashBase<IAddress>;
+export declare type AddressByScriptPubkeyBaselet = HashBase<AddressData>;
 export declare const addressByScriptPubkeyOptions: HashBaseOptions;
 export declare type LastUsedByFormatPathBaselet = HashBase<number>;
 export declare const lastUsedByFormatPathOptions: HashBaseOptions;
@@ -14,7 +14,7 @@ export interface TxIdByBlockHeight {
 }
 export declare type TxIdByBlockHeightBaselet = RangeBase<TxIdByBlockHeight, 'blockHeight', 'txid'>;
 export declare const txIdsByBlockHeightOptions: RangeBaseOptions<'blockHeight', 'txid'>;
-export declare type TxByIdBaselet = HashBase<IProcessorTransaction>;
+export declare type TxByIdBaselet = HashBase<TransactionData>;
 export declare const txByIdOptions: HashBaseOptions;
 export interface TxIdByDate {
     txid: string;
@@ -22,7 +22,7 @@ export interface TxIdByDate {
 }
 export declare type TxIdByDateBaselet = RangeBase<TxIdByDate, 'date', 'txid'>;
 export declare const txIdsByDateOptions: RangeBaseOptions<'date', 'txid'>;
-export declare type UtxoByIdBaselet = HashBase<IUTXO>;
+export declare type UtxoByIdBaselet = HashBase<UtxoData>;
 export declare const utxoByIdOptions: HashBaseOptions;
 export declare type UtxoIdsByScriptPubkeyBaselet = HashBase<string[]>;
 export declare const utxoIdsByScriptPubkeyOptions: HashBaseOptions;

package/lib/src/common/utxobased/db/types.d.ts

@@ -1,7 +1,7 @@
 import { SoftPick } from '../../../util/typeUtil';
 import { AddressPath } from '../../plugin/types';
 import { ScriptTypeEnum } from '../keymanager/keymanager';
-export interface IAddress {
+export interface AddressData {
     scriptPubkey: string;
     redeemScript?: string;
     lastQueriedBlockHeight: number;
@@ -11,8 +11,8 @@ export interface IAddress {
     used: boolean;
     balance?: string;
 }
-export declare const makeIAddress: (addressFields: SoftPick<IAddress, 'scriptPubkey'>) => IAddress;
-export interface IUTXO {
+export declare const makeAddressData: (addressFields: SoftPick<AddressData, 'scriptPubkey'>) => AddressData;
+export interface UtxoData {
     id: string;
     txid: string;
     vout: number;
@@ -24,26 +24,26 @@ export interface IUTXO {
     blockHeight: number;
     spent: boolean;
 }
-export declare const asIUTXO: import("cleaners").ObjectCleaner<IUTXO>;
-export interface IProcessorTransaction {
+export declare const asUtxoData: import("cleaners").ObjectCleaner<UtxoData>;
+export interface TransactionData {
     txid: string;
     hex: string;
     blockHeight: number;
     confirmations?: 'confirmed' | 'unconfirmed' | 'dropped' | number;
     date: number;
     fees: string;
-    inputs: ITransactionInput[];
-    outputs: ITransactionOutput[];
+    inputs: TransactionDataInput[];
+    outputs: TransactionDataOutput[];
     ourIns: string[];
     ourOuts: string[];
     ourAmount: string;
 }
-export interface ITransactionOutput {
+export interface TransactionDataOutput {
     amount: string;
     n: number;
     scriptPubkey: string;
 }
-export interface ITransactionInput {
+export interface TransactionDataInput {
     amount: string;
     n: number;
     outputIndex: number;

package/lib/src/common/utxobased/db/util/utxo.d.ts

@@ -1,3 +1,3 @@
-import { Processor } from '../Processor';
-import { IProcessorTransaction, IUTXO } from '../types';
-export declare const utxoFromProcessorTransactionInput: (processor: Processor, processorTransaction: IProcessorTransaction, inputIndex: number) => Promise<IUTXO>;
+import { DataLayer } from '../DataLayer';
+import { TransactionData, UtxoData } from '../types';
+export declare const utxoFromTransactionDataInput: (dataLayer: DataLayer, transactionData: TransactionData, inputIndex: number) => Promise<UtxoData>;

package/lib/src/common/utxobased/engine/ServerStates.d.ts

@@ -6,9 +6,9 @@ import { SafeWalletInfo } from '../keymanager/cleaners';
 import { Blockbook } from '../network/Blockbook';
 import { AddressResponse, AddressUtxosResponse, BlockbookTransaction } from '../network/blockbookApi';
 import Deferred from '../network/Deferred';
-import { WsTask } from '../network/Socket';
+import { WsTask, WsTaskGenerator } from '../network/Socket';
 import { UtxoInitOptions } from './types';
-interface ServerState {
+export interface ServerState {
     blockbook: Blockbook;
     blockSubscriptionStatus: 'unsubscribed' | 'subscribing' | 'subscribed';
     blockHeight: number;
@@ -25,7 +25,7 @@ interface ServerStateConfig {
     walletInfo: SafeWalletInfo;
 }
 export interface ServerStates {
-    setPickNextTaskCB: (callback: (uri: string) => Promise<boolean | WsTask<any> | undefined>) => void;
+    setPickNextTaskCB: (callback: (uri: string) => AsyncGenerator<WsTask<unknown> | boolean>) => void;
     stop: () => void;
     serverCanGetTx: (uri: string, txid: string) => boolean;
     serverCanGetAddress: (uri: string, address: string) => boolean;
@@ -41,10 +41,10 @@ export interface ServerStates {
     addressQueryTask: (serverUri: string, address: string, params: {
         lastQueriedBlockHeight: number;
         page: number;
-    }, deferred: Deferred<AddressResponse>) => WsTask<AddressResponse>;
-    transactionQueryTask: (serverUri: string, txId: string, deferred: Deferred<BlockbookTransaction>) => WsTask<BlockbookTransaction>;
-    transactionSpecialQueryTask: (serverUri: string, txId: string, deferred: Deferred<unknown>) => WsTask<unknown>;
-    utxoListQueryTask: (serverUri: string, address: string, deferred: Deferred<AddressUtxosResponse>) => WsTask<AddressUtxosResponse>;
+    }) => WsTaskGenerator<AddressResponse>;
+    transactionQueryTask: (serverUri: string, txId: string) => WsTaskGenerator<BlockbookTransaction>;
+    transactionSpecialQueryTask: (serverUri: string, txId: string) => WsTaskGenerator<unknown>;
+    utxoListQueryTask: (serverUri: string, address: string) => WsTaskGenerator<AddressUtxosResponse>;
 }
 export declare function makeServerStates(config: ServerStateConfig): ServerStates;
 export {};