@chainlink/external-adapter-framework 0.0.19 → 0.0.21

package/adapter.d.ts

@@ -0,0 +1,139 @@
+import { Cache } from './cache';
+import { AdapterConfig, BaseAdapterConfig, CustomSettingsType, SettingsMap } from './config';
+import { AdapterRateLimitTier, BackgroundExecuteRateLimiter, RequestRateLimiter } from './rate-limiting';
+import { Transport } from './transports';
+import { SubscriptionSetFactory } from './util';
+import { InputParameters } from './validation/input-params';
+/**
+ * Dependencies that will be injected into the Adapter on startup
+ */
+export interface AdapterDependencies {
+    /** Specific instance of the Cache the adapter will use (e.g. Local, Redis, etc.) */
+    cache: Cache;
+    /** Shared instance of the request rate limiter */
+    requestRateLimiter: RequestRateLimiter;
+    /** Shared instance of the background execute rate limiter */
+    backgroundExecuteRateLimiter: BackgroundExecuteRateLimiter;
+    /** Factory to create subscription sets based on the specified cache type */
+    subscriptionSetFactory: SubscriptionSetFactory;
+}
+/**
+ * Context that will be used on background executions of a Transport.
+ * For example, the endpointName used to log statements or generate Cache keys.
+ */
+export interface AdapterContext<CustomSettings extends CustomSettingsType<CustomSettings> = SettingsMap> {
+    /** Endpoint instance within the adapter that the Transport is related to */
+    adapterEndpoint: AdapterEndpoint<unknown, unknown, CustomSettings>;
+    /** Initialized config for the adapter that the Transport can access */
+    adapterConfig: AdapterConfig<CustomSettings>;
+}
+/**
+ * Structure to describe rate limits specs for the Adapter
+ */
+interface AdapterRateLimitingConfig {
+    /** Adapter rate limits, gotten from the specific tier requested */
+    tiers: Record<string, AdapterRateLimitTier>;
+}
+/**
+ * Main structure of an External Adapter
+ */
+export interface AdapterParams<CustomSettings extends SettingsMap> {
+    /** Name of the adapter */
+    name: string;
+    /** If present, the string that will be used for requests with no specified endpoint */
+    defaultEndpoint?: string;
+    /**
+     * List of [[AdapterEndpoint]]s in the adapter. This is purposefully typed any; it's the correct type in this case.
+     *
+     * When you try to create an adapter and you provide an endpoint, if these generics were set to "unknown" instead
+     * what would happen is that Typescript would check if the types match, and would fail to assign unknown to the
+     * specific Params or Result in the transport itself.
+     * We also can't use generics, because if we had more than one transport with different requests (very likely)
+     * then those new types wouldn't match with each other.
+     */
+    endpoints: AdapterEndpoint<any, any, CustomSettings>[];
+    /** Map of overrides to the default config values for an Adapter */
+    envDefaultOverrides?: Partial<BaseAdapterConfig>;
+    /** List of custom env vars for this particular adapter (e.g. RPC_URL) */
+    customSettings?: SettingsMap;
+    /** Configuration relevant to outbound (EA --\> DP) communication rate limiting */
+    rateLimiting?: AdapterRateLimitingConfig;
+    /** Overrides for converting the 'base' parameter that are hardcoded into the adapter. */
+    overrides?: Record<string, string>;
+}
+/**
+ * Structure to describe rate limits specs for a specific adapter endpoint
+ */
+export interface EndpointRateLimitingConfig {
+    /**
+     * How much of the total limit for the adapter will be assigned to this specific endpoint.
+     * Should be a non-zero positive number up to 100.
+     * Endpoints in the same adapter without a specific allocation will divide the remaining limits equally.
+     */
+    allocationPercentage: number;
+}
+/**
+ * Structure to describe a specific endpoint in an [[Adapter]]
+ */
+export interface AdapterEndpointParams<Params, Result, CustomSettings extends SettingsMap> {
+    /** Name that will be used to match input params to this endpoint (case insensitive) */
+    name: string;
+    /** List of alternative endpoint names that will resolve to this same transport (case insensitive) */
+    aliases?: string[];
+    /** Transport that will be used to handle data processing and communication for this endpoint */
+    transport: Transport<Params, Result, CustomSettings>;
+    /** Specification of what the body of a request hitting this endpoint should look like (used for validation) */
+    inputParameters: InputParameters;
+    /** Specific details related to the rate limiting for this endpoint in particular */
+    rateLimiting?: EndpointRateLimitingConfig;
+}
+export declare class AdapterEndpoint<Params, Result, CustomSettings extends SettingsMap> implements AdapterEndpointParams<Params, Result, CustomSettings> {
+    name: string;
+    aliases?: string[] | undefined;
+    transport: Transport<Params, Result, CustomSettings>;
+    inputParameters: InputParameters;
+    rateLimiting?: EndpointRateLimitingConfig | undefined;
+    constructor(params: AdapterEndpointParams<Params, Result, CustomSettings>);
+}
+export declare class Adapter<CustomSettings extends SettingsMap = SettingsMap> implements AdapterParams<CustomSettings> {
+    name: string;
+    defaultEndpoint?: string | undefined;
+    endpoints: AdapterEndpoint<unknown, unknown, CustomSettings>[];
+    envDefaultOverrides?: Partial<BaseAdapterConfig> | undefined;
+    customSettings?: SettingsMap | undefined;
+    rateLimiting?: AdapterRateLimitingConfig | undefined;
+    overrides?: Record<string, string> | undefined;
+    initialized: boolean;
+    /** Object containing alias translations for all endpoints */
+    endpointsMap: Record<string, AdapterEndpoint<unknown, unknown, CustomSettings>>;
+    /** Initialized dependencies that the adapter will use */
+    dependencies: AdapterDependencies;
+    /** Configuration params for various adapter properties */
+    config: AdapterConfig;
+    constructor(params: AdapterParams<CustomSettings>);
+    /**
+     * Initializes all of the [[Transport]]s in the adapter, passing along any [[AdapterDependencies]] and [[AdapterConfig]].
+     * Additionally, it builds a map out of all the endpoint names and aliases (checking for duplicates).
+     */
+    initialize(dependencies?: Partial<AdapterDependencies>): Promise<void>;
+    /**
+     * Takes an adapter and normalizes all endpoint names and aliases, as well as the default endpoint.
+     * i.e. makes them lowercase for now
+     */
+    private normalizeEndpointNames;
+    /**
+     * This function will take an adapter structure and go through each endpoint, calculating
+     * each one's allocation of the total rate limits that are set for the adapter as a whole.
+     *
+     */
+    private calculateRateLimitAllocations;
+    /**
+     * This function will process dependencies for an adapter, such as caches or rate limiters,
+     * in order to inject them into transports and other relevant places later in the lifecycle.
+     *
+     * @param inputDependencies - a partial obj of initialized dependencies to override the created ones
+     * @returns a set of AdapterDependencies all initialized
+     */
+    initializeDependencies(inputDependencies?: Partial<AdapterDependencies>): AdapterDependencies;
+}
+export {};

package/background-executor.d.ts

@@ -0,0 +1,9 @@
+import { Adapter } from './adapter';
+/**
+ * Very simple background loop that will call the [[Transport.backgroundExecute]] functions in all Transports.
+ * It gets the time in ms to wait as the return value from those functions, and sleeps until next execution.
+ *
+ * @param adapter - an initialized External Adapter
+ * @param server - the http server to attach an on close listener to
+ */
+export declare function callBackgroundExecutes(adapter: Adapter, apiShutdownPromise?: Promise<void>): Promise<void>;

package/background-executor.js

@@ -10,12 +10,18 @@ const logger = (0, util_1.makeLogger)('BackgroundExecutor');
  * @param adapter - an initialized External Adapter
  * @param server - the http server to attach an on close listener to
  */
-async function callBackgroundExecutes(adapter, server) {
+async function callBackgroundExecutes(adapter, apiShutdownPromise) {
     // Set up variable to check later on to see if we need to stop this background "thread"
     // If no server is provided, the listener won't be set and serverClosed will always be false
     let serverClosed = false;
-    server?.on('close', () => {
+    const timeoutsMap = {};
+    apiShutdownPromise?.then(() => {
         serverClosed = true;
+        for (const endpointName in timeoutsMap) {
+            logger.debug(`Clearing timeout for endpoint "${endpointName}"`);
+            timeoutsMap[endpointName].unref();
+            clearTimeout(timeoutsMap[endpointName]);
+        }
     });
     for (const endpoint of adapter.endpoints) {
         const backgroundExecute = endpoint.transport.backgroundExecute?.bind(endpoint.transport);
@@ -35,8 +41,7 @@ async function callBackgroundExecutes(adapter, server) {
             logger.debug(`Calling background execute for endpoint "${endpoint.name}"`);
             const timeToWait = await backgroundExecute(context);
             logger.debug(`Finished background execute for endpoint "${endpoint.name}", sleeping for ${timeToWait}ms`);
-            await (0, util_1.sleep)(timeToWait);
-            handler();
+            timeoutsMap[endpoint.name] = setTimeout(handler, timeToWait);
         };
         // Start recursive async calls
         handler();

package/cache/factory.d.ts

@@ -0,0 +1,6 @@
+import { AdapterConfig } from '../config';
+import { LocalCache } from './local';
+import { RedisCache } from './redis';
+export declare class CacheFactory {
+    static buildCache(config: AdapterConfig): LocalCache<unknown> | RedisCache<unknown> | undefined;
+}

package/cache/index.d.ts

@@ -0,0 +1,94 @@
+import { AdapterEndpoint } from '../adapter';
+import { AdapterConfig, SettingsMap } from '../config';
+import { AdapterMiddlewareBuilder, AdapterResponse, sleep } from '../util';
+export * from './local';
+export * from './redis';
+export * from './factory';
+/**
+ * An object describing an entry in the cache.
+ * @typeParam T - the type of the entry's value
+ */
+export interface CacheEntry<T> {
+    key: string;
+    value: T;
+}
+/**
+ * Generic interface for a local or remote Cache.
+ * @typeParam T - the type of the cache entries' values
+ */
+export interface Cache<T = unknown> {
+    /**
+     * Gets an item from the Cache.
+     *
+     * @param key - the key of the desired entry for which to fetch its value
+     * @returns a Promise of the entry's value, or undefined if not found / expired.
+     */
+    get: (key: string) => Promise<T | undefined>;
+    /**
+     * Sets an item in the Cache.
+     *
+     * @param key - the key of the new entry
+     * @param value - the value of the new entry
+     * @param ttl - the time in milliseconds until the entry expires
+     * @returns an empty Promise that resolves when the entry has been set
+     */
+    set: (key: string, value: T, ttl: number) => Promise<void>;
+    /**
+     * Sets a list of items in the Cache.
+     *
+     * @param entries - a list of cache entries
+     * @param ttl - the time in milliseconds until the entries expire
+     * @returns an empty Promise that resolves when all entries have been set
+     */
+    setMany: (entries: CacheEntry<T>[], ttl: number) => Promise<void>;
+    /**
+     * Deletes the specified item from the Cache
+     *
+     * @param key - the key of the entry to be deleted
+     * @returns an empty Promise that resolves when the entry has been deleted
+     */
+    delete: (key: string) => Promise<void>;
+}
+export declare const calculateCacheKey: <Params, Result, CustomSettings extends SettingsMap>({ adapterEndpoint, adapterConfig, }: {
+    adapterEndpoint: AdapterEndpoint<Params, Result, CustomSettings>;
+    adapterConfig: AdapterConfig<CustomSettings>;
+}, data: unknown) => string;
+export declare const calculateFeedId: <Params, Result, CustomSettings extends SettingsMap>({ adapterEndpoint, adapterConfig, }: {
+    adapterEndpoint: AdapterEndpoint<Params, Result, CustomSettings>;
+    adapterConfig: AdapterConfig<CustomSettings>;
+}, data: unknown) => string;
+/**
+ * Calculates a unique key from the provided data.
+ *
+ * @param data - the request data/body, i.e. the adapter input params
+ * @param paramNames - the keys from adapter endpoint input parameters
+ * @returns the calculated unique key
+ *
+ * @example
+ * ```
+ * calculateKey({ base: 'ETH', quote: 'BTC' }, ['base','quote'])
+ * // equals `|base:eth|quote:btc`
+ * ```
+ */
+export declare const calculateKey: <CustomSettings extends SettingsMap>(data: unknown, paramNames: string[], adapterConfig: AdapterConfig<CustomSettings>) => string;
+/**
+ * Polls the provided Cache for an AdapterResponse set in the provided key. If the maximum
+ * amount of retries is exceeded, it returns undefined instead.
+ *
+ * @param cache - a Cache instance
+ * @param key - the key generated from an AdapterRequest that corresponds to the desired AdapterResponse
+ * @param retry - current retry, only for internal use
+ * @returns the AdapterResponse if found, else undefined
+ */
+export declare const pollResponseFromCache: (cache: Cache<AdapterResponse>, key: string, options: {
+    maxRetries: number;
+    sleep: number;
+}, retry?: number) => Promise<AdapterResponse | undefined>;
+/**
+ * Given a Cache instance in the adapter dependencies, builds a middleware function that will perform
+ * a get from said Cache and return that if found; otherwise it'll continue the middleware chain.
+ *
+ * @param adapter - an initialized adapter
+ * @returns the cache middleware function
+ */
+export declare const buildCacheMiddleware: AdapterMiddlewareBuilder;

package/cache/local.d.ts

@@ -0,0 +1,23 @@
+import { Cache, CacheEntry } from './index';
+/**
+ * Type for a value stored in a LocalCache entry.
+ *
+ * @typeParam T - the type for the entry's value
+ */
+export interface LocalCacheEntry<T> {
+    expirationTimestamp: number;
+    value: T;
+}
+/**
+ * Local implementation of a Cache. It uses a simple js Object, storing entries with both
+ * a value and an expiration timestamp. Expired entries are deleted on reads (i.e. no background gc/upkeep).
+ *
+ * @typeParam T - the type for the entries' values
+ */
+export declare class LocalCache<T = unknown> implements Cache<T> {
+    store: Record<string, LocalCacheEntry<T>>;
+    get(key: string): Promise<T | undefined>;
+    delete(key: string): Promise<void>;
+    set(key: string, value: T, ttl: number): Promise<void>;
+    setMany(entries: CacheEntry<T>[], ttl: number): Promise<void>;
+}

package/cache/metrics.d.ts

@@ -0,0 +1,27 @@
+import * as client from 'prom-client';
+interface CacheMetricsLabels {
+    participant_id: string;
+    feed_id: string;
+    cache_type: string;
+}
+export declare const cacheGet: (label: CacheMetricsLabels, value: unknown, staleness: number) => void;
+export declare const cacheSet: (label: CacheMetricsLabels, maxAge: number) => void;
+export declare const cacheMetricsLabel: (cacheKey: string, feedId: string, cacheType: string) => {
+    participant_id: string;
+    feed_id: string;
+    cache_type: string;
+};
+export declare enum CacheTypes {
+    Redis = "redis",
+    Local = "local"
+}
+export declare enum CMD_SENT_STATUS {
+    TIMEOUT = "TIMEOUT",
+    FAIL = "FAIL",
+    SUCCESS = "SUCCESS"
+}
+export declare const redisConnectionsOpen: client.Counter<string>;
+export declare const redisRetriesCount: client.Counter<string>;
+export declare const redisCommandsSentCount: client.Counter<"status" | "function_name">;
+export declare const cacheWarmerCount: client.Gauge<"isBatched">;
+export {};

package/cache/redis.d.ts

@@ -0,0 +1,16 @@
+import Redis from 'ioredis';
+import { Cache, CacheEntry } from './index';
+/**
+ * Redis implementation of a Cache. It uses a simple js Object, storing entries with both
+ * a value and an expiration timestamp. Expired entries are deleted on reads (i.e. no background gc/upkeep).
+ *
+ * @typeParam T - the type for the entries' values
+ */
+export declare class RedisCache<T = unknown> implements Cache<T> {
+    private client;
+    constructor(client: Redis);
+    get(key: string): Promise<T | undefined>;
+    delete(key: string): Promise<void>;
+    set(key: string, value: T, ttl: number): Promise<void>;
+    setMany(entries: CacheEntry<T>[], ttl: number): Promise<void>;
+}

package/config/index.d.ts

@@ -0,0 +1,258 @@
+export declare const BaseSettings: {
+    readonly API_ENDPOINT: {
+        readonly description: "The URL that certain transports use to retrieve data";
+        readonly type: "string";
+    };
+    readonly API_KEY: {
+        readonly description: "Default setting for an EA key";
+        readonly type: "string";
+    };
+    readonly API_TIMEOUT: {
+        readonly description: "The number of milliseconds a request can be pending before returning a timeout error for data provider request";
+        readonly type: "number";
+        readonly default: 30000;
+    };
+    readonly API_VERBOSE: {
+        readonly description: "Toggle whether the response from the EA should contain just the results or also include the full response body from the queried API.";
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly BASE_URL: {
+        readonly description: "Starting path for the EA handler endpoint";
+        readonly type: "string";
+        readonly default: "/";
+    };
+    readonly CACHE_MAX_AGE: {
+        readonly description: "Maximum amount of time (in ms) that a response will stay cached";
+        readonly type: "number";
+        readonly default: 90000;
+    };
+    readonly CACHE_REDIS_HOST: {
+        readonly description: "Hostname for the Redis instance to be used";
+        readonly type: "string";
+        readonly default: "127.0.0.1";
+    };
+    readonly CACHE_REDIS_PASSWORD: {
+        readonly description: "The password required for redis auth";
+        readonly type: "string";
+    };
+    readonly CACHE_REDIS_PATH: {
+        readonly description: "The UNIX socket string of the Redis server";
+        readonly type: "string";
+    };
+    readonly CACHE_REDIS_PORT: {
+        readonly description: "Port for the Redis instance to be used";
+        readonly type: "number";
+        readonly default: 6379;
+    };
+    readonly CACHE_REDIS_TIMEOUT: {
+        readonly description: "Timeout to fail a Redis server request if no response (ms)";
+        readonly type: "number";
+        readonly default: 500;
+    };
+    readonly CACHE_TYPE: {
+        readonly description: "The type of cache to use throughout the EA";
+        readonly type: "enum";
+        readonly default: "local";
+        readonly options: readonly ["local", "redis"];
+    };
+    readonly CORRELATION_ID_ENABLED: {
+        readonly description: "Flag to enable correlation IDs for sent requests in logging";
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly DEBUG: {
+        readonly description: "Toggles debug mode";
+        readonly type: "boolean";
+        readonly default: false;
+    };
+    readonly EA_PORT: {
+        readonly description: "Port through which the EA will listen for REST requests (if mode is set to \"reader\" or \"reader-writer\")";
+        readonly type: "number";
+        readonly default: 8080;
+    };
+    readonly EXPERIMENTAL_METRICS_ENABLED: {
+        readonly description: "Flag to specify whether or not to collect metrics. Used as fallback for METRICS_ENABLED";
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly LOG_LEVEL: {
+        readonly description: "Minimum level required for logs to be output";
+        readonly type: "string";
+        readonly default: "info";
+    };
+    readonly METRICS_ENABLED: {
+        readonly description: "Flag to specify whether or not to startup the metrics server";
+        readonly type: "boolean";
+        readonly default: true;
+    };
+    readonly METRICS_NAME: {
+        readonly description: "Metrics name";
+        readonly type: "string";
+    };
+    readonly METRICS_PORT: {
+        readonly description: "Port metrics will be exposed to";
+        readonly type: "number";
+        readonly default: 9080;
+    };
+    readonly METRICS_USE_BASE_URL: {
+        readonly description: "Flag to specify whether or not to prepend the BASE_URL to the metrics endpoint";
+        readonly type: "boolean";
+    };
+    readonly RATE_LIMIT_API_TIER: {
+        readonly description: "Rate limiting tier to use from the available options for the adapter. If not present, the adapter will run using the first tier on the list.";
+        readonly type: "string";
+    };
+    readonly RATE_LIMIT_CAPACITY: {
+        readonly description: "Used as rate limit capacity per minute and ignores tier settings if defined";
+        readonly type: "number";
+    };
+    readonly RATE_LIMIT_CAPACITY_MINUTE: {
+        readonly description: "Used as rate limit capacity per minute and ignores tier settings if defined. Supercedes RATE_LIMIT_CAPACITY if both vars are set";
+        readonly type: "number";
+    };
+    readonly RATE_LIMIT_CAPACITY_SECOND: {
+        readonly description: "Used as rate limit capacity per second and ignores tier settings if defined";
+        readonly type: "number";
+    };
+    readonly REQUEST_COALESCING_ENABLED: {
+        readonly description: "Enable request coalescing";
+        readonly type: "boolean";
+    };
+    readonly WARMUP_SUBSCRIPTION_TTL: {
+        readonly type: "number";
+        readonly description: "TTL for batch warmer subscriptions";
+        readonly default: 10000;
+    };
+    readonly WS_SUBSCRIPTION_TTL: {
+        readonly description: "";
+        readonly type: "number";
+        readonly default: 120000;
+    };
+    readonly CACHE_POLLING_MAX_RETRIES: {
+        readonly description: "Max amount of times to attempt to find EA response in the cache after the Transport has been set up";
+        readonly type: "number";
+        readonly default: 10;
+    };
+    readonly CACHE_POLLING_SLEEP_MS: {
+        readonly description: "The number of ms to sleep between each retry to fetch the EA response in the cache";
+        readonly type: "number";
+        readonly default: 200;
+    };
+    readonly DEFAULT_CACHE_KEY: {
+        readonly description: "Default key to be used when one cannot be determined from request parameters";
+        readonly type: "string";
+        readonly default: "DEFAULT_CACHE_KEY";
+    };
+    readonly EA_HOST: {
+        readonly description: "Host this EA will listen for REST requests on (if mode is set to \"reader\" or \"reader-writer\")";
+        readonly type: "string";
+        readonly default: "::";
+    };
+    readonly EA_MODE: {
+        readonly description: "Port this EA will listen for REST requests on (if mode is set to \"reader\" or \"reader-writer\")";
+        readonly type: "enum";
+        readonly default: "reader-writer";
+        readonly options: readonly ["reader", "writer", "reader-writer"];
+    };
+    readonly MAX_COMMON_KEY_SIZE: {
+        readonly description: "Maximum amount of characters that the common part of the cache key or feed ID can have";
+        readonly type: "number";
+        readonly default: 300;
+        readonly validate: (value?: number) => "MAX_COMMON_KEY_SIZE must be a number between 150 and 500" | undefined;
+    };
+    readonly REST_TRANSPORT_MAX_RATE_LIMIT_RETRIES: {
+        readonly description: "Maximum amount of times the Rest Transport will attempt to set up a request when blocked by the rate limiter";
+        readonly type: "number";
+        readonly default: 3;
+    };
+    readonly REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES: {
+        readonly description: "Time that the Rest Transport will wait between retries when blocked by the rate limiter";
+        readonly type: "number";
+        readonly default: 400;
+    };
+    readonly SMOKE_TEST_PAYLOAD_FILE_NAME: {
+        readonly description: "Name of the test payload file used for the smoke endpoint";
+        readonly type: "string";
+    };
+};
+export declare const buildAdapterConfig: <CustomSettings extends CustomSettingsType<CustomSettings> = EmptySettings>({ overrides, customSettings, }: {
+    overrides?: Partial<BaseAdapterConfig> | undefined;
+    customSettings?: SettingsMap | undefined;
+}) => AdapterConfig<CustomSettings>;
+declare type SettingValueType = string | number | boolean;
+declare type SettingType<C extends Setting> = C['type'] extends 'string' ? string : C['type'] extends 'number' ? number : C['type'] extends 'boolean' ? boolean : C['type'] extends 'enum' ? C['options'] extends readonly string[] ? C['options'][number] : never : never;
+declare type BaseSettingsType = typeof BaseSettings;
+export declare type Setting = {
+    type: 'string';
+    description: string;
+    options?: never;
+    default?: string;
+    validate?: (value?: string) => ValidationErrorMessage;
+    required?: false;
+} | {
+    type: 'string';
+    description: string;
+    options?: never;
+    default?: string;
+    validate?: (value: string) => ValidationErrorMessage;
+    required: true;
+} | {
+    type: 'number';
+    description: string;
+    options?: never;
+    default?: number;
+    validate?: (value?: number) => ValidationErrorMessage;
+    required?: false;
+} | {
+    type: 'number';
+    description: string;
+    options?: never;
+    default?: number;
+    validate?: (value: number) => ValidationErrorMessage;
+    required: true;
+} | {
+    type: 'boolean';
+    description: string;
+    options?: never;
+    default?: boolean;
+    validate?: (value?: boolean) => ValidationErrorMessage;
+    required?: false;
+} | {
+    type: 'boolean';
+    description: string;
+    options?: never;
+    default?: boolean;
+    validate?: (value: boolean) => ValidationErrorMessage;
+    required: true;
+} | {
+    type: 'enum';
+    description: string;
+    default?: string;
+    options: readonly string[];
+    validate?: (value?: string) => ValidationErrorMessage;
+    required?: false;
+} | {
+    type: 'enum';
+    description: string;
+    default?: string;
+    options: readonly string[];
+    validate?: (value: string) => ValidationErrorMessage;
+    required: true;
+};
+export declare type AdapterConfigFromSettings<T extends SettingsMap> = {
+    -readonly [K in keyof T as T[K] extends {
+        default: SettingValueType;
+    } ? K : T[K]['required'] extends true ? K : never]: SettingType<T[K]>;
+} & {
+    -readonly [K in keyof T as T[K] extends {
+        default: SettingValueType;
+    } ? never : T[K]['required'] extends true ? never : K]?: SettingType<T[K]> | undefined;
+};
+export declare type BaseAdapterConfig = AdapterConfigFromSettings<BaseSettingsType>;
+export declare type AdapterConfig<T extends CustomSettingsType<T> = SettingsMap> = AdapterConfigFromSettings<T> & BaseAdapterConfig;
+export declare type CustomSettingsType<T = SettingsMap> = Record<keyof T, Setting>;
+export declare type EmptySettings = Record<string, never>;
+export declare type SettingsMap = Record<string, Setting>;
+export declare type ValidationErrorMessage = string | undefined;
+export {};

package/config/provider-limits.d.ts

@@ -0,0 +1,27 @@
+export declare const DEFAULT_MINUTE_RATE_LIMIT = 60;
+export declare const BURST_UNDEFINED_QUOTA_MULTIPLE = 2;
+export declare const DEFAULT_WS_CONNECTIONS = 2;
+export declare const DEFAULT_WS_SUBSCRIPTIONS = 10;
+declare type RateLimitTimeFrame = 'rateLimit1s' | 'rateLimit1m' | 'rateLimit1h';
+declare type HTTPTier = {
+    rateLimit1s?: number;
+    rateLimit1m?: number;
+    rateLimit1h?: number;
+    note?: string;
+};
+declare type WSTier = {
+    connections: number;
+    subscriptions: number;
+};
+export interface Limits {
+    http: Record<string, HTTPTier>;
+    ws: Record<string, WSTier>;
+}
+interface ProviderRateLimit {
+    second: number;
+    minute: number;
+}
+export declare const getHTTPLimit: (provider: string, limits: Limits, tier: string, timeframe: RateLimitTimeFrame) => number;
+export declare const getRateLimit: (provider: string, limits: Limits, tier: string) => ProviderRateLimit;
+export declare const getWSLimits: (provider: string, limits: Limits, tier: string) => WSTier;
+export {};