@chainlink/external-adapter-framework 0.0.7 → 0.0.10

package/adapter.d.ts

@@ -0,0 +1,88 @@
+import { AdapterConfig, BaseAdapterConfig, SettingsMap } from './config';
+import { AdapterRateLimitTier } from './rate-limiting';
+import { AdapterDependencies, Transport } from './transports';
+import { InputParameters } from './validation/input-params';
+/**
+ * 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 Adapter {
+    /** 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 */
+    endpoints: AdapterEndpoint[];
+    /** 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 AdapterEndpoint {
+    /** 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<any, any, any>;
+    /** 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;
+}
+/**
+ * Structure to describe an adapter that has been initialized
+ */
+export interface InitializedAdapter extends Adapter {
+    /** Object containing alias translations for all endpoints */
+    endpointsMap: Record<string, AdapterEndpoint>;
+    /** Initialized dependencies that the adapter will use */
+    dependencies: AdapterDependencies;
+    /** Configuration params for various adapter properties */
+    config: AdapterConfig;
+}
+/**
+ * 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 config - the configuration for this adapter
+ * @param inputDependencies - a partial obj of initialized dependencies to override the created ones
+ * @param rateLimitingConfig - details from the adapter regarding rate limiting
+ * @returns a set of AdapterDependencies all initialized
+ */
+export declare const initializeDependencies: (adapter: Adapter, config: AdapterConfig, inputDependencies?: Partial<AdapterDependencies>) => AdapterDependencies;
+/**
+ * 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).
+ *
+ * @param adapter - an instance of an Adapter
+ * @param dependencies - dependencies that the adapter will need at initialization
+ * @param config - configuration variables already processed and validated
+ * @returns - the adapter with all transports initialized and aliases map built
+ */
+export declare const initializeAdapter: (adapter: Adapter, config: AdapterConfig, dependencies?: Partial<AdapterDependencies>) => Promise<InitializedAdapter>;
+export {};

package/background-executor.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Server } from 'http';
+import { InitializedAdapter } 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: InitializedAdapter, server?: Server): Promise<void>;

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,90 @@
+import { AdapterEndpoint } from '../adapter';
+import { AdapterConfig } from '../config';
+import { AdapterMiddlewareBuilder, AdapterResponse, sleep } from '../util';
+export * from './local';
+export * from './redis';
+/**
+ * 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: ({ adapterEndpoint, adapterConfig, }: {
+    adapterEndpoint: AdapterEndpoint;
+    adapterConfig: AdapterConfig;
+}, data: unknown) => string;
+export declare const calculateFeedId: (adapterEndpoint: AdapterEndpoint, 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: (data: unknown, paramNames: string[]) => 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/{dist/src/cache → cache}/index.js

@@ -153,10 +153,14 @@ const buildCacheMiddleware = (adapter) => async (req, res) => {
     if (response) {
         logger.debug('Found response from cache, sending that');
         if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
-            const label = cacheMetrics.cacheMetricsLabel(req.requestContext.cacheKey, req.requestContext.metricsMeta?.feedId || 'N/A', adapter.config.CACHE_TYPE);
-            // Record cache get count, value, and staleness
+            const label = cacheMetrics.cacheMetricsLabel(req.requestContext.cacheKey, req.requestContext.meta?.metrics?.feedId || 'N/A', adapter.config.CACHE_TYPE);
+            // Record cache staleness and cache get count and value
             const staleness = calculateStaleness(response.maxAge, adapter.config.CACHE_MAX_AGE);
             cacheMetrics.cacheGet(label, response.result, staleness);
+            req.requestContext.meta = {
+                ...req.requestContext.meta,
+                metrics: { ...req.requestContext.meta?.metrics, cacheHit: true },
+            };
         }
         return res.send(response);
     }

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/{dist/cache → cache}/local.js

@@ -66,7 +66,7 @@ class LocalCache {
             expirationTimestamp: Date.now() + ttl,
         };
         // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
-        const feedId = value.metricsMeta?.feedId;
+        const feedId = value.meta?.metrics?.feedId;
         if (feedId) {
             // Record cache set count, max age, and staleness (set to 0 for cache set)
             const label = cacheMetrics.cacheMetricsLabel(key, feedId, cacheMetrics.CacheTypes.Local);

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/{dist/cache → cache}/metrics.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.redisCommandsSentCount = exports.redisRetriesCount = exports.redisConnectionsOpen = exports.CMD_SENT_STATUS = exports.CacheTypes = exports.cacheMetricsLabel = exports.cacheSet = exports.cacheGet = void 0;
+exports.cacheWarmerCount = exports.redisCommandsSentCount = exports.redisRetriesCount = exports.redisConnectionsOpen = exports.CMD_SENT_STATUS = exports.CacheTypes = exports.cacheMetricsLabel = exports.cacheSet = exports.cacheGet = void 0;
 const client = __importStar(require("prom-client"));
 const cacheGet = (label, value, staleness) => {
     if (typeof value === 'number' || typeof value === 'string') {
@@ -112,3 +112,9 @@ exports.redisCommandsSentCount = new client.Counter({
     help: 'The number of redis commands sent',
     labelNames: ['status', 'function_name'],
 });
+// Cache Warmer Metrics
+exports.cacheWarmerCount = new client.Gauge({
+    name: 'cache_warmer_get_count',
+    help: 'The number of cache warmers running',
+    labelNames: ['isBatched'],
+});

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/{dist/cache → cache}/redis.js

@@ -64,7 +64,7 @@ class RedisCache {
         // TODO: Check for invalid stringify
         await this.client.set(key, JSON.stringify(value), 'PX', ttl);
         // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
-        const feedId = value.metricsMeta?.feedId;
+        const feedId = value.meta?.metrics?.feedId;
         if (feedId) {
             // Record cache set count, max age, and staleness (set to 0 for cache set)
             const label = cacheMetrics.cacheMetricsLabel(key, feedId, cacheMetrics.CacheTypes.Redis);
@@ -83,7 +83,7 @@ class RedisCache {
             chain = chain.set(entry.key, JSON.stringify(entry.value), 'PX', ttl);
             // TODO: Move to after error handling once implemented to avoid recording cache sets that failed
             // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
-            const feedId = entry.value.metricsMeta?.feedId;
+            const feedId = entry.value.meta?.metrics?.feedId;
             if (feedId) {
                 // Record cache set count, max age, and staleness (set to 0 for cache set)
                 const label = cacheMetrics.cacheMetricsLabel(entry.key, feedId, cacheMetrics.CacheTypes.Redis);

package/config/index.d.ts

@@ -0,0 +1,195 @@
+export declare const BaseSettings: {
+    readonly API_KEY: {
+        readonly description: "Default setting for an EA key";
+        readonly type: "string";
+    };
+    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_PORT: {
+        readonly description: "Port for the Redis instance to be used";
+        readonly type: "number";
+        readonly default: 6379;
+    };
+    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 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 WARMUP_SUBSCRIPTION_TTL: {
+        readonly type: "number";
+        readonly description: "";
+        readonly default: 10000;
+    };
+    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 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;
+    };
+};
+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/{dist/src/config → config}/index.js

@@ -5,10 +5,9 @@ exports.buildAdapterConfig = exports.BaseSettings = void 0;
 exports.BaseSettings = {
     // V2 compat
     // TODO: Remove non used in v3 ones
-    API_ENDPOINT: {
-        description: 'The URL that the certain transports use to retrieve data',
-        type: 'string',
-    },
+    // API_ENDPOINT: {
+    //   type: 'string',
+    // },
     API_KEY: {
         description: 'Default setting for an EA key',
         type: 'string',
@@ -215,8 +214,8 @@ exports.BaseSettings = {
     // },
     WARMUP_SUBSCRIPTION_TTL: {
         type: 'number',
-        description: 'TTL for batch warmer subscriptions',
-        default: 60000,
+        description: '',
+        default: 10000,
     },
     // WARMUP_UNHEALTHY_THRESHOLD: {
     //   type: 'number',

package/config/provider-limits.d.ts

@@ -0,0 +1,31 @@
+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: {
+        [tierName: string]: HTTPTier;
+    };
+    ws: {
+        [tierName: 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 {};

package/{dist/src/config → config}/provider-limits.js

@@ -42,7 +42,7 @@ const getProviderLimits = (provider, limits, tier, protocol) => {
     return limitsConfig;
 };
 const parseLimits = (limits) => {
-    const _mapObject = (fn) => (o) => Object.fromEntries(Object.entries(o).map(fn));
+    const _mapObject = (fn) => (o) => Object.fromEntries([]);
     const _formatProtocol = _mapObject((entry) => {
         const [tierName, rest] = entry;
         return [tierName.toLowerCase(), { ...rest }];

package/examples/coingecko/batch-warming.d.ts

@@ -0,0 +1,2 @@
+import { AdapterEndpoint } from '../../adapter';
+export declare const batchEndpoint: AdapterEndpoint;

package/examples/coingecko/index.d.ts

@@ -0,0 +1,2 @@
+import { Adapter } from '../../adapter';
+export declare const adapter: Adapter;

package/examples/coingecko/rest.d.ts

@@ -0,0 +1,2 @@
+import { AdapterEndpoint } from '../../adapter';
+export declare const restEndpoint: AdapterEndpoint;

package/examples/ncfx/config/index.d.ts

@@ -0,0 +1,12 @@
+export declare const customSettings: {
+    readonly USERNAME: {
+        readonly description: "Username for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+    readonly PASSWORD: {
+        readonly description: "Password for the NCFX API";
+        readonly type: "string";
+        readonly required: true;
+    };
+};

package/examples/ncfx/index.d.ts

@@ -0,0 +1,2 @@
+import { Adapter } from '../../adapter';
+export declare const adapter: Adapter;