@chainlink/external-adapter-framework 0.0.14 → 0.0.16

package/package/validation/error.js

@@ -1,79 +0,0 @@
-"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

@@ -1,5 +0,0 @@
-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

@@ -1,86 +0,0 @@
-"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

@@ -1,15 +0,0 @@
-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

@@ -1,30 +0,0 @@
-"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

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

package/package/validation/preset-tokens.json

@@ -1,23 +0,0 @@
-{
-    "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

@@ -1,47 +0,0 @@
-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 {};

package/package/validation/validator.js

@@ -1,303 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validator = void 0;
-const error_1 = require("./error");
-const input_params_1 = require("./input-params");
-const util_1 = require("../util");
-const preset_tokens_json_1 = __importDefault(require("./preset-tokens.json"));
-// Don't want to get requester in just yet, only copying the static method 'errored'
-const requesterErrored = (jobRunID = '1', error = undefined, statusCode = 500, feedID = undefined) => {
-    if (error instanceof error_1.AdapterError) {
-        error.jobRunID = jobRunID;
-        if (feedID) {
-            error.feedID = feedID;
-        }
-        return error.toJSONResponse();
-    }
-    if (error instanceof Error) {
-        return new error_1.AdapterError({
-            jobRunID,
-            statusCode,
-            message: error.message,
-            cause: error,
-            feedID,
-        }).toJSONResponse();
-    }
-    return new error_1.AdapterError({ jobRunID, statusCode, message: error, feedID }).toJSONResponse();
-};
-class Validator {
-    constructor(input = { id: '1', data: {} }, inputConfigs = {}, inputOptions = {}, validatorOptions = {}) {
-        // OverrideSymbol = (adapter: string, symbol?: string | string[]): string | string[] => {
-        //   Const defaultSymbol = symbol || this.validated.data.base
-        //   If (!defaultSymbol) this.throwInvalid(`Required parameter not supplied: base`)
-        //   // TODO: Will never be reached, because the presetSymbols are used as default overrides
-        //   If (!this.validated.overrides) return defaultSymbol
-        //   If (!Array.isArray(defaultSymbol))
-        //     Return (
-        //       This.validated.overrides.get(adapter.toLowerCase())?.get(defaultSymbol.toLowerCase()) ||
-        //       DefaultSymbol
-        //     )
-        //   Const multiple: string[] = []
-        //   For (const sym of defaultSymbol) {
-        //     Const overrided = this.validated.overrides.get(adapter.toLowerCase())?.get(sym.toLowerCase())
-        //     If (!overrided) multiple.push(sym)
-        //     Else multiple.push(overrided)
-        //   }
-        //   Return multiple
-        // }
-        // OverrideToken = (symbol: string, network = 'ethereum'): string | undefined => {
-        //   Return this.validated.tokenOverrides?.get(network.toLowerCase())?.get(symbol.toLowerCase())
-        // }
-        // OverrideIncludes = (from: string, to: string): IncludePair | undefined => {
-        //   // Search through `presetIncludes` to find matching override for adapter and to/from pairing.
-        //   Const pairs = (
-        //     This.validated.includes?.filter(
-        //       (val: string | Includes) => typeof val !== 'string',
-        //     ) as Includes[]
-        //   ).filter(
-        //     (pair) =>
-        //       Pair.from.toLowerCase() === from.toLowerCase() &&
-        //       Pair.to.toLowerCase() === to.toLowerCase(),
-        //   )
-        //   If (!pairs || !pairs[0] || !pairs[0].includes || !pairs[0].includes[0]) {
-        //     Return
-        //   }
-        //   Return pairs[0].includes[0]
-        // }
-        // OverrideReverseLookup = (adapter: string, type: OverrideType, symbol: string): string => {
-        //   Const overrides: Map<string, string> | undefined = this.validated?.[type]?.get(
-        //     Adapter.toLowerCase(),
-        //   )
-        //   If (!overrides) return symbol
-        //   Let originalSymbol: string | undefined
-        //   Overrides.forEach((overridden, original) => {
-        //     If (overridden.toLowerCase() === symbol.toLowerCase()) originalSymbol = original
-        //   })
-        //   Return originalSymbol || symbol
-        // }
-        this.formatOverride = (param) => {
-            const _throwInvalid = () => this.throwInvalid(`Parameter supplied with wrong format: "override"`);
-            if (!(0, util_1.isObject)(param)) {
-                _throwInvalid();
-            }
-            const _isValid = Object.values(param).every(util_1.isObject);
-            if (!_isValid) {
-                _throwInvalid();
-            }
-            const _keyToLowerCase = (entry) => {
-                return [entry[0].toLowerCase(), entry[1]];
-            };
-            return new Map(Object.entries(param)
-                .map(_keyToLowerCase)
-                .map(([key, value]) => [key, new Map(Object.entries(value).map(_keyToLowerCase))]));
-        };
-        this.formatIncludeOverrides = (param) => {
-            const _throwInvalid = () => this.throwInvalid(`Parameter supplied with wrong format: "includes"`);
-            if (!(0, util_1.isArray)(param)) {
-                _throwInvalid();
-            }
-            const _isValid = Object.values(param).every((val) => (0, util_1.isObject)(val) || typeof val === 'string');
-            if (!_isValid) {
-                _throwInvalid();
-            }
-            return param;
-        };
-        this.throwInvalid = (message) => {
-            throw new error_1.AdapterError({ jobRunID: this.validated.id, statusCode: 400, message });
-        };
-        this.input = { ...input };
-        if (!this.input.id) {
-            this.input.id = '1';
-        } // TODO Please remove these once "no any" strict typing is enabled
-        if (!this.input.data) {
-            this.input.data = {};
-        }
-        this.inputConfigs = { ...input_params_1.baseInputParameters, ...inputConfigs };
-        this.inputOptions = { ...inputOptions };
-        this.validatorOptions = {
-            shouldThrowError: true,
-            includes: [],
-            overrides: {},
-            ...validatorOptions,
-        };
-        this.validated = { id: this.input.id, data: {} };
-        this.validateInput();
-        this.validateOverrides('overrides', this.validatorOptions.overrides);
-        this.validateOverrides('tokenOverrides', preset_tokens_json_1.default);
-        this.validateIncludeOverrides();
-        this.checkDuplicateInputParams(inputConfigs);
-    }
-    validateInput() {
-        try {
-            for (const key in this.inputConfigs) {
-                this.validateObjectParam(key, this.validatorOptions.shouldThrowError);
-            }
-        }
-        catch (e) {
-            this.parseError(e);
-        }
-    }
-    validateOverrides(path, preset) {
-        try {
-            if (!this.input.data?.[path]) {
-                this.validated[path] = this.formatOverride(preset);
-                return;
-            }
-            this.validated[path] = this.formatOverride({ ...preset, ...this.input.data[path] });
-        }
-        catch (e) {
-            this.parseError(e);
-        }
-    }
-    checkDuplicateInputParams(inputConfig) {
-        let aliases = [];
-        for (const key in inputConfig) {
-            const param = inputConfig[key];
-            if (Array.isArray(param)) {
-                aliases = aliases.concat(param);
-            }
-            else if (typeof inputConfig === 'boolean') {
-                return;
-            }
-            else {
-                aliases.push(key);
-                if (typeof param === 'object' && 'aliases' in param && Array.isArray(param.aliases)) {
-                    aliases = aliases.concat(param.aliases);
-                }
-            }
-        }
-        if (aliases.length !== new Set(aliases).size) {
-            this.throwInvalid('Duplicate Input Aliases');
-        }
-    }
-    validateIncludeOverrides() {
-        try {
-            this.validated.includes = this.formatIncludeOverrides([
-                ...(Array.isArray(this.input.data?.includes) ? this.input.data.includes : []),
-                ...(this.validatorOptions.includes || []),
-            ]);
-        }
-        catch (e) {
-            this.parseError(e);
-        }
-    }
-    parseError(error) {
-        if (!(error instanceof Error)) {
-            return;
-        }
-        const message = 'Error validating input.';
-        if (error instanceof error_1.AdapterError) {
-            this.error = error;
-        }
-        else {
-            this.error = new error_1.AdapterError({
-                jobRunID: this.validated.id,
-                statusCode: 400,
-                message,
-                cause: error,
-            });
-        }
-        this.errored = requesterErrored(this.validated.id, this.error);
-        if (this.validatorOptions.shouldThrowError) {
-            throw this.error;
-        }
-    }
-    validateObjectParam(key, shouldThrowError = true) {
-        const inputConfig = this.inputConfigs[key];
-        const usedKey = this.getUsedKey(key, inputConfig.aliases ?? []);
-        const param = usedKey
-            ? this.input.data[usedKey] ?? inputConfig.default
-            : inputConfig.default;
-        if (shouldThrowError) {
-            const paramIsDefined = !(param === undefined || param === null || param === '');
-            if (inputConfig.required && !paramIsDefined) {
-                this.throwInvalid(`Required parameter ${key} must be non-null and non-empty`);
-            }
-            if (paramIsDefined) {
-                if (inputConfig.type) {
-                    const primitiveTypes = ['boolean', 'number', 'bigint', 'string'];
-                    if (![...primitiveTypes, 'array', 'object'].includes(inputConfig.type)) {
-                        this.throwInvalid(`${key} parameter has unrecognized type ${inputConfig.type}`);
-                    }
-                    if (primitiveTypes.includes(inputConfig.type) && typeof param !== inputConfig.type) {
-                        this.throwInvalid(`${key} parameter must be of type ${inputConfig.type}`);
-                    }
-                    if (inputConfig.type === 'array' && (!Array.isArray(param) || param.length === 0)) {
-                        this.throwInvalid(`${key} parameter must be a non-empty array`);
-                    }
-                    if (inputConfig.type === 'object' &&
-                        (!param ||
-                            Array.isArray(param) ||
-                            typeof param !== inputConfig.type ||
-                            Object.keys(param).length === 0)) {
-                        this.throwInvalid(`${key} parameter must be an object with at least one property`);
-                    }
-                }
-                // If (inputConfig.options) {
-                //   Const tolcase = (o: any) => (typeof o === 'string' ? o.toLowerCase() : o)
-                //   Const formattedOptions = inputConfig.options.map(tolcase)
-                //   Const formattedParam = tolcase(param)
-                //   If (!formattedOptions.includes(formattedParam))
-                //     This.throwInvalid(
-                //       `${key} parameter '${formattedParam}' is not in the set of available options: ${formattedOptions.join(
-                //         ',',
-                //       )}`,
-                //     )
-                // }
-                // For (const dependency of inputConfig.dependsOn ?? []) {
-                //   Const usedDependencyKey = this.getUsedKey(
-                //     Dependency,
-                //     (this.inputConfigs[dependency] as InputParameter).aliases ?? [],
-                //   )
-                //   If (!usedDependencyKey) this.throwInvalid(`${key} dependency ${dependency} not supplied`)
-                // }
-                // For (const exclusive of inputConfig.exclusive ?? []) {
-                //   Const usedExclusiveKey = this.getUsedKey(
-                //     Exclusive,
-                //     (this.inputConfigs[exclusive] as InputParameter).aliases ?? [],
-                //   )
-                //   If (usedExclusiveKey)
-                //     This.throwInvalid(`${key} cannot be supplied concurrently with ${exclusive}`)
-                // }
-            }
-        }
-        this.validated.data[key] = param;
-    }
-    validateOptionalParam(param, key, options) {
-        if (param && options) {
-            if (!Array.isArray(options)) {
-                this.throwInvalid(`Parameter options for ${key} must be of an Array type`);
-            }
-            if (!options.includes(param)) {
-                this.throwInvalid(`${param} is not a supported ${key} option. Must be one of ${options}`);
-            }
-        }
-        this.validated.data[key] = param;
-    }
-    validateRequiredParam(param, key, options) {
-        if (typeof param === 'undefined' || param === '') {
-            this.throwInvalid(`Required parameter not supplied: ${key}`);
-        }
-        if (options) {
-            if (!Array.isArray(options)) {
-                this.throwInvalid(`Parameter options for ${key} must be of an Array type`);
-            }
-            if (!options.includes(param)) {
-                this.throwInvalid(`${param} is not a supported ${key} option. Must be one of ${options.join(' || ')}`);
-            }
-        }
-        this.validated.data[key] = param;
-    }
-    getUsedKey(key, keyArray) {
-        const comparisonArray = [...keyArray];
-        if (!comparisonArray.includes(key)) {
-            comparisonArray.push(key);
-        }
-        const inputParamKeys = Object.keys(this.input.data);
-        return inputParamKeys.find((k) => comparisonArray.includes(k));
-    }
-}
-exports.Validator = Validator;

package/rate-limiting/background/fixed-frequency.d.ts

@@ -1,10 +0,0 @@
-import { AdapterRateLimitTier, BackgroundExecuteRateLimiter } from '..';
-import { AdapterEndpoint } from '../../adapter';
-export declare const DEFAULT_SHARED_MS_BETWEEN_REQUESTS = 5000;
-export declare class FixedFrequencyRateLimiter implements BackgroundExecuteRateLimiter {
-    msBetweenRequestsMap: {
-        [endpointName: string]: number;
-    };
-    initialize(endpoints: AdapterEndpoint[], limits?: AdapterRateLimitTier): this;
-    msUntilNextExecution(endpointName: string): number;
-}

package/rate-limiting/index.d.ts

@@ -1,54 +0,0 @@
-import { AdapterEndpoint } from '../adapter';
-export * from './request/simple-counting';
-export * from './background/fixed-frequency';
-export interface AdapterRateLimitTier {
-    rateLimit1s?: number;
-    rateLimit1m?: number;
-    rateLimit1h?: number;
-    note?: string;
-}
-/**
- * Common interface for all RateLimiter classes to implement
- */
-export interface RateLimiter {
-    /**
-     * Method to ensure all RateLimiters can be initialized in the same manner.
-     *
-     * @param limits - settings for how much throughput to allow for the Adapter
-     * @param endpoints - list of adapter endpoints
-     */
-    initialize(endpoints: AdapterEndpoint[], limits: AdapterRateLimitTier): this;
-}
-/**
- * RequestRateLimiters perform checks agains imminent outbound requests for any transport.
- */
-export interface RequestRateLimiter extends RateLimiter {
-    /**
-     * This method will check using whatever strategy is implemented to determine if
-     * this request can be processed. If so, it returns true; if not, returns false.
-     */
-    isUnderLimits(): boolean;
-}
-/**
- * BackgroundExecuteFrequencyRateLimiters will implement custom logic to calculate
- * the period of time to wait between background executions for a transport.
- */
-export interface BackgroundExecuteRateLimiter extends RateLimiter {
-    msUntilNextExecution(endpointName: string): number;
-}
-/**
- * This method will convert all possible settings for a rate limit tier and
- * convert them all to requests per second, returning the lowest one
- *
- * @param limits - the rate limit tier set for the adapter
- * @returns the most restrictive of the set options, in requests per second
- */
-export declare const consolidateTierLimits: (limits?: AdapterRateLimitTier) => number;
-/**
- * Validates rate limiting tiers specified for the adapter, and returns the one to use.
- *
- * @param tiers - the adapter config listing the different available API tiers
- * @param selectedTier - chosen API tier from settings, if present
- * @returns the specified API tier, or a default one if none are specified
- */
-export declare const getRateLimitingTier: (tiers?: Record<string, AdapterRateLimitTier>, selectedTier?: string) => AdapterRateLimitTier | undefined;

package/rate-limiting/metrics.d.ts

@@ -1,3 +0,0 @@
-import * as client from 'prom-client';
-export declare const retrieveCost: <ProviderResponseBody>(data: ProviderResponseBody) => number;
-export declare const rateLimitCreditsSpentTotal: client.Counter<"feed_id" | "participant_id">;