@chainlink/external-adapter-framework 0.0.12 → 0.0.14

package/src/examples/bank-frick/accounts.ts

@@ -1,246 +0,0 @@
-import axios, { AxiosRequestConfig, AxiosResponse } from 'axios'
-import {
-  Account,
-  AdapterInputParameters,
-  BankFrickAccountsRequestSchema,
-  BankFrickAccountsResponseSchema,
-  SigningAlgorithm,
-} from './types'
-import { customSettings } from './config'
-import { Transport } from '../../transports'
-import { generateJWT } from './util'
-import { AdapterRequest, AdapterResponse, makeLogger, sleep } from '../../util'
-import { AdapterConfig } from '../../config'
-import { AdapterError } from '../../validation/error'
-import { Cache } from '../../cache'
-import { InputParameters } from '../../validation'
-import { AdapterDependencies, AdapterEndpoint } from '../../adapter'
-
-const logger = makeLogger('BankFrickTransport')
-
-// Note: this is a shallow pattern that only checks for a country code since IBANs in the sandbox are invalid
-const ibanPattern = /^[A-Z]{2}[A-Z\d]{14,30}$/
-const inputParameters: InputParameters = {
-  ibanIDs: {
-    description: 'The list of account ids included in the sum of balances',
-    required: true,
-    type: 'array',
-  },
-  signingAlgorithm: {
-    description:
-      'What signing algorithm is used to sign and verify authorization data, one of rsa-sha256, rsa-sha384, or rsa-sha512',
-    required: false,
-    type: 'string',
-    default: 'rsa-sha512',
-    options: ['rsa-sha256', 'rsa-sha384', 'rsa-sha512'],
-  },
-}
-
-// See here for all expected error returned by the API: https://developers.bankfrick.li/docs#errors
-const AuthErrors: { [key: number]: string } = {
-  401: 'No JWT token provided or token is invalid',
-  403: 'API key is invalid or any other condition is hindering the login', // Unclear if this is fatal or not
-}
-const FatalErrors: { [key: number]: string } = {
-  400: "Invalid parameters passed to Bank Frick's API",
-  423: "Authorization is valid, but the user's account is locked",
-}
-
-/**
- * RestTransport implementation for Bank Frick, which has unusually complex requirements for an EA
- * The RestTransport is generally built to make a single request and return a single response.
- * This transport instead is used to fetch and process pages of data, and also requires a JWT to run
- *
- * This transport does all the heavy lifting in setup(), which is where the paging happens, and it
- * also has complex retry logic that will attempt to refresh the JWT when certain HTTP errors occur
- */
-export class BankFrickAccountsTransport
-  implements Transport<AdapterInputParameters, number, typeof customSettings>
-{
-  // Global variable to keep the token. Token is provisioned when the accounts endpoint is hit.
-  // Each instance of the EA will have their own token by design
-  token!: string
-  cache!: Cache
-
-  async initialize(dependencies: AdapterDependencies): Promise<void> {
-    this.cache = dependencies.cache
-  }
-
-  async hasBeenSetUp() {
-    return false // Return false since we aren't coalescing requests
-  }
-
-  /**
-   * Creates an AxiosRequestConfig object for fetching a page of accounts from the Bank Frick API
-   */
-  prepareRequest(
-    firstPosition: number,
-    inputParams: AdapterInputParameters,
-    config: AdapterConfig<typeof customSettings>,
-  ): AxiosRequestConfig<BankFrickAccountsRequestSchema> {
-    const { API_ENDPOINT, BASE_URL, PAGE_SIZE } = config
-
-    return {
-      baseURL: API_ENDPOINT + BASE_URL,
-      url: 'accounts',
-      method: 'GET',
-      params: {
-        firstPosition,
-        maxResults: PAGE_SIZE,
-      },
-      headers: {
-        Authorization: `Bearer ${this.token}`,
-      },
-    }
-  }
-
-  /**
-   * Request with retry logic for Bank Frick's API. In addition to standard retry logic, this function
-   * compares errors against expected errors from the Bank Frick API, and will throw without retries
-   * on a known fatal error, or try to refresh the JWT on a known auth error
-   **/
-  async makeRequest(
-    axiosRequest: AxiosRequestConfig<BankFrickAccountsRequestSchema>,
-    config: AdapterConfig<typeof customSettings>,
-    signingAlgorithm?: SigningAlgorithm,
-  ): Promise<AxiosResponse<BankFrickAccountsResponseSchema>> {
-    let retryNumber = 0
-    let response = await axios.request(axiosRequest)
-    while (response.status !== 200) {
-      retryNumber++
-      logger.warn(
-        'Encountered error when fetching accounts from Bank Frick:',
-        response.status,
-        response.statusText,
-      )
-
-      // Evaluate whether the error was fatal, auth, or transient and whether we've exceeded the max number of retries.
-      // Throw on fatal, refresh token on auth error, pass on transient until we've exhausted our retries
-      if (FatalErrors[response.status]) {
-        throw new AdapterError({
-          statusCode: response.status,
-          message: response.statusText,
-        })
-      } else if (AuthErrors[response.status]) {
-        // We've encountered a known auth error, so try to refresh the token before making another request
-        logger.info('Auth error received from the Bank Frick API, attempting to refresh the token')
-        this.token = await generateJWT(config, signingAlgorithm)
-      } else if (retryNumber === config.REST_TRANSPORT_MAX_RATE_LIMIT_RETRIES) {
-        throw new AdapterError({
-          statusCode: 504,
-          message: `Bank Frick transport hit the max number of retries (${config.REST_TRANSPORT_MAX_RATE_LIMIT_RETRIES} retries) and aborted`,
-        })
-      }
-
-      logger.debug(
-        `Sleeping for ${config.REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES}ms before retrying`,
-      )
-      await sleep(config.REST_TRANSPORT_MS_BETWEEN_RATE_LIMIT_RETRIES)
-      response = await axios.request(axiosRequest)
-    }
-    return response
-  }
-
-  validateInputParams(params: AdapterInputParameters): string[] {
-    const encounteredIds: { [key: string]: number } = {}
-    const errors: string[] = []
-    const { ibanIDs } = params
-
-    ibanIDs.forEach((v) => {
-      if (!v.match(ibanPattern)) {
-        errors.push(`Invalid IBAN: ${v}`)
-      }
-      encounteredIds[v] += 1
-      if (encounteredIds[v] > 1) {
-        errors.push(`The following IBAN appears more than once in the input parameters: ${v}`)
-      }
-    })
-    return errors
-  }
-
-  /**
-   * Fetches pages of data from the Bank Frick API, scans for accounts by IBAN, and returns the balance
-   * of all found accounts. Returns a 404 if any IBAN isn't found.
-   */
-  async setup(
-    req: AdapterRequest<AdapterInputParameters>,
-    config: AdapterConfig<typeof customSettings>,
-  ): Promise<AdapterResponse<number>> {
-    const { ibanIDs, signingAlgorithm } = req.requestContext.data
-    const { PAGE_SIZE = 500 } = config
-
-    logger.debug(`Validating input: ${JSON.stringify(req.requestContext.data)}`)
-
-    // Scan ibanIDs for duplicates and invalid IBANs
-    const validationErrors = this.validateInputParams(req.requestContext.data)
-    if (validationErrors.length > 0) {
-      throw new AdapterError({
-        statusCode: 420,
-        message: `Received the following errors when validating inputParameters:\n ${validationErrors.join(
-          '\n',
-        )}`,
-      })
-    }
-
-    // Refresh the token if it isn't set
-    if (!this.token) {
-      this.token = await generateJWT(config, signingAlgorithm)
-    }
-
-    let sum = 0
-    let position = 0
-    const keys = ibanIDs
-    logger.info("Fetching accounts from Bank Frick's API...")
-    while (keys.length > 0) {
-      // TODO Fetching and processing pages can be run concurrently
-      const axiosRequest = this.prepareRequest(position, req.requestContext.data, config)
-      const response = await this.makeRequest(axiosRequest, config, signingAlgorithm)
-
-      logger.debug(`Evaluating accounts from page ${position / PAGE_SIZE}`)
-      response.data.accounts.forEach((v: Account) => {
-        logger.trace(`Evaluating ${v.account} (iban: ${v.iban}, type: ${v.type})`)
-        const index = ibanIDs.indexOf(v.iban)
-        if (index > -1) {
-          keys.splice(index, 1)
-          sum += v.balance
-          logger.trace(`Found account: ${v.account} (iban: ${v.iban}) with balance of ${v.balance}`)
-          logger.trace(
-            `Running sum: ${sum}, number of ibans left to find: ${keys.length}/${ibanIDs.length}`,
-          )
-        }
-      })
-
-      if (!response.data.moreResults) {
-        logger.debug('No more results, breaking out of account query loop')
-        break
-      }
-      position += PAGE_SIZE || 0
-    }
-
-    // 404 if one or more accounts were not found
-    if (keys.length > 0) {
-      logger.error(`Could not find all accounts, returning 404: ${keys.join(', ')}`)
-      const res = {
-        data: 0,
-        statusCode: 404,
-        result: 0,
-      }
-      await this.cache.set(req.requestContext.cacheKey, res, config.CACHE_MAX_AGE)
-    }
-
-    logger.debug('Was able to find all accounts, returning balance across all accounts: ', sum)
-    const res = {
-      data: sum,
-      statusCode: 200,
-      result: sum,
-    }
-    await this.cache.set(req.requestContext.cacheKey, res, config.CACHE_MAX_AGE)
-    return res
-  }
-}
-
-export const accountsRestEndpoint: AdapterEndpoint = {
-  name: 'accounts',
-  transport: new BankFrickAccountsTransport(),
-  inputParameters,
-}

package/src/examples/bank-frick/config/index.ts

@@ -1,53 +0,0 @@
-import { SettingsMap } from '../../../config'
-import crypto from 'crypto'
-import { SigningAlgorithm } from '../types'
-import { makeLogger } from '../../../util'
-
-const logger = makeLogger('BankFrickConfig')
-
-// Used for enum options and validation
-export const signingAlgorithms: SigningAlgorithm[] = ['rsa-sha256', 'rsa-sha384', 'rsa-sha512']
-const MAX_PAGE_SIZE = 500
-
-export const customSettings: SettingsMap = {
-  PAGE_SIZE: {
-    description: 'The number of accounts to fetch per call to /accounts. Must be >= 1 and <= 500.',
-    type: 'number',
-    required: false,
-    default: MAX_PAGE_SIZE,
-    validate: (value) => {
-      if (!value) {
-        return ''
-      } else if (value < 1) {
-        return `PAGE_SIZE must be at least >= 1, was ${value}`
-      } else if (value > MAX_PAGE_SIZE) {
-        return `PAGE_SIZE must be <= 500, was ${value}`
-      }
-    },
-  },
-  PRIVATE_KEY: {
-    description: '',
-    type: 'string',
-    required: true,
-    validate: (value) => {
-      const failedAlgos: SigningAlgorithm[] = []
-      for (const algorithm of signingAlgorithms) {
-        const body = { example: 123 }
-        try {
-          crypto.sign(algorithm, Buffer.from(JSON.stringify(body)), value)
-          logger.trace("Successfully tested PRIVATE_KEY by signing with algorithm '%s'", algorithm)
-        } catch {
-          logger.trace("PRIVATE_KEY failed to sign message with algorithm '%s'", algorithm)
-          failedAlgos.push(algorithm)
-        }
-      }
-
-      if (failedAlgos.length > 0) {
-        return `Failed to sign a dummy body using $PRIVATE_KEY with the following algorithms ${failedAlgos.join(
-          ',',
-        )}`
-      }
-      logger.debug('$PRIVATE_KEY successfully signed a dummy body with all supported algorithms')
-    },
-  },
-} as const

package/src/examples/bank-frick/index.ts

@@ -1,13 +0,0 @@
-import { Adapter } from '../../adapter'
-import { accountsRestEndpoint } from './accounts'
-import { customSettings } from './config'
-
-export const adapter: Adapter = {
-  name: 'bank-frick',
-  defaultEndpoint: 'accounts',
-  endpoints: [accountsRestEndpoint],
-  customSettings,
-  envDefaultOverrides: {
-    API_ENDPOINT: 'https://olbsandbox.bankfrick.li/webapi/v2',
-  },
-}

package/src/examples/bank-frick/types.d.ts

@@ -1,38 +0,0 @@
-export interface Account {
-  account: string // The account number of the account
-  type: string // The type of the account
-  iban: string // The iban of the account if exists
-  customer: string // The customer data of the account which consists of the customer number and name
-  currency: string // The account currency
-  balance: number // The current account balance
-  available: number // The available amount of the account as defined in the online banking
-}
-/**
- * Types representing what we send/receive from the bank frick api
- * See https://developers.bankfrick.li/docs#data-types for details
- */
-export interface BankFrickAccountsResponseSchema {
-  errors?: string[]
-  date: Date
-  moreResults: boolean
-  resultSetSize: number
-  accounts: Account[]
-}
-export interface BankFrickAccountsRequestSchema {
-  firstPosition: number
-  maxResults: number
-}
-
-/**
- * Types representing the input parameters and response of the adapter
- */
-export interface AdapterInputParameters {
-  ibanIDs: string[]
-  signingAlgorithm?: SigningAlgorithm
-}
-
-/**
- * These are the options from the docs, but it's hard to see. See the first paragraph from this
- * page for details:  https://developers.bankfrick.li/docs#getting-started-signatures
- */
-export type SigningAlgorithm = 'dsa-sha512' | 'rsa-sha256' | 'rsa-sha384' | 'rsa-sha512'

package/src/examples/bank-frick/util.ts

@@ -1,55 +0,0 @@
-import crypto from 'crypto'
-import { SigningAlgorithm } from './types'
-import { customSettings } from './config'
-import axios, { AxiosRequestConfig } from 'axios'
-import { makeLogger } from '../../util'
-import { AdapterConfig } from '../../config'
-
-interface TokenResponseBody {
-  errors?: string[]
-  token: string
-}
-interface TokenRequestBody {
-  key: string
-}
-
-const logger = makeLogger('BankFrickUtil')
-
-// Used by all endpoints requiring authentication
-export const generateJWT = async (
-  config: AdapterConfig<typeof customSettings>,
-  signingAlgorithm: SigningAlgorithm = 'rsa-sha512',
-): Promise<string> => {
-  logger.info("Generating a new JWT because we don't have one in config.token")
-  const { API_KEY, PRIVATE_KEY, API_ENDPOINT } = config
-
-  // All of these are required, so validation should have failed prior to this line
-  if (!API_KEY || !PRIVATE_KEY) {
-    throw new Error(
-      'API_KEY, PRIVATE_KEY, and PASSWORD all must be defined to get a new token\n' +
-        'Received:  \n' +
-        `API_KEY: ${API_KEY}\n` +
-        `PRIVATE_KEY: ${PRIVATE_KEY}`,
-    )
-  }
-
-  const data: TokenRequestBody = {
-    key: API_KEY,
-  }
-
-  const signature = crypto.sign(signingAlgorithm, Buffer.from(JSON.stringify(data)), PRIVATE_KEY)
-  const options: AxiosRequestConfig<TokenRequestBody> = {
-    method: 'POST',
-    baseURL: API_ENDPOINT,
-    url: `authorize`,
-    headers: {
-      Signature: signature.toString('base64'),
-      algorithm: signingAlgorithm,
-    },
-    data,
-  }
-
-  const response = await axios.request<TokenResponseBody>(options)
-
-  return response.data.token
-}

package/src/examples/coingecko/batch-warming.ts

@@ -1,78 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios'
-import { AdapterContext, AdapterEndpoint } from '../../adapter'
-import { BatchWarmingTransport } from '../../transports/batch-warming'
-import { ProviderResult } from '../../util'
-import { InputParameters } from '../../validation'
-
-const DEFAULT_URL = 'https://pro-api.coingecko.com/api/v3'
-
-interface AdapterRequestParams {
-  base: string
-  quote: string
-}
-
-const inputParameters: InputParameters = {
-  coinid: {
-    description:
-      'The CoinGecko id or array of ids of the coin(s) to query (Note: because of current limitations to use a dummy base will need to be supplied)',
-    required: false,
-  },
-  base: {
-    aliases: ['from', 'coin'],
-    description: 'The symbol or array of symbols of the currency to query',
-    required: true,
-  },
-  quote: {
-    aliases: ['to', 'market'],
-    description: 'The symbol of the currency to convert to',
-    required: true,
-  },
-}
-interface ProviderRequestBody {
-  ids: string
-  vs_currencies: string
-}
-
-interface ProviderResponseBody {
-  [base: string]: {
-    [quote: string]: number
-  }
-}
-
-const batchEndpointTransport = new BatchWarmingTransport({
-  prepareRequest: (
-    params: AdapterRequestParams[],
-    context: AdapterContext,
-  ): AxiosRequestConfig<ProviderRequestBody> => {
-    return {
-      baseURL: DEFAULT_URL,
-      url: '/simple/price',
-      method: 'GET',
-      params: {
-        ids: [...new Set(params.map((p) => p.base))].join(','),
-        vs_currencies: [...new Set(params.map((p) => p.quote))].join(','),
-        x_cg_pro_api_key: context.adapterConfig.API_KEY,
-      },
-    }
-  },
-  parseResponse: (
-    res: AxiosResponse<ProviderResponseBody>,
-  ): ProviderResult<AdapterRequestParams>[] => {
-    const entries = [] as ProviderResult<AdapterRequestParams>[]
-    for (const [base, entry] of Object.entries(res.data)) {
-      for (const [quote, price] of Object.entries(entry)) {
-        entries.push({
-          params: { base, quote },
-          value: price,
-        })
-      }
-    }
-    return entries
-  },
-})
-
-export const batchEndpoint: AdapterEndpoint = {
-  name: 'batch',
-  transport: batchEndpointTransport,
-  inputParameters,
-}

package/src/examples/coingecko/index.ts

@@ -1,9 +0,0 @@
-import { Adapter } from '../../adapter'
-import { batchEndpoint } from './batch-warming'
-import { restEndpoint } from './rest'
-
-export const adapter: Adapter = {
-  name: 'coingecko',
-  defaultEndpoint: 'batch',
-  endpoints: [restEndpoint, batchEndpoint],
-}

package/src/examples/coingecko/rest.ts

@@ -1,77 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios'
-import { AdapterEndpoint } from '../../adapter'
-import { RestTransport } from '../../transports'
-import { AdapterRequest, AdapterResponse } from '../../util'
-import { InputParameters } from '../../validation'
-
-const DEFAULT_URL = 'https://api.coingecko.com/api/v3'
-
-interface AdapterRequestParams {
-  base: string
-  quote: string
-}
-
-const inputParameters: InputParameters = {
-  coinid: {
-    description:
-      'The CoinGecko id or array of ids of the coin(s) to query (Note: because of current limitations to use a dummy base will need to be supplied)',
-    required: false,
-  },
-  base: {
-    aliases: ['from', 'coin'],
-    description: 'The symbol or array of symbols of the currency to query',
-    required: true,
-  },
-  quote: {
-    aliases: ['to', 'market'],
-    description: 'The symbol of the currency to convert to',
-    required: true,
-  },
-}
-
-interface ProviderRequestBody {
-  ids: string
-  vs_currencies: string
-}
-
-interface ProviderResponseBody {
-  [base: string]: {
-    [quote: string]: number
-  }
-}
-
-const restEndpointTransport = new RestTransport({
-  prepareRequest: (
-    req: AdapterRequest<AdapterRequestParams>,
-  ): AxiosRequestConfig<ProviderRequestBody> => {
-    return {
-      baseURL: DEFAULT_URL,
-      url: '/simple/price',
-      method: 'GET',
-      params: {
-        ids: req.requestContext.data.base,
-        vs_currencies: req.requestContext.data.quote,
-      },
-    }
-  },
-  parseResponse: (
-    req: AdapterRequest<AdapterRequestParams>,
-    res: AxiosResponse<ProviderResponseBody>,
-  ): AdapterResponse<ProviderResponseBody> => {
-    return {
-      data: res.data,
-      statusCode: 200,
-      result: res.data[req.requestContext.data.base]?.[req.requestContext.data.quote],
-    }
-  },
-  options: {
-    coalescing: true,
-  },
-})
-
-export const restEndpoint: AdapterEndpoint = {
-  name: 'rest',
-  aliases: ['qwe'],
-  transport: restEndpointTransport,
-  inputParameters,
-}

package/src/examples/ncfx/config/index.ts

@@ -1,12 +0,0 @@
-export const customSettings = {
-  USERNAME: {
-    description: 'Username for the NCFX API',
-    type: 'string',
-    required: true,
-  },
-  PASSWORD: {
-    description: 'Password for the NCFX API',
-    type: 'string',
-    required: true,
-  },
-} as const

package/src/examples/ncfx/index.ts

@@ -1,9 +0,0 @@
-import { Adapter } from '../../adapter'
-import { customSettings } from './config'
-import { webSocketEndpoint } from './websocket'
-
-export const adapter: Adapter = {
-  name: 'ncfx',
-  endpoints: [webSocketEndpoint],
-  customSettings,
-}

package/src/examples/ncfx/websocket.ts

@@ -1,99 +0,0 @@
-import { RawData, WebSocket } from 'ws'
-import { AdapterContext, AdapterEndpoint } from '../../adapter'
-import { WebSocketTransport } from '../../transports/websocket'
-import { ProviderResult, makeLogger } from '../../util'
-import { InputParameters } from '../../validation'
-import { customSettings } from './config'
-
-interface AdapterRequestParams {
-  base: string
-  quote: string
-}
-
-export const inputParameters: InputParameters = {
-  base: {
-    aliases: ['from', 'coin'],
-    description: 'The symbol of the currency to query',
-    required: true,
-  },
-  quote: {
-    aliases: ['to', 'market'],
-    description: 'The symbol of the currency to convert to',
-    required: true,
-  },
-}
-
-interface ProviderMessage {
-  timestamp: string
-  currencyPair: string
-  bid: number
-  offer: number
-  mid: number
-  changes: [
-    {
-      period: string
-      change: number
-      percentage: number
-    },
-  ]
-}
-
-const logger = makeLogger('NcfxWebSocketTransport')
-
-export const websocketTransport = new WebSocketTransport({
-  url: 'wss://feed.newchangefx.com/cryptodata',
-  handlers: {
-    open(connection: WebSocket, context: AdapterContext<typeof customSettings>) {
-      return new Promise((resolve, reject) => {
-        // Set up listener
-        connection.on('message', (data: RawData) => {
-          const parsed = JSON.parse(data.toString())
-          if (parsed.Message?.startsWith('Logged in as user')) {
-            logger.info('Got logged in response, connection is ready')
-            resolve()
-          } else {
-            reject(new Error('Unexpected message after WS connection open'))
-          }
-        })
-        // Send login payload
-        connection.send(
-          JSON.stringify({
-            request: 'login',
-            username: context.adapterConfig.USERNAME,
-            password: context.adapterConfig.PASSWORD,
-          }),
-        )
-      })
-    },
-
-    message(message: ProviderMessage[]): ProviderResult<AdapterRequestParams>[] {
-      if (!Array.isArray(message)) {
-        logger.debug('WS message is not array, skipping')
-        return []
-      }
-      return message.map((m) => {
-        const [base, quote] = m.currencyPair.split('/')
-        return {
-          params: { base, quote },
-          value: m.offer,
-        }
-      })
-    },
-  },
-  builders: {
-    subscribeMessage: (params: AdapterRequestParams) => ({
-      request: 'subscribe',
-      ccy: `${params.base}/${params.quote}`,
-    }),
-    unsubscribeMessage: (params: AdapterRequestParams) => ({
-      request: 'unsubscribe',
-      ccy: `${params.base}/${params.quote}`,
-    }),
-  },
-})
-
-export const webSocketEndpoint: AdapterEndpoint = {
-  name: 'websocket',
-  transport: websocketTransport,
-  inputParameters,
-}