edge-currency-plugins 1.0.0-rc.1

package/lib/src/common/fees/processInfoServerFees.d.ts

@@ -0,0 +1,7 @@
+import { SimpleFeeSettings } from '../plugin/types';
+/**
+ * Processes the fee object from Edge Info Server
+ * @param fees
+ * @returns {SimpleFeeSettings}
+ */
+export declare const processInfoServerFees: (fees: unknown) => SimpleFeeSettings | null;

package/lib/src/common/fees/processMempoolSpaceFees.d.ts

@@ -0,0 +1,13 @@
+import { FeeRates } from '../plugin/types';
+export declare const asMempoolSpaceFees: import("cleaners").ObjectCleaner<{
+    fastestFee: number;
+    halfHourFee: number;
+    hourFee: number;
+}>;
+/**
+ * Calculates the FeeRates object from MempoolSpace
+ * Sets the minimum of LOW_FEE on all fee levels
+ * @param fees
+ * @returns Partial<FeeRates>
+ */
+export declare const processMempoolSpaceFees: (fees: unknown) => FeeRates | null;

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

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+import { PluginInfo } from './types';
+export declare function makeCurrencyPlugin(pluginOptions: EdgeCorePluginOptions, pluginInfo: PluginInfo): EdgeCurrencyPlugin;

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

@@ -0,0 +1,8 @@
+import { EdgeCurrencyTools, EdgeIo } from 'edge-core-js/types';
+import { PluginInfo } from './types';
+/**
+ * The core currency plugin.
+ * Provides information about the currency,
+ * as well as generic (non-wallet) functionality.
+ */
+export declare function makeCurrencyTools(io: EdgeIo, pluginInfo: PluginInfo): EdgeCurrencyTools;

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

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { EdgeCurrencyEngineCallbacks, EdgeTransaction, EdgeTxidMap } from 'edge-core-js/types';
+import { EventEmitter } from 'events';
+import { SubscribeAddressResponse } from '../utxobased/network/BlockBookAPI';
+export declare interface EngineEmitter {
+    emit: ((event: EngineEvent.TRANSACTIONS_CHANGED, transactions: EdgeTransaction[]) => boolean) & ((event: EngineEvent.ADDRESS_BALANCE_CHANGED, currencyCode: string, nativeDiff: string) => boolean) & ((event: EngineEvent.WALLET_BALANCE_CHANGED, currencyCode: string, nativeBalance: string) => boolean) & ((event: EngineEvent.BLOCK_HEIGHT_CHANGED, uri: string, blockHeight: number) => boolean) & ((event: EngineEvent.NEW_ADDRESS_TRANSACTION, uri: string, newTx: SubscribeAddressResponse) => boolean) & ((event: EngineEvent.ADDRESSES_CHECKED, progressRatio: number) => boolean) & ((event: EngineEvent.TXIDS_CHANGED, txids: EdgeTxidMap) => boolean);
+    on: ((event: EngineEvent.TRANSACTIONS_CHANGED, listener: (transactions: EdgeTransaction[]) => Promise<void> | void) => this) & ((event: EngineEvent.ADDRESS_BALANCE_CHANGED, listener: (currencyCode: string, nativeDiff: string) => Promise<void> | void) => this) & ((event: EngineEvent.WALLET_BALANCE_CHANGED, listener: (currencyCode: string, nativeBalance: string) => Promise<void> | void) => this) & ((event: EngineEvent.BLOCK_HEIGHT_CHANGED, listener: (uri: string, blockHeight: number) => Promise<void> | void) => this) & ((event: EngineEvent.NEW_ADDRESS_TRANSACTION, listener: (uri: string, newTx: SubscribeAddressResponse) => Promise<void> | void) => this) & ((event: EngineEvent.ADDRESSES_CHECKED, listener: (progressRatio: number) => Promise<void> | void) => this) & ((event: EngineEvent.TXIDS_CHANGED, listener: (txids: EdgeTxidMap) => Promise<void> | void) => this);
+}
+export declare class EngineEmitter extends EventEmitter {
+}
+export declare enum EngineEvent {
+    TRANSACTIONS_CHANGED = "transactions:changed",
+    WALLET_BALANCE_CHANGED = "wallet:balance:changed",
+    ADDRESS_BALANCE_CHANGED = "address:balance:changed",
+    BLOCK_HEIGHT_CHANGED = "block:height:changed",
+    NEW_ADDRESS_TRANSACTION = "address:transaction:changed",
+    ADDRESSES_CHECKED = "addresses:checked",
+    TXIDS_CHANGED = "txids:changed",
+    CONNECTION_OPEN = "connection:open",
+    CONNECTION_CLOSE = "connection:close",
+    CONNECTION_TIMER = "connection:timer"
+}
+export declare const makeEngineEmitter: (callbacks: EdgeCurrencyEngineCallbacks) => EngineEmitter;

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

@@ -0,0 +1,14 @@
+import { Disklet } from 'disklet';
+import { EdgeLog } from 'edge-core-js/types';
+import { EngineEmitter } from './makeEngineEmitter';
+import { LocalWalletMetadata } from './types';
+interface MetadataConfig {
+    disklet: Disklet;
+    emitter: EngineEmitter;
+    log: EdgeLog;
+}
+export interface Metadata extends LocalWalletMetadata {
+    clear: () => Promise<void>;
+}
+export declare const makeMetadata: (config: MetadataConfig) => Promise<Metadata>;
+export {};

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

@@ -0,0 +1,34 @@
+import { Disklet } from 'disklet';
+import { EdgeIo, EdgeLog } from 'edge-core-js/types';
+import { UtxoEngineState } from '../utxobased/engine/makeUtxoEngineState';
+import { UtxoUserSettings } from '../utxobased/engine/types';
+/** A JSON object (as opposed to an array or primitive). */
+interface JsonObject {
+    [name: string]: unknown;
+}
+/**
+ * This object holds the plugin-wide per-currency caches.
+ * Engine plugins are responsible for keeping it up to date.
+ */
+export interface PluginStateSettings {
+    io: EdgeIo;
+    defaultSettings: UtxoUserSettings;
+    currencyCode: string;
+    pluginId: string;
+    pluginDisklet: Disklet;
+    log: EdgeLog;
+}
+export interface PluginState {
+    addEngine: (engineState: UtxoEngineState) => void;
+    removeEngine: (engineState: UtxoEngineState) => void;
+    dumpData: () => JsonObject;
+    load: () => Promise<PluginState>;
+    serverScoreDown: (uri: string) => void;
+    serverScoreUp: (uri: string, score: number) => void;
+    clearCache: () => Promise<void>;
+    getLocalServers: (numServersWanted: number, includePatterns: string[]) => string[];
+    refreshServers: () => Promise<void>;
+    updateServers: (settings: UtxoUserSettings) => Promise<void>;
+}
+export declare function makePluginState(settings: PluginStateSettings): PluginState;
+export {};

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

@@ -0,0 +1,61 @@
+import { EdgeLog } from 'edge-core-js/types';
+export declare type ServerInfo = ReturnType<typeof asServerInfo>;
+export declare const asServerInfo: import("cleaners").ObjectCleaner<{
+    serverUrl: string;
+    serverScore: number;
+    responseTime: number;
+    numResponseTimes: number;
+}>;
+export declare type ServerList = ReturnType<typeof asServerList>;
+export declare const asServerList: import("cleaners").Cleaner<{
+    [keys: string]: {
+        serverUrl: string;
+        serverScore: number;
+        responseTime: number;
+        numResponseTimes: number;
+    };
+}>;
+export declare type ServerCache = ReturnType<typeof asServerCache>;
+export declare const asServerCache: import("cleaners").ObjectCleaner<{
+    customServers: {
+        [keys: string]: {
+            serverUrl: any;
+            serverScore: any;
+            responseTime: any;
+            numResponseTimes: any;
+        };
+    };
+    internalServers: {
+        [keys: string]: {
+            serverUrl: any;
+            serverScore: any;
+            responseTime: any;
+            numResponseTimes: any;
+        };
+    };
+}>;
+interface ServerScoresOptions {
+    log: EdgeLog;
+    onDirtyServer?: (serverUrl: string) => void;
+}
+export declare class ServerScores {
+    scoresLastLoaded: number;
+    log: EdgeLog;
+    lastScoreUpTime: number;
+    onDirtyServer: (serverUrl: string) => void;
+    constructor(options: ServerScoresOptions);
+    /**
+     * Loads the server scores with new and old servers, mutates the passed in
+     * list of known servers.
+     * @param knownServers: Map of ServerInfo objects by serverUrl. This should come from disk
+     * @param newServers: Array<string> of new servers downloaded from the info server
+     */
+    serverScoresLoad(knownServers: ServerList, newServers?: string[]): void;
+    clearServerScoreTimes(): void;
+    printServers(servers: ServerList): void;
+    serverScoreUp(servers: ServerList, serverUrl: string, responseTimeMilliseconds: number, changeScore?: number): void;
+    serverScoreDown(servers: ServerList, serverUrl: string, changeScore?: number): void;
+    setResponseTime(servers: ServerList, serverUrl: string, responseTimeMilliseconds: number): void;
+    getServers(servers: ServerList, numServersWanted: number, includePatterns?: string[]): string[];
+}
+export {};

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

@@ -0,0 +1,135 @@
+/// <reference types="node" />
+import { bip32 } from 'altcoin-js';
+import { Cleaner } from 'cleaners';
+import { Disklet } from 'disklet';
+import { EdgeCurrencyEngineOptions, EdgeCurrencyInfo, EdgeCurrencyTools, EdgeIo, EdgeParsedUri, EdgeTransaction, EdgeWalletInfo } from 'edge-core-js/types';
+import { IProcessorTransaction, IUTXO } from '../utxobased/db/types';
+import { ScriptTemplates } from '../utxobased/info/scriptTemplates/types';
+import { UtxoPicker } from '../utxobased/keymanager/utxopicker';
+import { EngineEmitter } from './makeEngineEmitter';
+import { PluginState } from './pluginState';
+export declare type CurrencyFormat = ReturnType<typeof asCurrencyFormat>;
+export declare const asCurrencyFormat: Cleaner<"bip32" | "bip44" | "bip49" | "bip84">;
+export interface ChangePath {
+    format: CurrencyFormat;
+    changeIndex: number;
+}
+export interface AddressPath {
+    format: CurrencyFormat;
+    changeIndex: number;
+    addressIndex: number;
+}
+export interface TxOptions {
+    utxos?: IUTXO[];
+    subtractFee?: boolean;
+    setRBF?: boolean;
+    CPFP?: string;
+}
+export interface PluginInfo {
+    currencyInfo: EdgeCurrencyInfo;
+    engineInfo: EngineInfo;
+    coinInfo: CoinInfo;
+}
+export interface EngineInfo {
+    formats?: CurrencyFormat[];
+    forks?: string[];
+    uriPrefix?: string;
+    gapLimit: number;
+    defaultFee: number;
+    feeUpdateInterval: number;
+    mempoolSpaceFeeInfoServer?: string;
+    simpleFeeSettings: SimpleFeeSettings;
+    scriptTemplates?: ScriptTemplates;
+    asBlockbookAddress?: Cleaner<string>;
+    validateConfirmations?: (txResponse: IProcessorTransaction, blockHeight: number, requiredConfirmations: number | undefined) => EdgeTransaction['confirmations'];
+}
+/**
+ * Coin Info
+ */
+export interface CoinInfo {
+    name: string;
+    segwit: boolean;
+    coinType: number;
+    sighash?: number;
+    sighashFunction?: (Hash: Buffer) => Buffer;
+    txHashFunction?: (Hash: Buffer) => Buffer;
+    bs58DecodeFunc?: (payload: string | undefined) => Buffer;
+    bs58EncodeFunc?: (payload: any) => string;
+    wifEncodeFunc?: (prefix: unknown, key: unknown, compressed: unknown) => string;
+    bip32FromBase58Func?: (xKey: string, network: BitcoinJSNetwork) => bip32.BIP32Interface;
+    bip32FromSeedFunc?: (seed: Buffer) => bip32.BIP32Interface;
+    utxoPicker?: UtxoPicker;
+    prefixes: CoinPrefixes;
+}
+export interface CoinPrefixes {
+    messagePrefix: string[];
+    wif: number[];
+    legacyXPriv: number[];
+    legacyXPub: number[];
+    wrappedSegwitXPriv?: number[];
+    wrappedSegwitXPub?: number[];
+    segwitXPriv?: number[];
+    segwitXPub?: number[];
+    pubkeyHash: number[];
+    scriptHash: number[];
+    bech32?: string[];
+    cashaddr?: string[];
+}
+interface BitcoinJSNetwork {
+    wif: number;
+    bip32: Bip32;
+    messagePrefix: string;
+    bech32: string;
+    pubKeyHash: number;
+    scriptHash: number;
+}
+interface Bip32 {
+    public: number;
+    private: number;
+}
+export interface ExtendedParseUri extends EdgeParsedUri {
+    metadata?: EdgeParsedUri['metadata'] & {
+        gateway?: boolean;
+    };
+}
+export interface EncodeUriMetadata {
+    metadata?: {
+        name?: string;
+        notes?: string;
+        gateway?: boolean;
+    };
+}
+export declare type FeeRates = ReturnType<typeof asFeeRates>;
+export declare const asFeeRates: import("cleaners").ObjectCleaner<{
+    lowFee: string;
+    standardFeeLow: string;
+    standardFeeHigh: string;
+    highFee: string;
+}>;
+export declare type SimpleFeeSettings = ReturnType<typeof asSimpleFeeSettings>;
+export declare const asSimpleFeeSettings: import("cleaners").ObjectCleaner<{
+    standardFeeLowAmount: string;
+    standardFeeHighAmount: string;
+    lowFee: string;
+    standardFeeLow: string;
+    standardFeeHigh: string;
+    highFee: string;
+}>;
+export interface EngineConfig {
+    walletInfo: EdgeWalletInfo;
+    pluginInfo: PluginInfo;
+    pluginDisklet: Disklet;
+    currencyTools: EdgeCurrencyTools;
+    options: EngineOptions;
+    io: EdgeIo;
+    pluginState: PluginState;
+}
+export interface EngineOptions extends EdgeCurrencyEngineOptions {
+    emitter: EngineEmitter;
+}
+export declare type LocalWalletMetadata = ReturnType<typeof asLocalWalletMetadata>;
+export declare const asLocalWalletMetadata: import("cleaners").ObjectCleaner<{
+    balance: string;
+    lastSeenBlockHeight: number;
+}>;
+export {};

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

@@ -0,0 +1,6 @@
+export declare const getFormatsForNetwork: (coinName: string) => string[];
+interface GenericObject<T> {
+    [key: string]: T;
+}
+export declare const removeItem: <T>(obj: GenericObject<T>, key: string) => void;
+export {};

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

@@ -0,0 +1,16 @@
+import { EdgeTransaction } from 'edge-core-js/types';
+import { PluginInfo } from '../../../plugin/types';
+import { UTXOPluginWalletTools } from '../../engine/makeUtxoWalletTools';
+import { Processor } from '../makeProcessor';
+import { IProcessorTransaction } from '../types';
+export declare const fromEdgeTransaction: (tx: EdgeTransaction) => IProcessorTransaction;
+interface ToEdgeTransactionArgs {
+    tx: IProcessorTransaction;
+    currencyCode: string;
+    pluginInfo: PluginInfo;
+    processor: Processor;
+    walletBlockHeight: number;
+    walletTools: UTXOPluginWalletTools;
+}
+export declare const toEdgeTransaction: (args: ToEdgeTransactionArgs) => Promise<EdgeTransaction>;
+export {};

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

@@ -0,0 +1,28 @@
+import { CountBase, CountBaseOptions, HashBase, HashBaseOptions, RangeBase, RangeBaseOptions } from 'baselet';
+import { ChangePath } from '../../../plugin/types';
+import { IAddress, IProcessorTransaction, IUTXO } 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 const addressByScriptPubkeyOptions: HashBaseOptions;
+export declare type LastUsedByFormatPathBaselet = HashBase<number>;
+export declare const lastUsedByFormatPathOptions: HashBaseOptions;
+export interface TxIdByBlockHeight {
+    txid: string;
+    blockHeight: number;
+}
+export declare type TxIdByBlockHeightBaselet = RangeBase<TxIdByBlockHeight, 'blockHeight', 'txid'>;
+export declare const txIdsByBlockHeightOptions: RangeBaseOptions<'blockHeight', 'txid'>;
+export declare type TxByIdBaselet = HashBase<IProcessorTransaction>;
+export declare const txByIdOptions: HashBaseOptions;
+export interface TxIdByDate {
+    txid: string;
+    date: number;
+}
+export declare type TxIdByDateBaselet = RangeBase<TxIdByDate, 'date', 'txid'>;
+export declare const txIdsByDateOptions: RangeBaseOptions<'date', 'txid'>;
+export declare type UtxoByIdBaselet = HashBase<IUTXO>;
+export declare const utxoByIdOptions: HashBaseOptions;
+export declare type UtxoIdsByScriptPubkeyBaselet = HashBase<string[]>;
+export declare const utxoIdsByScriptPubkeyOptions: HashBaseOptions;

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

@@ -0,0 +1,33 @@
+import { Disklet } from 'disklet';
+import { AddressByScriptPubkeyBaselet, LastUsedByFormatPathBaselet, ScriptPubkeyByPathBaselet, TxByIdBaselet, TxIdByBlockHeightBaselet, TxIdByDateBaselet, UtxoByIdBaselet, UtxoIdsByScriptPubkeyBaselet } from './Models/baselet';
+interface MakeBaseletsConfig {
+    disklet: Disklet;
+}
+declare type Executor<BaseletName extends keyof AllBaselets> = (tables: AllBaselets[BaseletName]) => Promise<unknown>;
+interface AllBaselets {
+    address: AddressBaselets;
+    tx: TransactionBaselets;
+    utxo: UtxoBaselets;
+}
+interface AddressBaselets {
+    addressByScriptPubkey: AddressByScriptPubkeyBaselet;
+    scriptPubkeyByPath: ScriptPubkeyByPathBaselet;
+    lastUsedByFormatPath: LastUsedByFormatPathBaselet;
+}
+interface TransactionBaselets {
+    txById: TxByIdBaselet;
+    txIdsByBlockHeight: TxIdByBlockHeightBaselet;
+    txIdsByDate: TxIdByDateBaselet;
+}
+interface UtxoBaselets {
+    utxoById: UtxoByIdBaselet;
+    utxoIdsByScriptPubkey: UtxoIdsByScriptPubkeyBaselet;
+}
+export interface Baselets {
+    address: <E extends Executor<'address'>>(fn: E) => Promise<ReturnType<E>>;
+    tx: <E extends Executor<'tx'>>(fn: E) => Promise<ReturnType<E>>;
+    utxo: <E extends Executor<'utxo'>>(fn: E) => Promise<ReturnType<E>>;
+    all: AddressBaselets & TransactionBaselets & UtxoBaselets;
+}
+export declare const makeBaselets: (config: MakeBaseletsConfig) => Promise<Baselets>;
+export {};

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

@@ -0,0 +1,3 @@
+declare type Mutex = <T>(callback: () => Promise<T>) => Promise<T>;
+export declare function makeMutex(): Mutex;
+export {};

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

@@ -0,0 +1,42 @@
+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 {
+    disklet: Disklet;
+}
+interface SaveTransactionArgs {
+    tx: IProcessorTransaction;
+    scriptPubkeys?: string[];
+}
+interface FetchTransactionArgs {
+    blockHeight?: number;
+    blockHeightMax?: number;
+    txId?: string;
+    options?: EdgeGetTransactionsOptions;
+}
+interface FetchUtxosArgs {
+    utxoIds?: string[];
+    scriptPubkey?: string;
+}
+interface DumpDataReturn {
+    databaseName: string;
+    data: unknown;
+}
+export interface Processor {
+    clearAll: () => Promise<void>;
+    dumpData: () => Promise<DumpDataReturn[]>;
+    saveUtxo: (utxo: IUTXO) => Promise<void>;
+    removeUtxos: (utxoIds: string[]) => Promise<void>;
+    fetchUtxos: (args: FetchUtxosArgs) => Promise<Array<IUTXO | undefined>>;
+    saveTransaction: (args: SaveTransactionArgs) => Promise<IProcessorTransaction>;
+    numTransactions: () => number;
+    removeTransaction: (txId: string) => Promise<void>;
+    fetchTransactions: (args: FetchTransactionArgs) => Promise<Array<IProcessorTransaction | undefined>>;
+    saveAddress: (args: IAddress) => Promise<void>;
+    numAddressesByFormatPath: (path: ChangePath) => number;
+    lastUsedIndexByFormatPath: (path: ChangePath) => Promise<number>;
+    fetchAddress: (args: AddressPath | string) => Promise<IAddress | undefined>;
+}
+export declare function makeProcessor(config: ProcessorConfig): Promise<Processor>;
+export {};

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

@@ -0,0 +1,47 @@
+import { SoftPick } from '../../../util/typeUtil';
+import { AddressPath } from '../../plugin/types';
+import { ScriptTypeEnum } from '../keymanager/keymanager';
+export interface IAddress {
+    scriptPubkey: string;
+    redeemScript?: string;
+    lastQueriedBlockHeight: number;
+    path?: AddressPath;
+    lastQuery: number;
+    lastTouched: number;
+    used: boolean;
+    balance: string;
+}
+export declare const makeIAddress: (addressFields: SoftPick<IAddress, 'scriptPubkey'>) => IAddress;
+export interface IUTXO {
+    id: string;
+    txid: string;
+    vout: number;
+    value: string;
+    scriptPubkey: string;
+    script: string;
+    redeemScript?: string;
+    scriptType: ScriptTypeEnum;
+    blockHeight: number;
+    spent: boolean;
+}
+export interface IProcessorTransaction {
+    txid: string;
+    hex: string;
+    blockHeight: number;
+    date: number;
+    fees: string;
+    inputs: ITransactionInput[];
+    outputs: ITransactionOutput[];
+    ourIns: string[];
+    ourOuts: string[];
+    ourAmount: string;
+}
+export interface ITransactionOutput {
+    amount: string;
+    scriptPubkey: string;
+    n: number;
+}
+export interface ITransactionInput extends ITransactionOutput {
+    txId: string;
+    outputIndex: number;
+}

package/lib/src/common/utxobased/engine/await-lock.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A mutex lock for coordination across async functions
+ */
+export default class AwaitLock {
+    private _acquired;
+    private readonly _waitingResolvers;
+    /**
+     * Whether the lock is currently acquired or not. Accessing this property does not affect the
+     * status of the lock.
+     */
+    get acquired(): boolean;
+    /**
+     * Acquires the lock, waiting if necessary for it to become free if it is already locked. The
+     * returned promise is fulfilled once the lock is acquired.
+     *
+     * After acquiring the lock, you **must** call `release` when you are done with it.
+     */
+    acquireAsync(): Promise<void>;
+    /**
+     * Acquires the lock if it is free and otherwise returns immediately without waiting. Returns
+     * `true` if the lock was free and is now acquired, and `false` otherwise,
+     */
+    tryAcquire(): boolean;
+    /**
+     * Releases the lock and gives it to the next waiting acquirer, if there is one. Each acquirer
+     * must release the lock exactly once.
+     */
+    release(): void;
+}

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

@@ -0,0 +1,4 @@
+export declare const BLOCKBOOK_TXS_PER_PAGE = 100;
+export declare const CACHE_THROTTLE = 0.05;
+export declare const MAX_CONNECTIONS = 2;
+export declare const NEW_CONNECTIONS = 8;

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

@@ -0,0 +1,37 @@
+import { EdgeLog, EdgeTransaction } from 'edge-core-js/types';
+import { EngineEmitter } from '../../plugin/makeEngineEmitter';
+import { PluginState } from '../../plugin/pluginState';
+import { PluginInfo } from '../../plugin/types';
+import { NumbWalletInfo } from '../keymanager/cleaners';
+import Deferred from '../network/Deferred';
+import { WsTask } from '../network/Socket';
+interface ServerState {
+    blockSubscriptionStatus: 'unsubscribed' | 'subscribing' | 'subscribed';
+    blockHeight: number;
+    txids: Set<string>;
+    addresses: Set<string>;
+}
+interface ServerStateConfig {
+    engineEmitter: EngineEmitter;
+    log: EdgeLog;
+    pluginInfo: PluginInfo;
+    pluginState: PluginState;
+    walletInfo: NumbWalletInfo;
+}
+export interface ServerStates {
+    setPickNextTaskCB: (callback: (uri: string) => Promise<boolean | WsTask<any> | undefined>) => void;
+    stop: () => void;
+    serverCanGetTx: (uri: string, txid: string) => boolean;
+    serverCanGetAddress: (uri: string, address: string) => boolean;
+    serverScoreUp: (uri: string, score: number) => void;
+    getServerState: (uri: string) => ServerState | undefined;
+    refillServers: () => void;
+    getServerList: () => string[];
+    setServerList: (updatedServerList: string[]) => void;
+    broadcastTx: (transaction: EdgeTransaction) => Promise<string>;
+    watchAddresses: (uri: string, addresses: string[], deferredAddressSub: Deferred<unknown>) => void;
+    watchBlocks: (uri: string) => void;
+    getBlockHeight: (uri: string) => number;
+}
+export declare function makeServerStates(config: ServerStateConfig): ServerStates;
+export {};

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

@@ -0,0 +1,3 @@
+import { EdgeCurrencyEngine } from 'edge-core-js/types';
+import { EngineConfig } from '../../plugin/types';
+export declare function makeUtxoEngine(config: EngineConfig): Promise<EdgeCurrencyEngine>;