edge-currency-plugins 3.2.1 → 3.3.1

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[]>;

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

@@ -1,7 +1,7 @@
 import { Disklet } from 'disklet';
 import { EdgeParsedUri } from 'edge-core-js/types';
 import { ChangePath, CurrencyFormat, EngineInfo } from '../../plugin/types';
-import { IUTXO } from '../db/types';
+import { UtxoData } from '../db/types';
 import { ScriptTemplates } from '../info/scriptTemplates/types';
 import { PrivateKey } from '../keymanager/cleaners';
 import { AddressTypeEnum, BIP43PurposeTypeEnum, ScriptTypeEnum } from '../keymanager/keymanager';
@@ -55,4 +55,4 @@ export declare const parsePathname: (args: {
     pathname: string;
     coin: string;
 }) => EdgeParsedUri;
-export declare const sumUtxos: (utxos: IUTXO[]) => string;
+export declare const sumUtxos: (utxos: UtxoData[]) => string;

package/lib/src/common/utxobased/keymanager/keymanager.d.ts

@@ -1,6 +1,6 @@
 import { EdgeLog, EdgeMemo } from 'edge-core-js/types';
 import { ChangePath, FeeInfo } from '../../plugin/types';
-import { IUTXO } from '../db/types';
+import { UtxoData } from '../db/types';
 import { ScriptTemplate, ScriptTemplates } from '../info/scriptTemplates/types';
 import * as utxopicker from './utxopicker';
 export declare enum BIP43PurposeTypeEnum {
@@ -132,8 +132,8 @@ export interface TxOutput {
     amount: number;
 }
 export interface MakeTxArgs {
-    forceUseUtxo: IUTXO[];
-    utxos: IUTXO[];
+    forceUseUtxo: UtxoData[];
+    utxos: UtxoData[];
     targets: MakeTxTarget[];
     memos: EdgeMemo[];
     feeRate: number;

package/lib/src/common/utxobased/network/Blockbook.d.ts

@@ -1,9 +1,10 @@
 import { Cleaner } from 'cleaners';
 import { EdgeLog, EdgeTransaction } from 'edge-core-js/types';
 import { EngineEmitter } from '../../plugin/EngineEmitter';
+import { UtxoInitOptions } from '../engine/types';
 import { AddressResponse, AddresssMessageParams, AddressUtxosResponse, BlockbookTask, BlockbookTransaction, BroadcastTxResponse, InfoResponse, SubscribeAddressResponse, TransactionResponse } from './blockbookApi';
 import Deferred from './Deferred';
-import { OnQueueSpaceCB, WsResponse, WsTask } from './Socket';
+import { TaskGeneratorFn, WsResponse, WsTaskGenerator } from './Socket';
 import { SocketEmitter } from './SocketEmitter';
 export declare type WatchAddressesCB = (response: SubscribeAddressResponse) => void | Promise<void>;
 export declare type WatchBlocksCB = () => void | Promise<void>;
@@ -18,26 +19,26 @@ export interface Blockbook {
     fetchTransaction: (hash: string) => Promise<TransactionResponse>;
     watchAddresses: (addresses: string[], deferredAddressSub: Deferred<unknown>) => void;
     watchBlocks: (deferredBlockSub: Deferred<unknown>) => void;
-    onQueueSpace: (cb: OnQueueSpaceCB) => void;
     promisifyWsMessage: <T>(message: BlockbookTask<T>) => Promise<T>;
     addressQueryTask: (address: string, params: {
         asBlockbookAddress?: Cleaner<string> | undefined;
         lastQueriedBlockHeight: number;
         page: number;
-    }, deferred: Deferred<AddressResponse>) => WsTask<AddressResponse>;
-    transactionQueryTask: (txId: string, deferred: Deferred<BlockbookTransaction>) => WsTask<BlockbookTransaction>;
-    transactionSpecialQueryTask: (txId: string, deferred: Deferred<unknown>) => WsTask<unknown>;
+    }) => WsTaskGenerator<AddressResponse>;
+    transactionQueryTask: (txId: string) => WsTaskGenerator<BlockbookTransaction>;
+    transactionSpecialQueryTask: (txId: string) => WsTaskGenerator<unknown>;
     utxoListQueryTask: (address: string, params: {
         asBlockbookAddress?: Cleaner<string> | undefined;
-    }, deferred: Deferred<AddressUtxosResponse>) => WsTask<AddressUtxosResponse>;
+    }) => WsTaskGenerator<AddressUtxosResponse>;
 }
 interface BlockbookConfig {
     asAddress?: Cleaner<string>;
     asResponse?: Cleaner<WsResponse>;
     connectionUri: string;
     engineEmitter: EngineEmitter;
+    initOptions: UtxoInitOptions;
     log: EdgeLog;
-    onQueueSpaceCB: OnQueueSpaceCB;
+    taskGeneratorFn: TaskGeneratorFn;
     ping?: () => Promise<void>;
     socketEmitter: SocketEmitter;
     walletId: string;

package/lib/src/common/utxobased/network/BlockbookElectrum.d.ts

@@ -2,15 +2,17 @@ import { Cleaner } from 'cleaners';
 import { EdgeLog } from 'edge-core-js/types';
 import { EngineEmitter } from '../../plugin/EngineEmitter';
 import { PluginInfo } from '../../plugin/types';
+import { UtxoInitOptions } from '../engine/types';
 import { Blockbook } from './Blockbook';
-import { OnQueueSpaceCB } from './Socket';
+import { TaskGeneratorFn } from './Socket';
 import { SocketEmitter } from './SocketEmitter';
 export interface BlockbookElectrumConfig {
     asAddress?: Cleaner<string>;
     connectionUri: string;
     engineEmitter: EngineEmitter;
+    initOptions: UtxoInitOptions;
     log: EdgeLog;
-    onQueueSpaceCB: OnQueueSpaceCB;
+    taskGeneratorFn: TaskGeneratorFn;
     pluginInfo: PluginInfo;
     socketEmitter: SocketEmitter;
     walletId: string;

package/lib/src/common/utxobased/network/Socket.d.ts

@@ -1,5 +1,6 @@
 import { Cleaner } from 'cleaners';
 import { EdgeLog } from 'edge-core-js/types';
+import { UtxoInitOptions } from '../engine/types';
 import Deferred from './Deferred';
 import { SocketEmitter } from './SocketEmitter';
 import { ReadyState } from './types';
@@ -7,9 +8,10 @@ export declare type OnFailHandler = (error: Error) => void;
 export interface WsTask<T> {
     method: string;
     params: unknown;
-    deferred: Deferred<T>;
     cleaner?: Cleaner<T>;
 }
+export declare type WsTaskGenerator<T> = Generator<WsTask<T>, T, T>;
+export declare type WsTaskAsyncGenerator<T> = AsyncGenerator<WsTask<T> | boolean, boolean, T>;
 export interface WsSubscription<T> {
     method: string;
     params: unknown;
@@ -22,21 +24,21 @@ export interface Socket {
     readyState: ReadyState;
     connect: () => Promise<void>;
     disconnect: () => void;
-    submitTask: <T>(task: WsTask<T>) => void;
-    onQueueSpace: (cb: OnQueueSpaceCB) => void;
+    submitTask: <T>(task: WsTask<T>, generator: WsTaskAsyncGenerator<T>) => void;
     subscribe: <T>(subscription: WsSubscription<T>) => void;
     isConnected: () => boolean;
 }
-export declare type OnQueueSpaceCB = (uri: string) => Promise<WsTask<unknown> | boolean | undefined>;
+export declare type TaskGeneratorFn = (uri: string) => WsTaskAsyncGenerator<unknown>;
 interface SocketConfig {
     asResponse?: Cleaner<WsResponse>;
+    emitter: SocketEmitter;
+    healthCheck: () => Promise<void>;
+    initOptions: UtxoInitOptions;
+    log: EdgeLog;
     queueSize?: number;
+    taskGeneratorFn: TaskGeneratorFn;
     timeout?: number;
     walletId: string;
-    emitter: SocketEmitter;
-    log: EdgeLog;
-    healthCheck: () => Promise<void>;
-    onQueueSpaceCB: OnQueueSpaceCB;
 }
 export declare type WsResponse = WsResponseMessage[];
 export interface WsResponseMessage {

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

@@ -1,7 +1,11 @@
 export interface InnerSocketCallbacks {
-    onError: (error?: unknown) => void;
+    /**
+     * Called when the socket closes.
+     * See rfc6455 section 7.4.1 for status codes.
+     */
+    onClose: (code: number, reason: string) => void;
+    onError: (error?: Event | Error) => void;
     onMessage: (message: string) => void;
-    onClose: (error?: Error) => void;
     onOpen: () => void;
 }
 export declare enum ReadyState {

package/lib/src/util/uriKeyParams.d.ts

@@ -0,0 +1,4 @@
+export declare function getUriKeyParams(uri: string): string[];
+export declare function replaceKeyParams<T extends string>(uri: string, options: {
+    [P in T]?: string;
+}): string;

package/lib/util/uriKeyParams.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function getUriKeyParams(uri) {
+  const params = uri.match(/%\{(\w|\d)+\}/g)
+  return _nullishCoalesce(params, () => ( []))
+} exports.getUriKeyParams = getUriKeyParams;
+
+ function replaceKeyParams(
+  uri,
+  options
+) {
+  const keyParams = getUriKeyParams(uri)
+
+  for (const keyParam of keyParams) {
+    const keyIndex = keyParam.replace(/%|{|}/g, '') 
+    const key = options[keyIndex]
+    if (key == null) throw new Error(`Missing key for connection URI ${uri}`)
+    uri = uri.replace(keyParam, key)
+  }
+
+  return uri
+} exports.replaceKeyParams = replaceKeyParams;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edge-currency-plugins",
-  "version": "3.2.1",
+  "version": "3.3.1",
   "description": "Edge currency plugins to fetch and process wallet accounts, balances and transactions.",
   "homepage": "https://edge.app/",
   "repository": "https://github.com/EdgeApp/edge-currency-plugins",
@@ -120,4 +120,4 @@
     "wif": "^2.0.6"
   },
   "react-native": "./lib/react-native.js"
-}
+}