edge-currency-plugins 1.0.0-rc.1

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

@@ -0,0 +1,198 @@
+import { AddressPath } from '../../plugin/types';
+import { IUTXO } from '../db/types';
+import { ScriptTemplate } from '../info/scriptTemplates/types';
+import * as utxopicker from './utxopicker';
+export declare enum BIP43PurposeTypeEnum {
+    Airbitz = "airbitz",
+    Legacy = "legacy",
+    Segwit = "segwit",
+    WrappedSegwit = "wrappedSegwit"
+}
+export declare enum AddressTypeEnum {
+    p2pkh = "p2pkh",
+    p2sh = "p2sh",
+    p2wpkh = "p2wpkh",
+    p2wsh = "p2wsh"
+}
+export declare enum ScriptTypeEnum {
+    p2wpkh = "p2wpkh",
+    p2wpkhp2sh = "p2wpkhp2sh",
+    p2wsh = "p2wsh",
+    p2pk = "p2pk",
+    p2pkh = "p2pkh",
+    p2sh = "p2sh",
+    replayProtection = "replayprotection",
+    replayProtectionP2SH = "replayprotectionp2sh"
+}
+export declare enum TransactionInputTypeEnum {
+    Legacy = "legacy",
+    Segwit = "segwit"
+}
+export interface VerifyAddressArgs {
+    address: string;
+    coin: string;
+}
+export declare enum VerifyAddressEnum {
+    good = "good",
+    legacy = "legacy",
+    bad = "bad"
+}
+export interface SeedOrMnemonicToXPrivArgs {
+    seed: string;
+    type: BIP43PurposeTypeEnum;
+    coinType?: number;
+    account?: number;
+    coin: string;
+}
+export interface XPrivToXPubArgs {
+    xpriv: string;
+    type: BIP43PurposeTypeEnum;
+    coin: string;
+}
+export interface XPrivToPrivateKeyArgs {
+    xpriv: string;
+    type: BIP43PurposeTypeEnum;
+    bip44ChangeIndex: number;
+    bip44AddressIndex: number;
+    coin: string;
+}
+export interface XPubToPubkeyArgs {
+    xpub: string;
+    type: BIP43PurposeTypeEnum;
+    bip44ChangeIndex: number;
+    bip44AddressIndex: number;
+    coin: string;
+}
+export interface AddressToScriptPubkeyArgs {
+    address: string;
+    addressType?: AddressTypeEnum;
+    coin: string;
+}
+export interface PubkeyToScriptPubkeyArgs {
+    pubkey: string;
+    scriptType: ScriptTypeEnum;
+}
+export interface PubkeyToScriptPubkeyReturn {
+    scriptPubkey: string;
+    redeemScript?: string;
+}
+export interface ScriptPubkeyToAddressArgs {
+    scriptPubkey: string;
+    addressType: AddressTypeEnum;
+    coin: string;
+    redeemScript?: string;
+}
+export interface ScriptPubkeyToAddressReturn {
+    address: string;
+    legacyAddress: string;
+}
+export interface ScriptPubkeyToScriptHashArgs {
+    scriptPubkey: string;
+    scriptType: ScriptTypeEnum;
+    coin: string;
+}
+export interface ScriptPubkeyToP2SHArgs {
+    scriptPubkey: string;
+    coin?: string;
+}
+export interface ScriptPubkeyToP2SHReturn {
+    scriptPubkey: string;
+    redeemScript: string;
+    address?: string;
+}
+export interface WIFToPrivateKeyArgs {
+    wifKey: string;
+    coin: string;
+}
+export interface PrivateKeyToWIFArgs {
+    privateKey: string;
+    coin: string;
+}
+export interface TxInput {
+    type: TransactionInputTypeEnum;
+    prevTxid: string;
+    index: number;
+    prevTx?: string;
+    prevScriptPubkey?: string;
+    redeemScript?: string;
+    value?: number;
+}
+export interface TxOutput {
+    scriptPubkey: string;
+    amount: number;
+}
+export interface MakeTxArgs {
+    forceUseUtxo: IUTXO[];
+    utxos: IUTXO[];
+    targets: MakeTxTarget[];
+    feeRate: number;
+    setRBF: boolean;
+    coin: string;
+    freshChangeAddress: string;
+    subtractFee?: boolean;
+}
+export interface MakeTxTarget {
+    address: string;
+    value: number;
+}
+interface MakeTxReturn extends Required<utxopicker.UtxoPickerResult> {
+    hex: string;
+    psbtBase64: string;
+}
+export interface SignTxArgs {
+    privateKeys: string[];
+    psbtBase64: string;
+    coin: string;
+}
+interface SignTxReturn {
+    id: string;
+    hex: string;
+}
+export interface BitcoinJSNetwork {
+    wif: number;
+    bip32: Bip32;
+    messagePrefix: string;
+    bech32: string;
+    pubKeyHash: number;
+    scriptHash: number;
+}
+export interface Bip32 {
+    public: number;
+    private: number;
+}
+export declare function bip43PurposeNumberToTypeEnum(num: number): BIP43PurposeTypeEnum;
+export interface SelectedCoinPrefixes {
+    messagePrefix: string;
+    wif: number;
+    legacyXPriv: number;
+    legacyXPub: number;
+    wrappedSegwitXPriv?: number;
+    wrappedSegwitXPub?: number;
+    segwitXPriv?: number;
+    segwitXPub?: number;
+    pubkeyHash: number;
+    scriptHash: number;
+    bech32?: string;
+    cashaddr?: string;
+}
+export declare const verifyAddress: (args: VerifyAddressArgs) => VerifyAddressEnum;
+export declare const getAddressTypeFromAddress: (address: string, coinName: string) => AddressTypeEnum;
+export declare function seedOrMnemonicToXPriv(args: SeedOrMnemonicToXPrivArgs): string;
+export declare const xprivToXPub: (args: XPrivToXPubArgs) => string;
+export declare function derivationLevelScriptHash(scriptTemplate: ScriptTemplate): number;
+export declare const isPathUsingDerivationLevelScriptHash: (scriptTemplate: ScriptTemplate, path: AddressPath) => boolean;
+export declare const xpubToPubkey: (args: XPubToPubkeyArgs) => string;
+export declare const addressToScriptPubkey: (args: AddressToScriptPubkeyArgs) => string;
+export declare function scriptPubkeyToAddress(args: ScriptPubkeyToAddressArgs): ScriptPubkeyToAddressReturn;
+export declare function scriptPubkeyToScriptHash(args: ScriptPubkeyToScriptHashArgs): string;
+export declare function scriptPubkeyToP2SH(args: ScriptPubkeyToP2SHArgs): ScriptPubkeyToP2SHReturn;
+export declare function pubkeyToScriptPubkey(args: PubkeyToScriptPubkeyArgs): PubkeyToScriptPubkeyReturn;
+export declare const toNewFormat: (address: string, coinName: string) => string;
+export declare const xprivToPrivateKey: (args: XPrivToPrivateKeyArgs) => string;
+export declare function privateKeyToWIF(args: PrivateKeyToWIFArgs): string;
+export declare const wifToPrivateKey: (args: WIFToPrivateKeyArgs) => string;
+export declare function privateKeyToPubkey(privateKey: string): string;
+export declare function signMessageBase64(message: string, privateKey: string): string;
+export declare function makeTx(args: MakeTxArgs): Promise<MakeTxReturn>;
+export declare function signTx(args: SignTxArgs): Promise<SignTxReturn>;
+export {};

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

@@ -0,0 +1,2 @@
+import { UtxoPickerArgs, UtxoPickerResult } from './types';
+export declare function accumulative(args: UtxoPickerArgs): UtxoPickerResult;

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

@@ -0,0 +1,2 @@
+import { UtxoPickerArgs, UtxoPickerResult } from './types';
+export declare function forceUseUtxo(args: UtxoPickerArgs): UtxoPickerResult;

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

@@ -0,0 +1,2 @@
+import { UtxoPickerArgs, UtxoPickerResult } from './types';
+export declare function subtractFee(args: UtxoPickerArgs): UtxoPickerResult;

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

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { PsbtInput } from 'bip174/src/lib/interfaces';
+import { ScriptTypeEnum } from '../keymanager';
+export declare type Input = UTXO;
+export interface UTXO extends PsbtInput {
+    hash: Buffer;
+    index: number;
+    sequence?: number;
+    value: number;
+    script: Buffer;
+    scriptPubkey: Buffer;
+    scriptType: ScriptTypeEnum;
+}
+export interface Output {
+    script: Buffer;
+    scriptPubkey: Buffer;
+    value: number;
+}
+export interface Target {
+    script: string;
+    value: number;
+}
+export interface UtxoPickerArgs {
+    utxos: UTXO[];
+    useUtxos?: UTXO[];
+    targets: Target[];
+    feeRate: number;
+    changeScript: string;
+}
+export interface UtxoPickerResult {
+    inputs?: Input[];
+    outputs?: Output[];
+    changeUsed: boolean;
+    fee: number;
+}
+export declare type UtxoPickingFunc = (args: UtxoPickerArgs) => UtxoPickerResult;

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

@@ -0,0 +1,15 @@
+import { Input, Output, UTXO, UtxoPickerResult } from './types';
+export declare const compactSize: (num: number) => number;
+export declare const withCompactSize: (num: number) => number;
+export declare function inputBytes(input: UTXO): number;
+export declare function outputBytes(output: Output): number;
+export declare function dustThreshold(output: Output, feeRate: number): number;
+export declare function transactionBytes(inputs: UTXO[], outputs: Output[]): number;
+export declare function uintOrNaN(v: number): number;
+export declare function sumForgiving(range: Array<{
+    value: number;
+}>): number;
+export declare function sumOrNaN(range: Array<{
+    value: number;
+}>): number;
+export declare function finalize(inputs: Input[], outputs: Output[], feeRate: number, changeScript: string): UtxoPickerResult;

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

@@ -0,0 +1,8 @@
+import { UtxoPickingFunc } from './utxopicker/types';
+export * from './utxopicker/types';
+export interface UtxoPicker {
+    forceUseUtxo: UtxoPickingFunc;
+    subtractFee: UtxoPickingFunc;
+    accumulative: UtxoPickingFunc;
+}
+export declare const utxoPicker: UtxoPicker;

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

@@ -0,0 +1,33 @@
+import { Cleaner } from 'cleaners';
+import { EdgeLog, EdgeTransaction } from 'edge-core-js/types';
+import { EngineEmitter } from '../../plugin/makeEngineEmitter';
+import { AddressResponse, AddresssMessageParams, AddressUtxosResponse, BroadcastTxResponse, InfoResponse, SubscribeAddressResponse, TransactionResponse } from './BlockBookAPI';
+import Deferred from './Deferred';
+import { SocketEmitter } from './MakeSocketEmitter';
+import { OnQueueSpaceCB } from './Socket';
+export declare type WatchAddressesCB = (response: SubscribeAddressResponse) => void | Promise<void>;
+export declare type WatchBlocksCB = () => void | Promise<void>;
+export interface BlockBook {
+    isConnected: boolean;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    onQueueSpace: (cb: OnQueueSpaceCB) => void;
+    fetchInfo: () => Promise<InfoResponse>;
+    fetchAddress: (address: string, params?: AddresssMessageParams) => Promise<AddressResponse>;
+    watchAddresses: (addresses: string[], deferredAddressSub: Deferred<unknown>) => void;
+    watchBlocks: (deferredBlockSub: Deferred<unknown>) => void;
+    fetchAddressUtxos: (account: string) => Promise<AddressUtxosResponse>;
+    fetchTransaction: (hash: string) => Promise<TransactionResponse>;
+    broadcastTx: (transaction: EdgeTransaction) => Promise<BroadcastTxResponse>;
+}
+interface BlockBookConfig {
+    socketEmitter: SocketEmitter;
+    engineEmitter: EngineEmitter;
+    wsAddress: string;
+    log: EdgeLog;
+    walletId: string;
+    onQueueSpaceCB: OnQueueSpaceCB;
+    asAddress?: Cleaner<string>;
+}
+export declare function makeBlockBook(config: BlockBookConfig): BlockBook;
+export {};

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

@@ -0,0 +1,163 @@
+import { Cleaner } from 'cleaners';
+import { EdgeTransaction } from 'edge-core-js/types';
+/**
+ * Websocket Task
+ */
+export interface BlockbookTask<T> {
+    method: string;
+    params: unknown;
+    cleaner: Cleaner<T>;
+}
+export interface BlockbookAccountUtxo {
+    txid: string;
+    vout: number;
+    value: string;
+    confirmations?: number;
+    coinbase?: boolean;
+    height?: number;
+    lockTime?: number;
+    address?: string;
+    path?: string;
+}
+export declare const asBlockbookAccountUtxo: (asAddress?: Cleaner<string>) => Cleaner<BlockbookAccountUtxo>;
+export interface BlockbookTransaction {
+    txid: string;
+    hex: string;
+    blockHeight: number;
+    confirmations: number;
+    blockTime: number;
+    fees: string;
+    vin: Array<{
+        txid: string;
+        sequence?: number;
+        n: number;
+        vout: number;
+        addresses: string[];
+        isAddress: boolean;
+        value: string;
+        hex?: string;
+    }>;
+    vout: Array<{
+        n: number;
+        value: string;
+        addresses: string[];
+        hex?: string;
+    }>;
+}
+export declare const asBlockbookTransaction: (asAddress?: Cleaner<string>) => Cleaner<BlockbookTransaction>;
+/**
+ * Error Response
+ */
+export declare type BlockbookErrorResponse = ReturnType<typeof asBlockbookErrorResponse>;
+export declare const asBlockbookErrorResponse: import("cleaners").ObjectCleaner<{
+    error: {
+        message: any;
+    };
+}>;
+/**
+ * Blockbook Response Generic
+ */
+export declare type BlockbookResponse<T> = T;
+export declare const asBlockbookResponse: <T>(asT: Cleaner<T>) => Cleaner<T>;
+/**
+ * Ping Message
+ */
+export declare const pingMessage: () => BlockbookTask<PingResponse>;
+export declare type PingResponse = ReturnType<typeof asPingResponse>;
+export declare const asPingResponse: import("cleaners").ObjectCleaner<object>;
+/**
+ * Get Info
+ */
+export declare const infoMessage: () => BlockbookTask<InfoResponse>;
+export declare type InfoResponse = ReturnType<typeof asInfoResponse>;
+export declare const asInfoResponse: import("cleaners").ObjectCleaner<{
+    name: string;
+    shortcut: string;
+    decimals: number;
+    version: string;
+    bestHeight: number;
+    bestHash: string;
+    block0Hash: string;
+    testnet: boolean;
+    backend: {
+        version: any;
+        subversion: any;
+    } | undefined;
+}>;
+/**
+ * Get Account UTXO
+ */
+export declare const addressUtxosMessage: (address: string, asAddress?: Cleaner<string>) => BlockbookTask<AddressUtxosResponse>;
+export declare type AddressUtxosResponse = BlockbookAccountUtxo[];
+export declare const asAddressUtxosResponse: (asAddress?: Cleaner<string>) => Cleaner<AddressUtxosResponse>;
+/**
+ * Get Transaction
+ */
+export declare const transactionMessage: (hash: string, asAddress?: Cleaner<string>) => BlockbookTask<TransactionResponse>;
+export declare type TransactionResponse = BlockbookTransaction;
+export declare const asTransactionResponse: (asAddress?: Cleaner<string>) => Cleaner<BlockbookTransaction>;
+/**
+ * Send Transaction
+ */
+export declare const broadcastTxMessage: (transaction: EdgeTransaction) => BlockbookTask<BroadcastTxResponse>;
+export declare type BroadcastTxResponse = ReturnType<typeof asBroadcastTxResponse>;
+export declare const asBroadcastTxResponse: import("cleaners").ObjectCleaner<{
+    result: string;
+}>;
+/**
+ * Get Account Info
+ */
+export interface AddresssMessageParams {
+    details?: 'basic' | 'txids' | 'txs';
+    from?: number;
+    to?: number;
+    page?: number;
+    pageSize?: number;
+}
+export declare const addressMessage: (address: string, asAddress?: Cleaner<string>, params?: AddresssMessageParams) => BlockbookTask<AddressResponse>;
+export interface AddressResponse {
+    address: string;
+    balance: string;
+    totalReceived: string;
+    totalSent: string;
+    txs: number;
+    unconfirmedBalance: string;
+    unconfirmedTxs: number;
+    txids: string[];
+    transactions: BlockbookTransaction[];
+    page: number;
+    totalPages: number;
+    itemsOnPage: number;
+}
+export declare const asAddressResponse: (asAddress?: Cleaner<string>) => import("cleaners").ObjectCleaner<{
+    address: string;
+    balance: string;
+    totalReceived: string;
+    totalSent: string;
+    txs: number;
+    unconfirmedBalance: string;
+    unconfirmedTxs: number;
+    txids: string[];
+    transactions: BlockbookTransaction[];
+    page: number;
+    totalPages: number;
+    itemsOnPage: number;
+}>;
+/**
+ * Subscribe New Block
+ */
+export declare const subscribeNewBlockMessage: () => BlockbookTask<SubscribeNewBlockResponse>;
+export declare type SubscribeNewBlockResponse = ReturnType<typeof asSubscribeNewBlockResponse>;
+export declare const asSubscribeNewBlockResponse: import("cleaners").ObjectCleaner<{
+    height: number;
+    hash: string;
+}>;
+/**
+ * Subscribe Address
+ */
+export declare const subscribeAddressesMessage: (addresses: string[], asAddress?: Cleaner<string>) => BlockbookTask<SubscribeAddressResponse>;
+export interface SubscribeAddressResponse {
+    address: string;
+    tx: BlockbookTransaction;
+}
+export declare const asSubscribeAddressResponse: (asAddress?: Cleaner<string>) => Cleaner<SubscribeAddressResponse>;

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

@@ -0,0 +1,8 @@
+export default class Deferred<T> {
+    private _resolve;
+    private _reject;
+    private readonly _promise;
+    get promise(): Promise<T>;
+    resolve(value: T): void;
+    reject(reason?: unknown): void;
+}

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export declare interface SocketEmitter {
+    emit: ((event: SocketEvent.CONNECTION_OPEN, uri: string) => void) & ((event: SocketEvent.CONNECTION_CLOSE, uri: string, error?: Error) => boolean) & ((event: SocketEvent.CONNECTION_TIMER, uri: string, queryTime: number) => boolean);
+    on: ((event: SocketEvent.CONNECTION_OPEN, listener: (uri: string) => void) => this) & ((event: SocketEvent.CONNECTION_CLOSE, listener: (uri: string, error?: Error) => void) => this) & ((event: SocketEvent.CONNECTION_TIMER, listener: (uri: string, queryTime: number) => void) => this);
+}
+export declare class SocketEmitter extends EventEmitter {
+}
+export declare enum SocketEvent {
+    CONNECTION_OPEN = "connection:open",
+    CONNECTION_CLOSE = "connection:close",
+    CONNECTION_TIMER = "connection:timer"
+}

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

@@ -0,0 +1,41 @@
+import { Cleaner } from 'cleaners';
+import { EdgeLog } from 'edge-core-js/types';
+import Deferred from './Deferred';
+import { SocketEmitter } from './MakeSocketEmitter';
+import { ReadyState } from './types';
+export declare type OnFailHandler = (error: Error) => void;
+export interface WsTask<T> {
+    method: string;
+    params: unknown;
+    deferred: Deferred<T>;
+    cleaner?: Cleaner<T>;
+}
+export interface WsSubscription<T> {
+    method: string;
+    params: unknown;
+    cb: (value: T) => void;
+    subscribed: boolean;
+    cleaner: Cleaner<T>;
+    deferred: Deferred<unknown>;
+}
+export interface Socket {
+    readyState: ReadyState;
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    submitTask: <T>(task: WsTask<T>) => void;
+    onQueueSpace: (cb: OnQueueSpaceCB) => void;
+    subscribe: <T>(subscription: WsSubscription<T>) => void;
+    isConnected: () => boolean;
+}
+export declare type OnQueueSpaceCB = (uri: string) => Promise<WsTask<unknown> | boolean | undefined>;
+interface SocketConfig {
+    queueSize?: number;
+    timeout?: number;
+    walletId: string;
+    emitter: SocketEmitter;
+    log: EdgeLog;
+    healthCheck: () => Promise<void>;
+    onQueueSpaceCB: OnQueueSpaceCB;
+}
+export declare function makeSocket(uri: string, config: SocketConfig): Socket;
+export {};

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

@@ -0,0 +1,2 @@
+import { InnerSocket, InnerSocketCallbacks } from './types';
+export declare function setupWS(uri: string, callbacks: InnerSocketCallbacks): InnerSocket;

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

@@ -0,0 +1,8 @@
+interface UpdateQueue {
+    id: string;
+    action?: string;
+    updateFunc: () => void;
+}
+export declare function pushUpdate(update: UpdateQueue): void;
+export declare function removeIdFromQueue(id: string): void;
+export {};

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

@@ -0,0 +1,17 @@
+export interface InnerSocketCallbacks {
+    onError: (error?: Error) => void;
+    onMessage: (message: string) => void;
+    onClose: (error?: Error) => void;
+    onOpen: () => void;
+}
+export declare enum ReadyState {
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3
+}
+export interface InnerSocket {
+    readyState: ReadyState;
+    disconnect: () => void;
+    send: (message: string) => void;
+}

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

@@ -0,0 +1,2 @@
+import { InnerSocket, InnerSocketCallbacks } from './types';
+export declare function setupBrowser(uri: string, callbacks: InnerSocketCallbacks): InnerSocket;

package/lib/src/firo.d.ts

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+declare const plugin: (options: EdgeCorePluginOptions) => EdgeCurrencyPlugin;
+export default plugin;

package/lib/src/ftc.d.ts

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+declare const plugin: (options: EdgeCorePluginOptions) => EdgeCurrencyPlugin;
+export default plugin;

package/lib/src/index.d.ts

@@ -0,0 +1,4 @@
+import { EdgeCorePlugins } from 'edge-core-js/types';
+declare const plugins: EdgeCorePlugins;
+export default plugins;
+export { setMemletConfig } from 'memlet';

package/lib/src/ltc.d.ts

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+declare const plugin: (options: EdgeCorePluginOptions) => EdgeCurrencyPlugin;
+export default plugin;

package/lib/src/tbch.d.ts

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+declare const plugin: (options: EdgeCorePluginOptions) => EdgeCurrencyPlugin;
+export default plugin;

package/lib/src/tbtc.d.ts

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+declare const plugin: (options: EdgeCorePluginOptions) => EdgeCurrencyPlugin;
+export default plugin;

package/lib/src/tbtg.d.ts

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+declare const plugin: (options: EdgeCorePluginOptions) => EdgeCurrencyPlugin;
+export default plugin;

package/lib/src/types.d.ts

@@ -0,0 +1,6 @@
+import { EdgeCorePlugins } from 'edge-core-js/types';
+declare global {
+    interface Window {
+        addEdgeCorePlugins?: (plugins: EdgeCorePlugins) => void;
+    }
+}

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

@@ -0,0 +1 @@
+export declare const delay: (ms: number) => Promise<void>;

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

@@ -0,0 +1 @@
+export declare const filterUndefined: <T>(values: (T | undefined)[]) => T[];

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

@@ -0,0 +1,5 @@
+/**
+ * Gets an element out of an array but includes protection if the index
+ * overflows the length of the array.
+ **/
+export declare const indexAtProtected: <T extends any[] | undefined>(array: T, index: number) => T extends (infer U)[] ? U : undefined;

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

@@ -0,0 +1,8 @@
+/**
+ * Like Pick, but removed fields are optional.
+ */
+export declare type SoftPick<T, K extends keyof T> = Pick<T, K> & Partial<T>;
+/**
+ * Like Omit, but removed fields are optional.
+ */
+export declare type SoftOmit<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

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

@@ -0,0 +1 @@
+export declare const undefinedIfEmptyString: (str?: string | undefined) => string | undefined;

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

@@ -0,0 +1 @@
+export declare const unixTime: (ts?: number) => number;

package/lib/tbch.js

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _makeCurrencyPlugin = require('./common/plugin/makeCurrencyPlugin');
+var _bitcoincashtestnet = require('./common/utxobased/info/bitcoincashtestnet');
+
+const plugin = (options) =>
+  _makeCurrencyPlugin.makeCurrencyPlugin.call(void 0, options, _bitcoincashtestnet.info)
+
+if (typeof window !== 'undefined') {
+  _optionalChain([window, 'access', _ => _.addEdgeCorePlugins, 'optionalCall', _2 => _2({
+    [_bitcoincashtestnet.info.currencyInfo.pluginId]: plugin
+  })])
+}
+
+exports. default = plugin