@bigmi/core/dist/cjs/transports/fallback.d.ts

TypeScript library for Bitcoin apps.

import type { ErrorType } from '../errors/utils.js';
import type { Chain } from '../types/chain.js';
import type { CreateTransportErrorType, Transport, TransportConfig } from '../types/transport.js';
export type OnResponseFn = (args: {
    method: string;
    params: unknown[];
    transport: ReturnType<Transport>;
} & ({
    error?: undefined;
    response: unknown;
    status: 'success';
} | {
    error: Error;
    response?: undefined;
    status: 'error';
})) => void;
type RankOptions = {
    interval?: number | undefined;
    ping?: (parameters: {
        transport: ReturnType<Transport>;
    }) => Promise<unknown> | undefined;
    sampleCount?: number | undefined;
    timeout?: number | undefined;
    weights?: {
        latency?: number | undefined;
        stability?: number | undefined;
    } | undefined;
};
export type FallbackTransportConfig = {
    key?: TransportConfig['key'] | undefined;
    name?: TransportConfig['name'] | undefined;
    rank?: boolean | RankOptions | undefined;
    retryCount?: TransportConfig['retryCount'] | undefined;
    retryDelay?: TransportConfig['retryDelay'] | undefined;
    shouldThrow?: (error: Error) => boolean | undefined;
};
export type FallbackTransport<transports extends readonly Transport[] = readonly Transport[]> = Transport<'fallback', {
    onResponse: (fn: OnResponseFn) => void;
    transports: {
        [key in keyof transports]: ReturnType<transports[key]>;
    };
}>;
export type FallbackTransportErrorType = CreateTransportErrorType | ErrorType;
export declare function fallback<const transports extends readonly Transport[]>(transports_: transports, config?: FallbackTransportConfig): FallbackTransport<transports>;
export declare function shouldThrow(error: Error): boolean;
export declare function rankTransports({ chain, interval, onTransports, ping, sampleCount, timeout, transports, weights, }: {
    chain?: Chain | undefined;
    interval: RankOptions['interval'];
    onTransports: (transports: readonly Transport[]) => void;
    ping?: RankOptions['ping'] | undefined;
    sampleCount?: RankOptions['sampleCount'] | undefined;
    timeout?: RankOptions['timeout'] | undefined;
    transports: readonly Transport[];
    weights?: RankOptions['weights'] | undefined;
}): void;
export {};