edge-currency-plugins 3.2.1 → 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
@@ -131,7 +139,7 @@ const asResponseDefault = (raw) => [
 
   const handleError = (e) => {
     if (trackedError == null) trackedError = e
-    if (connected && socket != null && socket.readyState === _types3.ReadyState.OPEN)
+    if (connected && socket != null && socket.readyState === _types5.ReadyState.OPEN)
       disconnect()
     else cancelConnect = true
     log.error('handled error!', e)
@@ -159,11 +167,9 @@ const asResponseDefault = (raw) => [
     cancelConnect = false
     trackedError = undefined
     for (const request of Object.values(pendingRequests)) {
-      try {
-        request.task.deferred.reject(errObj)
-      } catch (e) {
+      request.generator.throw(errObj).catch(e => {
         log.error(e.message)
-      }
+      })
     }
     pendingRequests = {}
     try {
@@ -211,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,
@@ -236,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
     ) {
@@ -278,11 +277,11 @@ const asResponseDefault = (raw) => [
 
     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)
       }
     }
@@ -347,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
           }
@@ -375,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() {
@@ -396,11 +408,23 @@ const asResponseDefault = (raw) => [
           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:')
         }
@@ -423,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/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,8 +19,8 @@ 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;

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 {};

package/lib/src/common/utxobased/engine/{UtxoEngineState.d.ts → UtxoEngineProcessor.d.ts}

@@ -1,16 +1,15 @@
 import { EdgeFreshAddress, EdgeIo, EdgeLog, EdgeTransaction } from 'edge-core-js/types';
 import { EngineEmitter } from '../../plugin/EngineEmitter';
-import { PluginState } from '../../plugin/PluginState';
 import { ChangePath, CurrencyFormat, EngineConfig, PluginInfo } from '../../plugin/types';
-import { Processor } from '../db/Processor';
-import { IAddress, IProcessorTransaction, IUTXO } from '../db/types';
+import { DataLayer } from '../db/DataLayer';
+import { AddressData, TransactionData, UtxoData } from '../db/types';
 import { SafeWalletInfo } from '../keymanager/cleaners';
-import { BlockbookAccountUtxo } from '../network/blockbookApi';
+import { AddressResponse, AddressUtxosResponse, BlockbookAccountUtxo, TransactionResponse } from '../network/blockbookApi';
 import { WsTask } from '../network/Socket';
 import AwaitLock from './await-lock';
 import { ServerStates } from './ServerStates';
 import { UtxoWalletTools } from './UtxoWalletTools';
-export interface UtxoEngineState {
+export interface UtxoEngineProcessor {
     processedPercent: number;
     start: () => Promise<void>;
     stop: () => Promise<void>;
@@ -25,47 +24,49 @@ export interface UtxoEngineState {
     getServerList: () => string[];
     setServerList: (serverList: string[]) => void;
     loadWifs: (wifs: string[]) => Promise<void>;
-    processUtxos: (utxos: IUTXO[]) => Promise<void>;
+    processUtxos: (utxos: UtxoData[]) => Promise<void>;
 }
-export interface UtxoEngineStateConfig extends EngineConfig {
+export interface UtxoEngineProcessorConfig extends EngineConfig {
     walletTools: UtxoWalletTools;
     walletInfo: SafeWalletInfo;
-    processor: Processor;
+    dataLayer: DataLayer;
 }
-export declare function makeUtxoEngineState(config: UtxoEngineStateConfig): UtxoEngineState;
-interface CommonArgs {
+export declare function makeUtxoEngineProcessor(config: UtxoEngineProcessorConfig): UtxoEngineProcessor;
+interface CommonParams {
     pluginInfo: PluginInfo;
     walletInfo: SafeWalletInfo;
     walletTools: UtxoWalletTools;
-    processor: Processor;
+    dataLayer: DataLayer;
     emitter: EngineEmitter;
     taskCache: TaskCache;
     updateProgressRatio: () => void;
     io: EdgeIo;
     log: EdgeLog;
     serverStates: ServerStates;
-    pluginState: PluginState;
     walletFormats: CurrencyFormat[];
     lock: AwaitLock;
 }
 interface TaskCache {
-    blockWatching: boolean;
+    readonly addressForTransactionsCache: AddressForTransactionsCache;
+    readonly addressForUtxosCache: AddressForUtxosCache;
     readonly addressSubscribeCache: AddressSubscribeCache;
-    readonly addressUtxoCache: AddressUtxoCache;
-    readonly rawUtxoCache: RawUtxoCache;
-    readonly processorUtxoCache: ProcessorUtxoCache;
-    readonly addressTransactionCache: AddressTransactionCache;
-    readonly updateTransactionCache: UpdateTransactionCache;
-    readonly updateTransactionSpecificCache: UpdateTransactionSpecificCache;
+    readonly blockbookUtxoCache: BlockbookUtxoCache;
+    readonly dataLayerUtxoCache: DataLayerUtxoCache;
+    readonly transactionSpecificUpdateCache: TransactionSpecificUpdateCache;
+    readonly transactionUpdateCache: TransactionUpdateCache;
 }
-interface UpdateTransactionCache {
+interface AddressForTransactionsCache {
     [key: string]: {
         processing: boolean;
+        path: ChangePath;
+        page: number;
+        blockHeight: number;
     };
 }
-interface UpdateTransactionSpecificCache {
+interface AddressForUtxosCache {
     [key: string]: {
         processing: boolean;
+        path: ChangePath;
     };
 }
 interface AddressSubscribeCache {
@@ -74,45 +75,46 @@ interface AddressSubscribeCache {
         path: ChangePath;
     };
 }
-interface AddressUtxoCache {
+interface DataLayerUtxoCache {
     [key: string]: {
         processing: boolean;
+        full: boolean;
+        utxos: UtxoData[];
         path: ChangePath;
     };
 }
-interface ProcessorUtxoCache {
+interface BlockbookUtxoCache {
     [key: string]: {
+        blockbookUtxo: BlockbookAccountUtxo;
         processing: boolean;
-        full: boolean;
-        utxos: IUTXO[];
         path: ChangePath;
+        address: AddressData;
+        requiredCount: number;
     };
 }
-interface RawUtxoCache {
+interface TransactionSpecificUpdateCache {
     [key: string]: {
-        blockbookUtxo: BlockbookAccountUtxo;
         processing: boolean;
-        path: ChangePath;
-        address: IAddress;
-        requiredCount: number;
     };
 }
-interface AddressTransactionCache {
+interface TransactionUpdateCache {
     [key: string]: {
         processing: boolean;
-        path: ChangePath;
-        page: number;
-        blockHeight: number;
     };
 }
-interface TransactionChangedArgs {
-    walletId: string;
-    tx: IProcessorTransaction;
+export declare const transactionChanged: (args: {
+    dataLayer: DataLayer;
     emitter: EngineEmitter;
-    walletTools: UtxoWalletTools;
     pluginInfo: PluginInfo;
-    processor: Processor;
-}
-export declare const transactionChanged: (args: TransactionChangedArgs) => Promise<void>;
-export declare const pickNextTask: (args: CommonArgs, serverUri: string) => Promise<WsTask<any> | undefined | boolean>;
+    tx: TransactionData;
+    walletTools: UtxoWalletTools;
+    walletId: string;
+}) => Promise<void>;
+/**
+ * The pickNextTask generator is responsible for selecting the next WsTask
+ * to be done by the network layer. It will yield WsTasks or booleans for early
+ * exit, and it will return a boolean when it's done.
+ */
+declare type PickNextTaskGenerator = AsyncGenerator<boolean | WsTask<unknown>, boolean, AddressUtxosResponse & AddressResponse & TransactionResponse>;
+export declare function pickNextTask(common: CommonParams, serverUri: string): PickNextTaskGenerator;
 export {};

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

@@ -1,9 +1,9 @@
 import { EdgeSpendInfo } from 'edge-core-js/types';
 import { Input, Output } from '../keymanager/utxopicker/types';
-export declare type UtxoInitOptions = ReturnType<typeof asUtxoInitOptions>;
-export declare const asUtxoInitOptions: import("cleaners").ObjectCleaner<{
-    nowNodeApiKey: string | undefined;
-}>;
+export interface UtxoInitOptions {
+    nowNodesApiKey?: string;
+}
+export declare const asUtxoInitOptions: import("cleaners").ObjectCleaner<UtxoInitOptions>;
 export declare const asUtxoUserSettings: import("cleaners").ObjectCleaner<{
     blockbookServers: string[];
     enableCustomServers: boolean;

package/lib/src/common/utxobased/engine/util/getOwnUtxosFromTx.d.ts

@@ -1,4 +1,4 @@
 import { EngineInfo } from '../../../plugin/types';
-import { Processor } from '../../db/Processor';
-import { IProcessorTransaction, IUTXO } from '../../db/types';
-export declare const getOwnUtxosFromTx: (engineInfo: EngineInfo, processor: Processor, tx: IProcessorTransaction) => Promise<IUTXO[]>;
+import { DataLayer } from '../../db/DataLayer';
+import { TransactionData, UtxoData } from '../../db/types';
+export declare const getOwnUtxosFromTx: (engineInfo: EngineInfo, dataLayer: DataLayer, tx: TransactionData) => Promise<UtxoData[]>;