@chainlink/external-adapter-framework 0.0.10 → 0.0.12

package/dist/src/package/background-executor.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callBackgroundExecutes = void 0;
+const util_1 = require("./util");
+const logger = (0, util_1.makeLogger)('BackgroundExecutor');
+/**
+ * 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
+ */
+async function callBackgroundExecutes(adapter, server) {
+    // 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', () => {
+        serverClosed = true;
+    });
+    for (const endpoint of adapter.endpoints) {
+        const backgroundExecute = endpoint.transport.backgroundExecute?.bind(endpoint.transport);
+        if (!backgroundExecute) {
+            logger.debug(`Endpoint "${endpoint.name}" has no background execute, skipping...`);
+            continue;
+        }
+        const context = {
+            adapterEndpoint: endpoint,
+            adapterConfig: adapter.config,
+        };
+        const handler = async () => {
+            if (serverClosed) {
+                logger.info('Server closed, stopping recursive backgroundExecute handler chain');
+                return;
+            }
+            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();
+        };
+        // Start recursive async calls
+        handler();
+    }
+}
+exports.callBackgroundExecutes = callBackgroundExecutes;

package/dist/src/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/dist/src/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/src/package/cache/local.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCache = void 0;
+const util_1 = require("../util");
+const cacheMetrics = __importStar(require("./metrics"));
+const logger = (0, util_1.makeLogger)('LocalCache');
+/**
+ * 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
+ */
+class LocalCache {
+    constructor() {
+        this.store = {};
+    }
+    async get(key) {
+        logger.trace(`Getting key ${key}`);
+        const entry = this.store[key];
+        if (!entry) {
+            logger.debug(`No entry in local cache for key "${key}", returning undefined`);
+            return undefined;
+        }
+        const expired = entry.expirationTimestamp <= Date.now();
+        if (expired) {
+            logger.debug('Entry in local cache expired, deleting and returning undefined');
+            this.delete(key);
+            return undefined;
+        }
+        else {
+            logger.debug('Found valid entry in local cache, returning value');
+            return entry.value;
+        }
+    }
+    async delete(key) {
+        logger.trace(`Deleting key ${key}`);
+        delete this.store[key]; // Deletes are slower than ignoring or setting null, fyi
+    }
+    async set(key, value, ttl) {
+        logger.trace(`Setting key ${key} with ttl ${ttl}`);
+        this.store[key] = {
+            value,
+            expirationTimestamp: Date.now() + ttl,
+        };
+        // Only record metrics if feed Id is present, otherwise assuming value is not adapter response to record
+        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);
+            cacheMetrics.cacheSet(label, ttl);
+        }
+    }
+    async setMany(entries, ttl) {
+        logger.trace(`Setting a bunch of keys with ttl ${ttl}`);
+        for (const { key, value } of entries) {
+            this.set(key, value, ttl);
+        }
+    }
+}
+exports.LocalCache = LocalCache;

package/dist/src/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/src/package/cache/metrics.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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') {
+        const parsedValue = Number(value);
+        if (!Number.isNaN(parsedValue) && Number.isFinite(parsedValue)) {
+            cacheDataGetValues.labels(label).set(parsedValue);
+        }
+    }
+    cacheDataGetCount.labels(label).inc();
+    cacheDataStalenessSeconds.labels(label).set(staleness);
+};
+exports.cacheGet = cacheGet;
+const cacheSet = (label, maxAge) => {
+    cacheDataSetCount.labels(label).inc();
+    cacheDataMaxAge.labels(label).set(maxAge);
+    cacheDataStalenessSeconds.labels(label).set(0);
+};
+exports.cacheSet = cacheSet;
+const cacheMetricsLabel = (cacheKey, feedId, cacheType) => ({
+    participant_id: cacheKey,
+    feed_id: feedId,
+    cache_type: cacheType,
+});
+exports.cacheMetricsLabel = cacheMetricsLabel;
+var CacheTypes;
+(function (CacheTypes) {
+    CacheTypes["Redis"] = "redis";
+    CacheTypes["Local"] = "local";
+})(CacheTypes = exports.CacheTypes || (exports.CacheTypes = {}));
+var CMD_SENT_STATUS;
+(function (CMD_SENT_STATUS) {
+    CMD_SENT_STATUS["TIMEOUT"] = "TIMEOUT";
+    CMD_SENT_STATUS["FAIL"] = "FAIL";
+    CMD_SENT_STATUS["SUCCESS"] = "SUCCESS";
+})(CMD_SENT_STATUS = exports.CMD_SENT_STATUS || (exports.CMD_SENT_STATUS = {}));
+const baseLabels = [
+    'feed_id',
+    'participant_id',
+    'cache_type',
+    'is_from_ws',
+    'experimental',
+];
+// Skipping this metrics for v3
+// const cache_execution_duration_seconds = new client.Histogram({
+//   name: 'cache_execution_duration_seconds',
+//   help: 'A histogram bucket of the distribution of cache execution durations',
+//   labelNames: [...baseLabels, 'cache_hit'] as const,
+//   buckets: [0.01, 0.1, 1, 10],
+// })
+const cacheDataGetCount = new client.Counter({
+    name: 'cache_data_get_count',
+    help: 'A counter that increments every time a value is fetched from the cache',
+    labelNames: baseLabels,
+});
+const cacheDataGetValues = new client.Gauge({
+    name: 'cache_data_get_values',
+    help: 'A gauge keeping track of values being fetched from cache',
+    labelNames: baseLabels,
+});
+const cacheDataMaxAge = new client.Gauge({
+    name: 'cache_data_max_age',
+    help: 'A gauge tracking the max age of stored values in the cache',
+    labelNames: baseLabels,
+});
+const cacheDataSetCount = new client.Counter({
+    name: 'cache_data_set_count',
+    help: 'A counter that increments every time a value is set to the cache',
+    labelNames: [...baseLabels, 'status_code'],
+});
+const cacheDataStalenessSeconds = new client.Gauge({
+    name: 'cache_data_staleness_seconds',
+    help: 'Observes the staleness of the data returned',
+    labelNames: baseLabels,
+});
+// Redis Metrics
+exports.redisConnectionsOpen = new client.Counter({
+    name: 'redis_connections_open',
+    help: 'The number of redis connections that are open',
+});
+exports.redisRetriesCount = new client.Counter({
+    name: 'redis_retries_count',
+    help: 'The number of retries that have been made to establish a redis connection',
+});
+exports.redisCommandsSentCount = new client.Counter({
+    name: 'redis_commands_sent_count',
+    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/dist/src/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/src/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/package/config/provider-limits.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWSLimits = exports.getRateLimit = exports.getHTTPLimit = exports.DEFAULT_WS_SUBSCRIPTIONS = exports.DEFAULT_WS_CONNECTIONS = exports.BURST_UNDEFINED_QUOTA_MULTIPLE = exports.DEFAULT_MINUTE_RATE_LIMIT = void 0;
+const util_1 = require("../util");
+exports.DEFAULT_MINUTE_RATE_LIMIT = 60;
+exports.BURST_UNDEFINED_QUOTA_MULTIPLE = 2;
+exports.DEFAULT_WS_CONNECTIONS = 2;
+exports.DEFAULT_WS_SUBSCRIPTIONS = 10;
+const logger = (0, util_1.makeLogger)('ProviderLimits');
+const getHTTPLimit = (provider, limits, tier, timeframe) => {
+    const providerLimit = getProviderLimits(provider, limits, tier, 'http');
+    return providerLimit?.[timeframe] || 0;
+};
+exports.getHTTPLimit = getHTTPLimit;
+const getRateLimit = (provider, limits, tier) => {
+    const providerLimit = getProviderLimits(provider, limits, tier, 'http');
+    return calculateRateLimit(providerLimit);
+};
+exports.getRateLimit = getRateLimit;
+const getWSLimits = (provider, limits, tier) => {
+    const providerLimit = getProviderLimits(provider, limits, tier, 'ws');
+    return calculateWSLimits(providerLimit);
+};
+exports.getWSLimits = getWSLimits;
+const getProviderLimits = (provider, limits, tier, protocol) => {
+    const providerConfig = parseLimits(limits);
+    if (!providerConfig) {
+        throw new Error(`Rate Limit: Provider: "${provider}" doesn't match any provider spec in limits.json`);
+    }
+    const protocolConfig = providerConfig[protocol];
+    if (!protocolConfig) {
+        throw new Error(`Rate Limit: "${provider}" doesn't have any configuration for ${protocol} in limits.json`);
+    }
+    let limitsConfig = protocolConfig[tier.toLowerCase()];
+    if (!limitsConfig) {
+        logger.debug(`Rate Limit: "${provider} does not have tier ${tier} defined. Falling back to lowest tier"`);
+        limitsConfig = Object.values(protocolConfig)?.[0];
+    }
+    if (!limitsConfig) {
+        throw new Error(`Rate Limit: Provider: "${provider}" has no tiers defined for ${protocol} in limits.json`);
+    }
+    return limitsConfig;
+};
+const parseLimits = (limits) => {
+    // const _mapObject = (fn: any) => (o: any) => 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 }];
+    });
+    const _formatProvider = (ls) => {
+        const http = _formatProtocol(ls.http);
+        const ws = _formatProtocol(ls?.ws);
+        return { http, ws };
+    };
+    return _formatProvider(limits);
+};
+const calculateWSLimits = (providerLimit) => {
+    return {
+        connections: providerLimit.connections,
+        subscriptions: providerLimit.subscriptions,
+    };
+};
+const calculateRateLimit = (providerLimit) => {
+    let quota = providerLimit.rateLimit1m;
+    if (!quota && providerLimit?.rateLimit1h) {
+        quota = providerLimit?.rateLimit1h / 60;
+    }
+    else if (!quota && providerLimit?.rateLimit1s) {
+        quota = providerLimit?.rateLimit1s * 60;
+    }
+    return {
+        second: providerLimit?.rateLimit1s || (quota / 60) * exports.BURST_UNDEFINED_QUOTA_MULTIPLE,
+        minute: quota,
+    };
+};

package/dist/src/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/dist/src/package/examples/ncfx/config/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customSettings = void 0;
+exports.customSettings = {
+    USERNAME: {
+        description: 'Username for the NCFX API',
+        type: 'string',
+        required: true,
+    },
+    PASSWORD: {
+        description: 'Password for the NCFX API',
+        type: 'string',
+        required: true,
+    },
+};

package/dist/src/package/metrics/constants.d.ts

@@ -0,0 +1,16 @@
+export declare enum HttpRequestType {
+    CACHE_HIT = "cacheHit",
+    DATA_PROVIDER_HIT = "dataProviderHit",
+    ADAPTER_ERROR = "adapterError",
+    INPUT_ERROR = "inputError",
+    RATE_LIMIT_ERROR = "rateLimitError",
+    DP_ERROR = "dataProviderError",
+    TIMEOUT_ERROR = "timeoutError",
+    CONNECTION_ERROR = "connectionError",
+    CUSTOM_ERROR = "customError"
+}
+/**
+ * Maxiumum number of characters that a feedId can contain.
+ */
+export declare const MAX_FEED_ID_LENGTH = 300;
+export declare const requestDurationBuckets: number[];

package/dist/src/package/metrics/constants.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestDurationBuckets = exports.MAX_FEED_ID_LENGTH = exports.HttpRequestType = void 0;
+var HttpRequestType;
+(function (HttpRequestType) {
+    HttpRequestType["CACHE_HIT"] = "cacheHit";
+    HttpRequestType["DATA_PROVIDER_HIT"] = "dataProviderHit";
+    HttpRequestType["ADAPTER_ERROR"] = "adapterError";
+    HttpRequestType["INPUT_ERROR"] = "inputError";
+    HttpRequestType["RATE_LIMIT_ERROR"] = "rateLimitError";
+    // BURST_LIMIT_ERROR = 'burstLimitError',
+    // BACKOFF_ERROR = 'backoffError',
+    HttpRequestType["DP_ERROR"] = "dataProviderError";
+    HttpRequestType["TIMEOUT_ERROR"] = "timeoutError";
+    HttpRequestType["CONNECTION_ERROR"] = "connectionError";
+    // RES_EMPTY_ERROR = 'responseEmptyError',
+    // RES_INVALID_ERROR = 'responseInvalidError',
+    HttpRequestType["CUSTOM_ERROR"] = "customError";
+})(HttpRequestType = exports.HttpRequestType || (exports.HttpRequestType = {}));
+/**
+ * Maxiumum number of characters that a feedId can contain.
+ */
+exports.MAX_FEED_ID_LENGTH = 300;
+// We should tune these as we collect data, this is the default bucket distribution that prom comes with
+exports.requestDurationBuckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];

package/dist/src/package/metrics/index.d.ts

@@ -0,0 +1,15 @@
+import * as client from 'prom-client';
+import { AdapterRequest } from '../util';
+import { AdapterConfig } from '../config';
+import { FastifyReply, HookHandlerDoneFunction } from 'fastify';
+export declare function setupMetricsServer(name: string, config: AdapterConfig): void;
+export declare const setupMetrics: (name: string, config: AdapterConfig) => void;
+/**
+ * Builds metrics middleware that records end to end EA response times
+ * and count of requests
+ *
+ * @returns the cache middleware function
+ */
+export declare const buildMetricsMiddleware: (req: AdapterRequest, res: FastifyReply, done: HookHandlerDoneFunction) => void;
+export declare const httpRequestsTotal: client.Counter<"type" | "method" | "feed_id" | "status_code" | "provider_status_code" | "retry" | "is_cache_warming">;
+export declare const httpRequestDurationSeconds: client.Histogram<string>;

package/dist/src/package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@chainlink/external-adapter-framework",
+  "version": "0.0.6",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^0.27.2",
+    "fastify": "^3.29.0",
+    "ioredis": "^5.0.4",
+    "pino": "^7.9.2",
+    "prom-client": "13.2.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.6.3",
+    "ws": "^8.5.0"
+  },
+  "scripts": {
+    "start": "ts-node src/test.ts",
+    "generate-docs": "typedoc src/**/*.ts",
+    "test": "LOG_LEVEL=error EA_PORT=0 c8 ava",
+    "test-debug": "LOG_LEVEL=trace DEBUG=true EA_PORT=0 c8 ava --verbose",
+    "build": "tsc",
+    "lint": "eslint ./src"
+  },
+  "devDependencies": {
+    "@sinonjs/fake-timers": "^9.1.2",
+    "@types/node": "^18.6.5",
+    "@types/sinonjs__fake-timers": "^8.1.2",
+    "@types/ws": "^8.5.3",
+    "@typescript-eslint/eslint-plugin": "^5.17.0",
+    "@typescript-eslint/parser": "^5.17.0",
+    "ava": "^4.2.0",
+    "c8": "^7.11.2",
+    "eslint": "^8.14.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-tsdoc": "^0.2.16",
+    "mock-socket": "^9.1.3",
+    "nock": "^13.2.4",
+    "pino-pretty": "^7.6.0",
+    "prettier": "^2.6.1",
+    "ts-loader": "^9.3.1",
+    "typedoc": "^0.22.15",
+    "webpack": "^5.74.0",
+    "webpack-cli": "^4.10.0"
+  },
+  "prettier": {
+    "semi": false,
+    "singleQuote": true,
+    "printWidth": 100,
+    "endOfLine": "auto",
+    "trailingComma": "all",
+    "arrowParens": "always"
+  },
+  "optionalDependencies": {
+    "bufferutil": "^4.0.6",
+    "utf-8-validate": "^5.0.9"
+  },
+  "ava": {
+    "files": [
+      "test/**/*.test.ts"
+    ],
+    "extensions": [
+      "ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "workerThreads": false,
+    "environmentVariables": {
+      "METRICS_ENABLED": "false"
+    }
+  }
+}