@chainlink/external-adapter-framework 0.0.10 → 0.0.12

package/dist/src/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: unknown;
+    url?: string;
+    errorResponse: unknown;
+    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/dist/src/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/dist/src/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/dist/src/validation/index.js

@@ -0,0 +1,91 @@
+"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() ||
+        req.body.data?.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 "${endpointParam}" 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)({
+            adapterEndpoint: endpoint,
+            adapterConfig: adapter.config,
+        }, 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/dist/src/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/dist/src/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/dist/src/validation/override-functions.d.ts

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

package/dist/src/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/dist/src/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/dist/src/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 {};