@chainlink/external-adapter-framework 0.0.6 → 0.0.7

package/src/validation/index.ts

@@ -1,101 +0,0 @@
-import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from 'fastify'
-import { InitializedAdapter } from '../adapter'
-import { calculateCacheKey } from '../cache'
-import { getMetricsMeta } from '../metrics/util'
-import { makeLogger } from '../util'
-import { AdapterMiddlewareBuilder, AdapterRequest } from '../util/request'
-import { AdapterError, AdapterInputError } from './error'
-import { Validator } from './validator'
-import { performSymbolOverrides } from './override-functions'
-export { InputParameters } from './input-params'
-
-const errorCatcherLogger = makeLogger('ErrorCatchingMiddleware')
-
-export const validatorMiddleware: AdapterMiddlewareBuilder =
-  (adapter: InitializedAdapter) =>
-  (req: AdapterRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => {
-    if (req.headers['content-type'] !== 'application/json') {
-      throw new AdapterInputError({
-        message: 'Content type not "application/json", returning 400',
-        statusCode: 400,
-      })
-    }
-
-    if (!req.body) {
-      throw new 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 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 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(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 = 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[]
-    performSymbolOverrides(adapter, req)
-
-    req.requestContext.cacheKey = calculateCacheKey(
-      {
-        adapterEndpoint: endpoint,
-        adapterConfig: adapter.config,
-      },
-      req.requestContext.data,
-    )
-
-    done()
-  }
-
-export const errorCatchingMiddleware = (err: Error, req: FastifyRequest, res: FastifyReply) => {
-  // Add adapter or generic error to request meta for metrics use
-  req.requestContext.meta = { ...req.requestContext.meta, error: err }
-  if (err instanceof 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.')
-  }
-}

package/src/validation/input-params.ts

@@ -1,45 +0,0 @@
-/* INPUT TYPE VALIDATIONS */
-export type Override = Map<string, Map<string, string>>
-
-export type InputParameter = {
-  aliases?: string[]
-  description?: string
-  type?: 'bigint' | 'boolean' | 'array' | 'number' | 'object' | 'string'
-  required?: boolean
-  options?: unknown[] // Enumerated options, ex. ['ADA', 'BTC', 'ETH']
-  default?: unknown
-  dependsOn?: string[] // Other inputs this one depends on
-  exclusive?: string[] // Other inputs that cannot be present with this one
-}
-
-export type InputParameters = {
-  [name: string]: InputParameter | boolean | string[]
-}
-export const baseInputParameters: InputParameters = {
-  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/src/validation/override-functions.ts

@@ -1,44 +0,0 @@
-import { InitializedAdapter } from '../adapter'
-import { AdapterRequest } from '../util/request'
-
-type Overrides = Record<string, Record<string, string>>
-
-export const performSymbolOverrides = (adapter: InitializedAdapter, req: AdapterRequest) => {
-  let adapterOverrides = {} as Record<string, string>
-  if (
-    req.requestContext.data &&
-    req.requestContext.data['overrides'] &&
-    (req.requestContext.data['overrides'] as Overrides)[adapter.name]
-  ) {
-    adapterOverrides = (req.requestContext.data['overrides'] as 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'] as string] ?? req.requestContext.data['base']
-    // Perform hardcoded overrides
-    if (adapter.overrides) {
-      req.requestContext.data['base'] =
-        adapter.overrides[req.requestContext.data['base'] as string] ??
-        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
-}

package/src/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/src/validation/validator.ts

@@ -1,384 +0,0 @@
-import { AdapterError, AdapterErrorResponse } from './error'
-import { InputParameter, InputParameters, Override, baseInputParameters } from './input-params'
-import { isArray, isObject } from '../util'
-import presetTokens from './preset-tokens.json'
-
-export type OverrideType = 'overrides' | 'tokenOverrides' | 'includes'
-
-type InputType = {
-  id?: string
-  data?: any
-}
-
-export interface ValidatorOptions {
-  shouldThrowError?: boolean
-  includes?: any[]
-  overrides?: any
-}
-
-// Includes is an alternative symbol mapping that can be used to represent
-// The original request, such as wrapped tokens on DEXes.
-export type IncludePair = {
-  from: string // From symbol
-  to: string // To symbol
-  adapters?: string[] // Array of adapters this applies to
-  inverse?: boolean // If the inverse should be calculated instead
-  tokens?: boolean // If the token addresses should be used instead
-}
-
-export type Includes = {
-  from: string
-  to: string
-  includes: IncludePair[]
-}
-
-// Don't want to get requester in just yet, only copying the static method 'errored'
-const requesterErrored = (
-  jobRunID = '1',
-  error: AdapterError | Error | string | undefined = undefined,
-  statusCode = 500,
-  feedID: string | undefined = undefined,
-): AdapterErrorResponse => {
-  if (error instanceof AdapterError) {
-    error.jobRunID = jobRunID
-    if (feedID) {
-      error.feedID = feedID
-    }
-    return error.toJSONResponse()
-  }
-  if (error instanceof Error) {
-    return new AdapterError({
-      jobRunID,
-      statusCode,
-      message: error.message,
-      cause: error,
-      feedID,
-    }).toJSONResponse()
-  }
-  return new AdapterError({ jobRunID, statusCode, message: error, feedID }).toJSONResponse()
-}
-
-export class Validator {
-  input: InputType
-  inputConfigs: InputParameters
-  inputOptions: Record<string, any[]>
-  validatorOptions: ValidatorOptions
-  validated: any
-  error: AdapterError | undefined
-  errored: AdapterErrorResponse | undefined
-  constructor(
-    input: InputType = { id: '1', data: {} },
-    inputConfigs = {},
-    inputOptions = {},
-    validatorOptions: ValidatorOptions = {},
-  ) {
-    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 = { ...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', presetTokens)
-    this.validateIncludeOverrides()
-    this.checkDuplicateInputParams(inputConfigs)
-  }
-
-  validateInput(): void {
-    try {
-      for (const key in this.inputConfigs) {
-        this.validateObjectParam(key, this.validatorOptions.shouldThrowError)
-      }
-    } catch (e) {
-      this.parseError(e)
-    }
-  }
-
-  validateOverrides(path: 'overrides' | 'tokenOverrides', preset: Record<string, any>): void {
-    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: InputParameters): void {
-    let aliases: string[] = []
-    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(): void {
-    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: unknown): void {
-    if (!(error instanceof Error)) {
-      return
-    }
-    const message = 'Error validating input.'
-    if (error instanceof AdapterError) {
-      this.error = error
-    } else {
-      this.error = new 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
-    }
-  }
-
-  // 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
-  // }
-
-  formatOverride = (param: any): Override => {
-    const _throwInvalid = () =>
-      this.throwInvalid(`Parameter supplied with wrong format: "override"`)
-
-    if (!isObject(param)) {
-      _throwInvalid()
-    }
-
-    const _isValid = Object.values(param).every(isObject)
-    if (!_isValid) {
-      _throwInvalid()
-    }
-
-    const _keyToLowerCase = (entry: [string, any]): [string, any] => {
-      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))]),
-    )
-  }
-
-  formatIncludeOverrides = (param: any): Override => {
-    const _throwInvalid = () =>
-      this.throwInvalid(`Parameter supplied with wrong format: "includes"`)
-    if (!isArray(param)) {
-      _throwInvalid()
-    }
-
-    const _isValid = Object.values(param).every((val) => isObject(val) || typeof val === 'string')
-    if (!_isValid) {
-      _throwInvalid()
-    }
-
-    return param
-  }
-
-  throwInvalid = (message: string): void => {
-    throw new AdapterError({ jobRunID: this.validated.id, statusCode: 400, message })
-  }
-
-  validateObjectParam(key: string, shouldThrowError = true): void {
-    const inputConfig = this.inputConfigs[key] as InputParameter
-    const usedKey = this.getUsedKey(key, inputConfig.aliases ?? [])
-
-    const param = usedKey
-      ? this.input.data[usedKey as string] ?? 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: any, key: string, options: any[]): void {
-    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: any, key: string, options: any[]): void {
-    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: string, keyArray: string[]): string | undefined {
-    const comparisonArray = [...keyArray]
-    if (!comparisonArray.includes(key)) {
-      comparisonArray.push(key)
-    }
-
-    const inputParamKeys = Object.keys(this.input.data)
-    return inputParamKeys.find((k) => comparisonArray.includes(k))
-  }
-}

package/test/adapter.test.ts

@@ -1,27 +0,0 @@
-import test from 'ava'
-import { expose } from '../src'
-import { Adapter } from '../src/adapter'
-import { NopTransport } from './util'
-
-test('duplicate endpoint names throw error on startup', async (t) => {
-  const adapter: Adapter = {
-    name: 'test',
-    endpoints: [
-      {
-        name: 'test',
-        inputParameters: {},
-        transport: new NopTransport(),
-      },
-      {
-        name: 'another',
-        aliases: ['test'],
-        inputParameters: {},
-        transport: new NopTransport(),
-      },
-    ],
-  }
-
-  await t.throwsAsync(async () => expose(adapter), {
-    message: 'Duplicate endpoint / alias: "test"',
-  })
-})