@chainlink/external-adapter-framework 0.0.10 → 0.0.14

package/package/util/expiring-sorted-set.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpiringSortedSet = void 0;
+/**
+ * This class implements a set of unique items, each of which has an expiration timestamp.
+ * On reads, items that have expired will be deleted from the set and not returned.
+ *
+ * @typeParam T - the type of the set entries' values
+ */
+class ExpiringSortedSet {
+    constructor() {
+        this.map = new Map();
+    }
+    add(key, value, ttl) {
+        this.map.set(key, {
+            value,
+            expirationTimestamp: Date.now() + ttl,
+        });
+    }
+    get(key) {
+        const entry = this.map.get(key);
+        if (!entry) {
+            return;
+        }
+        else if (entry.expirationTimestamp < Date.now()) {
+            return entry.value;
+        }
+        else {
+            this.map.delete(key);
+        }
+    }
+    getAll() {
+        const results = [];
+        const now = Date.now();
+        // Since we're iterating, might as well prune here
+        for (const [key, entry] of this.map.entries()) {
+            if (entry.expirationTimestamp < now) {
+                this.map.delete(key); // In theory, this shouldn't happen frequently for feeds
+            }
+            else {
+                results.push(entry.value);
+            }
+        }
+        return results;
+    }
+}
+exports.ExpiringSortedSet = ExpiringSortedSet;

package/package/util/index.d.ts

@@ -0,0 +1,11 @@
+export * from './request';
+export * from './logger';
+export * from './expiring-sorted-set';
+/**
+ * Sleeps for the provided number of milliseconds
+ * @param ms - The number of milliseconds to sleep for
+ * @returns a Promise that resolves once the specified time passes
+ */
+export declare const sleep: (ms: number) => Promise<void>;
+export declare const isObject: (o: unknown) => boolean;
+export declare const isArray: (o: unknown) => boolean;

package/package/util/index.js

@@ -0,0 +1,35 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArray = exports.isObject = exports.sleep = void 0;
+__exportStar(require("./request"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./expiring-sorted-set"), exports);
+/**
+ * Sleeps for the provided number of milliseconds
+ * @param ms - The number of milliseconds to sleep for
+ * @returns a Promise that resolves once the specified time passes
+ */
+const sleep = (ms) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+exports.sleep = sleep;
+const isObject = (o) => o !== null && typeof o === 'object' && Array.isArray(o) === false;
+exports.isObject = isObject;
+const isArray = (o) => o !== null && typeof o === 'object' && Array.isArray(o);
+exports.isArray = isArray;

package/package/util/logger.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import pino from 'pino';
+import { AdapterRequest } from './request';
+import { FastifyReply, HookHandlerDoneFunction } from 'fastify';
+import { AsyncLocalStorage } from 'node:async_hooks';
+export declare const asyncLocalStorage: AsyncLocalStorage<unknown>;
+export declare type Store = {
+    correlationId: string;
+};
+/**
+ * Instead of using a global logger instance, we want to force using a child logger
+ * with a specific layer set in it, so that we can filter logs by where they're output from.
+ *
+ * Details on what each log level represents:
+ * "trace": Forensic debugging of issues on a local machine.
+ * "debug": Detailed logging level to get more context from users on their environments.
+ * "info": High-level informational messages, to describe at a glance the high level state of the system.
+ * "warn": A mild error occurred that might require non-urgent action.
+ * "error": An unexpected error occurred during the regular operation of a well-maintained EA.
+ * "fatal": The EA encountered an unrecoverable problem and had to exit.
+ *
+ * Full reference this is based on can be found at
+ * https://github.com/smartcontractkit/documentation/blob/main/docs/Node%20Operators/configuration-variables.md#log_level
+ *
+ * @param layer - the layer name to include in the logs (e.g. "SomeMiddleware", "RedisCache", etc.)
+ * @returns a layer specific logger
+ */
+export declare const makeLogger: (layer: string) => pino.Logger<{
+    level: string;
+    mixin(): {};
+    transport: {
+        target: string;
+        options: {
+            levelFirst: boolean;
+            levelLabel: string;
+            ignore: string;
+            messageFormat: string;
+            translateTime: string;
+        };
+    } | undefined;
+} & pino.ChildLoggerOptions>;
+export declare const loggingContextMiddleware: (req: AdapterRequest, res: FastifyReply, done: HookHandlerDoneFunction) => void;

package/package/util/logger.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggingContextMiddleware = exports.makeLogger = exports.asyncLocalStorage = void 0;
+const pino_1 = __importDefault(require("pino"));
+const config_1 = require("../config");
+const crypto_1 = require("crypto");
+const node_async_hooks_1 = require("node:async_hooks");
+exports.asyncLocalStorage = new node_async_hooks_1.AsyncLocalStorage();
+const debugTransport = {
+    target: 'pino-pretty',
+    options: {
+        levelFirst: true,
+        levelLabel: 'level',
+        ignore: 'layer,pid,hostname',
+        messageFormat: '[{correlationId}][{layer}] {msg}',
+        translateTime: 'yyyy-mm-dd HH:MM:ss.l',
+    },
+};
+// Base logger, shouldn't be used because we want layers to be specified
+const baseLogger = (0, pino_1.default)({
+    level: process.env['LOG_LEVEL']?.toLowerCase() || config_1.BaseSettings.LOG_LEVEL.default,
+    mixin() {
+        if (process.env['CORRELATION_ID_ENABLED'] === 'true') {
+            const store = exports.asyncLocalStorage.getStore();
+            if (store) {
+                return store;
+            }
+        }
+        return {};
+    },
+    transport: process.env['DEBUG'] === 'true' ? debugTransport : undefined,
+});
+/**
+ * Instead of using a global logger instance, we want to force using a child logger
+ * with a specific layer set in it, so that we can filter logs by where they're output from.
+ *
+ * Details on what each log level represents:
+ * "trace": Forensic debugging of issues on a local machine.
+ * "debug": Detailed logging level to get more context from users on their environments.
+ * "info": High-level informational messages, to describe at a glance the high level state of the system.
+ * "warn": A mild error occurred that might require non-urgent action.
+ * "error": An unexpected error occurred during the regular operation of a well-maintained EA.
+ * "fatal": The EA encountered an unrecoverable problem and had to exit.
+ *
+ * Full reference this is based on can be found at
+ * https://github.com/smartcontractkit/documentation/blob/main/docs/Node%20Operators/configuration-variables.md#log_level
+ *
+ * @param layer - the layer name to include in the logs (e.g. "SomeMiddleware", "RedisCache", etc.)
+ * @returns a layer specific logger
+ */
+const makeLogger = (layer) => baseLogger.child({ layer });
+exports.makeLogger = makeLogger;
+const loggingContextMiddleware = (req, res, done) => {
+    const correlationId = req.headers['x-correlation-id'] || (0, crypto_1.randomUUID)();
+    exports.asyncLocalStorage.run({ correlationId: correlationId }, () => {
+        done();
+    });
+};
+exports.loggingContextMiddleware = loggingContextMiddleware;

package/package/util/request.d.ts

@@ -0,0 +1,55 @@
+import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from 'fastify';
+import { InitializedAdapter } from '../adapter';
+import { AdapterError } from '../validation/error';
+declare module 'fastify' {
+    interface FastifyRequest {
+        requestContext: AdapterRequestContext;
+    }
+}
+export interface AdapterRequestBody<T = AdapterRequestData> {
+    endpoint?: string;
+    data: T;
+    id?: string;
+}
+export declare type AdapterRequestContext<T = AdapterRequestData> = {
+    id: string;
+    endpointName: string;
+    cacheKey: string;
+    data: T;
+    meta?: AdapterRequestMeta;
+};
+export declare type AdapterRouteGeneric<T = AdapterRequestData> = {
+    Body: AdapterRequestBody<T>;
+};
+export declare type AdapterRequest<T = AdapterRequestData> = FastifyRequest<AdapterRouteGeneric<T>> & {
+    requestContext: AdapterRequestContext<T>;
+};
+/**
+ * Meta info that pertains to exposing metrics
+ */
+export interface AdapterRequestMeta {
+    metrics?: AdapterMetricsMeta;
+    error?: AdapterError | Error;
+}
+/**
+ * Meta info that pertains to exposing metrics
+ */
+export interface AdapterMetricsMeta {
+    feedId?: string;
+    cacheHit?: boolean;
+}
+export declare type AdapterRequestData = Record<string, unknown>;
+export interface ProviderResult<Params> {
+    params: Params;
+    value: unknown;
+}
+export declare type AdapterResponse<T = unknown> = {
+    statusCode: number;
+    data: T;
+    result: unknown;
+    maxAge?: number;
+    meta?: AdapterRequestMeta;
+    providerStatusCode?: number;
+};
+export declare type Middleware = ((req: AdapterRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => FastifyReply | void) | ((req: AdapterRequest, reply: FastifyReply) => Promise<FastifyReply | void>);
+export declare type AdapterMiddlewareBuilder = (adapter: InitializedAdapter) => Middleware;

package/package/util/request.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package/validation/error.d.ts

@@ -0,0 +1,50 @@
+import { HttpRequestType } from "../metrics/constants";
+declare type ErrorBasic = {
+    name: string;
+    message: string;
+};
+declare type ErrorFull = ErrorBasic & {
+    stack: string;
+    cause: string;
+};
+export declare type AdapterErrorResponse = {
+    jobRunID: string;
+    status: string;
+    statusCode: number;
+    providerStatusCode?: number;
+    error: ErrorBasic | ErrorFull;
+};
+export declare class AdapterError extends Error {
+    jobRunID: string;
+    status: string;
+    statusCode: number;
+    cause: any;
+    url?: string;
+    errorResponse: any;
+    feedID?: string;
+    providerStatusCode?: number;
+    metricsLabel?: HttpRequestType;
+    name: string;
+    message: string;
+    constructor({ jobRunID, status, statusCode, name, message, cause, url, errorResponse, feedID, providerStatusCode, metricsLabel }: Partial<AdapterError>);
+    toJSONResponse(): AdapterErrorResponse;
+}
+export declare class AdapterInputError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterRateLimitError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterTimeoutError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterDataProviderError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterConnectionError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export declare class AdapterCustomError extends AdapterError {
+    constructor(input: Partial<AdapterError>);
+}
+export {};

package/package/validation/error.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdapterCustomError = exports.AdapterConnectionError = exports.AdapterDataProviderError = exports.AdapterTimeoutError = exports.AdapterRateLimitError = exports.AdapterInputError = exports.AdapterError = void 0;
+const constants_1 = require("../metrics/constants");
+class AdapterError extends Error {
+    constructor({ jobRunID = '1', status = 'errored', statusCode = 500, name = 'AdapterError', message = 'An error occurred.', cause, url, errorResponse, feedID, providerStatusCode, metricsLabel = constants_1.HttpRequestType.ADAPTER_ERROR }) {
+        super(message);
+        this.jobRunID = jobRunID;
+        this.status = status;
+        this.statusCode = statusCode;
+        this.name = name;
+        this.message = message;
+        this.cause = cause;
+        if (url) {
+            this.url = url;
+        }
+        if (feedID) {
+            this.feedID = feedID;
+        }
+        this.errorResponse = errorResponse;
+        this.providerStatusCode = providerStatusCode;
+        this.metricsLabel = metricsLabel;
+    }
+    toJSONResponse() {
+        const showDebugInfo = process.env['NODE_ENV'] === 'development' || process.env['DEBUG'] === 'true';
+        const errorBasic = {
+            name: this.name,
+            message: this.message,
+            url: this.url,
+            errorResponse: this.errorResponse,
+            feedID: this.feedID,
+        };
+        const errorFull = { ...errorBasic, stack: this.stack, cause: this.cause };
+        return {
+            jobRunID: this.jobRunID,
+            status: this.status,
+            statusCode: this.statusCode,
+            providerStatusCode: this.providerStatusCode,
+            error: showDebugInfo ? errorFull : errorBasic,
+        };
+    }
+}
+exports.AdapterError = AdapterError;
+class AdapterInputError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.INPUT_ERROR });
+    }
+}
+exports.AdapterInputError = AdapterInputError;
+class AdapterRateLimitError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.RATE_LIMIT_ERROR });
+    }
+}
+exports.AdapterRateLimitError = AdapterRateLimitError;
+class AdapterTimeoutError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.TIMEOUT_ERROR });
+    }
+}
+exports.AdapterTimeoutError = AdapterTimeoutError;
+class AdapterDataProviderError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.DP_ERROR });
+    }
+}
+exports.AdapterDataProviderError = AdapterDataProviderError;
+class AdapterConnectionError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.CONNECTION_ERROR });
+    }
+}
+exports.AdapterConnectionError = AdapterConnectionError;
+class AdapterCustomError extends AdapterError {
+    constructor(input) {
+        super({ ...input, metricsLabel: constants_1.HttpRequestType.CUSTOM_ERROR });
+    }
+}
+exports.AdapterCustomError = AdapterCustomError;

package/package/validation/index.d.ts

@@ -0,0 +1,5 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { AdapterMiddlewareBuilder } from '../util/request';
+export { InputParameters } from './input-params';
+export declare const validatorMiddleware: AdapterMiddlewareBuilder;
+export declare const errorCatchingMiddleware: (err: Error, req: FastifyRequest, res: FastifyReply) => void;

package/package/validation/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorCatchingMiddleware = exports.validatorMiddleware = void 0;
+const cache_1 = require("../cache");
+const util_1 = require("../metrics/util");
+const util_2 = require("../util");
+const error_1 = require("./error");
+const validator_1 = require("./validator");
+const override_functions_1 = require("./override-functions");
+const errorCatcherLogger = (0, util_2.makeLogger)('ErrorCatchingMiddleware');
+const validatorMiddleware = (adapter) => (req, reply, done) => {
+    if (req.headers['content-type'] !== 'application/json') {
+        throw new error_1.AdapterInputError({
+            message: 'Content type not "application/json", returning 400',
+            statusCode: 400,
+        });
+    }
+    if (!req.body) {
+        throw new error_1.AdapterInputError({
+            message: 'Body not present in adapter request, returning 400',
+            statusCode: 400,
+        });
+    }
+    // Make endpoints case insensitive
+    const endpointParam = req.body.endpoint?.toLowerCase() || adapter.defaultEndpoint;
+    if (!endpointParam) {
+        throw new error_1.AdapterInputError({
+            message: `Request body does not specify an endpoint, and there is no default endpoint configured for this adapter.`,
+            statusCode: 400,
+        });
+    }
+    const endpoint = adapter.endpointsMap[endpointParam];
+    if (!endpoint) {
+        throw new error_1.AdapterInputError({
+            message: `Adapter does not have a "${req.body.endpoint}" endpoint.`,
+            statusCode: 404,
+        });
+    }
+    // Validate data using validator from v2
+    // TODO: See if we want to change this whole thing
+    const validator = new validator_1.Validator(req.body, endpoint.inputParameters);
+    req.requestContext = {
+        id: req.body.id || '1',
+        cacheKey: '',
+        data: validator.validated.data,
+        endpointName: endpoint.name,
+    };
+    if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
+        // Add metrics meta which includes feedId to the request
+        // Perform prior to overrides to maintain consistent Feed IDs across adapters
+        const metrics = (0, util_1.getMetricsMeta)(endpoint, validator.validated.data);
+        req.requestContext = { ...req.requestContext, meta: { metrics } };
+    }
+    // TODO: Support `includes` and `tokenOverrides` overrides as needed
+    const requestParams = req.requestContext.data ?? {};
+    if (requestParams['tokenOverrides']) {
+        throw new Error('Token overrides not yet supported');
+    }
+    if (requestParams['includes']) {
+        throw new Error('Includes not yet supported');
+    }
+    // Swaps the 'base' parameter if any overrides are found in the request or the adapter configuration
+    // Supports 'base' input as string or string[]
+    (0, override_functions_1.performSymbolOverrides)(adapter, req);
+    req.requestContext.cacheKey = (0, cache_1.calculateCacheKey)({
+        adapterEndpoint: endpoint,
+        adapterConfig: adapter.config,
+    }, req.requestContext.data);
+    done();
+};
+exports.validatorMiddleware = validatorMiddleware;
+const errorCatchingMiddleware = (err, req, res) => {
+    // Add adapter or generic error to request meta for metrics use
+    req.requestContext.meta = { ...req.requestContext.meta, error: err };
+    if (err instanceof error_1.AdapterError) {
+        // We want to log these as warn, because although they are to be expected, NOPs should
+        // Only use "correct" job specs and therefore not hit adapters with invalid requests.
+        errorCatcherLogger.warn(err);
+        res.status(err.statusCode).send(err.toJSONResponse());
+    }
+    else {
+        errorCatcherLogger.error(err);
+        res.status(200).send('There was an unexpected error in the adapter.');
+    }
+};
+exports.errorCatchingMiddleware = errorCatchingMiddleware;

package/package/validation/input-params.d.ts

@@ -0,0 +1,15 @@
+export declare type Override = Map<string, Map<string, string>>;
+export declare type InputParameter = {
+    aliases?: string[];
+    description?: string;
+    type?: 'bigint' | 'boolean' | 'array' | 'number' | 'object' | 'string';
+    required?: boolean;
+    options?: unknown[];
+    default?: unknown;
+    dependsOn?: string[];
+    exclusive?: string[];
+};
+export declare type InputParameters = {
+    [name: string]: InputParameter | boolean | string[];
+};
+export declare const baseInputParameters: InputParameters;

package/package/validation/input-params.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseInputParameters = void 0;
+exports.baseInputParameters = {
+    endpoint: {
+        description: 'The External Adapter "endpoint" name to use.',
+        required: false,
+        type: 'string',
+    },
+    resultPath: {
+        description: 'The path to key into the API response the retrieve the result',
+        required: false,
+        // Type: 'string', TODO: Once multiple types are supported this could be string or array of strings
+    },
+    overrides: {
+        description: 'Override the mapping of token symbols to another token symbol',
+        required: false,
+        // Type: 'string', TODO: Once complex types are supported this could be { [adapter: string]: { [token: string]: string } }
+    },
+    tokenOverrides: {
+        description: 'Override the mapping of token symbols to smart contract address',
+        required: false,
+        // Type: 'string', TODO: Once complex types are supported this could be { [network: string]: { [token: string]: string } }
+    },
+    includes: {
+        description: 'Override the array of includes that holds additional input parameters when matching a pair of symbols',
+        required: false,
+        // Type: 'string', TODO: Once complex types are supported this could be { from: string, to: string, includes: [{ from: string, to: string, adapters: string[], inverse: boolean, tokens: boolean }] } }[]
+    },
+};

package/package/validation/override-functions.d.ts

@@ -0,0 +1,3 @@
+import { InitializedAdapter } from '../adapter';
+import { AdapterRequest } from '../util/request';
+export declare const performSymbolOverrides: (adapter: InitializedAdapter, req: AdapterRequest) => void;

package/package/validation/override-functions.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performSymbolOverrides = void 0;
+const performSymbolOverrides = (adapter, req) => {
+    let adapterOverrides = {};
+    if (req.requestContext.data &&
+        req.requestContext.data['overrides'] &&
+        req.requestContext.data['overrides'][adapter.name]) {
+        adapterOverrides = req.requestContext.data['overrides'][adapter.name];
+    }
+    if (!Array.isArray(req.requestContext.data['base'])) {
+        // Perform overrides specified in the request payload
+        req.requestContext.data['base'] =
+            adapterOverrides[req.requestContext.data['base']] ?? req.requestContext.data['base'];
+        // Perform hardcoded overrides
+        if (adapter.overrides) {
+            req.requestContext.data['base'] =
+                adapter.overrides[req.requestContext.data['base']] ??
+                    req.requestContext.data['base'];
+        }
+        return;
+    }
+    let requestedSymbols = req.requestContext.data['base'];
+    for (let i = 0; i < requestedSymbols.length; i++) {
+        const symbol = requestedSymbols[i];
+        // Perform overrides specified in the request payload
+        let overriddenSymbol = adapterOverrides[symbol.toUpperCase()] ?? adapterOverrides[symbol.toLowerCase()];
+        // Perform hardcoded overrides
+        if (adapter.overrides) {
+            overriddenSymbol =
+                adapter.overrides[symbol.toUpperCase()] ??
+                    adapter.overrides[symbol.toLowerCase()] ??
+                    overriddenSymbol;
+        }
+        requestedSymbols[i] = overriddenSymbol ?? requestedSymbols[i];
+    }
+    requestedSymbols = requestedSymbols.length > 1 ? requestedSymbols : requestedSymbols[1];
+    req.requestContext.data['base'] = requestedSymbols;
+};
+exports.performSymbolOverrides = performSymbolOverrides;

package/package/validation/preset-tokens.json

@@ -0,0 +1,23 @@
+{
+    "ethereum": {
+        "LINK": "0x514910771af9ca656af840dff83e8264ecf986ca",
+        "WETH": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+        "ETH": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        "stETH": "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
+        "DIGG": "0x798d1be841a82a273720ce31c822c61a67a601c3",
+        "WBTC": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
+        "RAI": "0x03ab458634910aad20ef5f1c8ee96f1d6ac54919",
+        "RGT": "0xD291E7a03283640FDc51b121aC401383A46cC623",
+        "RARI": "0xFca59Cd816aB1eaD66534D82bc21E7515cE441CF",
+        "SFI": "0xb753428af26e81097e7fd17f40c88aaa3e04902c",
+        "LDO": "0x5a98fcbea516cf06857215779fd812ca3bef1b32",
+        "VSP": "0x1b40183EFB4Dd766f11bDa7A7c3AD8982e998421",
+        "USDC": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        "USDT": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        "DAI": "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+        "FRAX": "0x853d955aCEf822Db058eb8505911ED77F175b99e",
+        "BOND": "0x0391d2021f89dc339f60fff84546ea23e337750f",
+        "FEI": "0x956f47f50a910163d8bf957cf5846d573e7f87ca",
+        "TRIBE": "0xc7283b66Eb1EB5FB86327f08e1B5816b0720212B"
+    }
+}

package/package/validation/validator.d.ts

@@ -0,0 +1,47 @@
+import { AdapterError, AdapterErrorResponse } from './error';
+import { InputParameters, Override } from './input-params';
+export declare type OverrideType = 'overrides' | 'tokenOverrides' | 'includes';
+declare type InputType = {
+    id?: string;
+    data?: any;
+};
+export interface ValidatorOptions {
+    shouldThrowError?: boolean;
+    includes?: any[];
+    overrides?: any;
+}
+export declare type IncludePair = {
+    from: string;
+    to: string;
+    adapters?: string[];
+    inverse?: boolean;
+    tokens?: boolean;
+};
+export declare type Includes = {
+    from: string;
+    to: string;
+    includes: IncludePair[];
+};
+export declare class Validator {
+    input: InputType;
+    inputConfigs: InputParameters;
+    inputOptions: Record<string, any[]>;
+    validatorOptions: ValidatorOptions;
+    validated: any;
+    error: AdapterError | undefined;
+    errored: AdapterErrorResponse | undefined;
+    constructor(input?: InputType, inputConfigs?: {}, inputOptions?: {}, validatorOptions?: ValidatorOptions);
+    validateInput(): void;
+    validateOverrides(path: 'overrides' | 'tokenOverrides', preset: Record<string, any>): void;
+    checkDuplicateInputParams(inputConfig: InputParameters): void;
+    validateIncludeOverrides(): void;
+    parseError(error: unknown): void;
+    formatOverride: (param: any) => Override;
+    formatIncludeOverrides: (param: any) => Override;
+    throwInvalid: (message: string) => void;
+    validateObjectParam(key: string, shouldThrowError?: boolean): void;
+    validateOptionalParam(param: any, key: string, options: any[]): void;
+    validateRequiredParam(param: any, key: string, options: any[]): void;
+    getUsedKey(key: string, keyArray: string[]): string | undefined;
+}
+export {};