@chainlink/external-adapter-framework 0.0.10 → 0.0.12

package/.c8rc.json

@@ -0,0 +1,3 @@
+{
+  "reporter": ["lcov", "text"]
+}

package/.eslintignore

@@ -0,0 +1,9 @@
+# don't ever lint node_modules
+node_modules
+# don't lint build output (make sure it's set to your correct build folder name)
+dist
+# don't lint coverage output
+coverage
+
+.yarn
+.vscode

package/.eslintrc.js

@@ -0,0 +1,96 @@
+// https://github.com/typescript-eslint/typescript-eslint/blob/master/docs/getting-started/linting/README.md
+module.exports = {
+  root: true,
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint', 'eslint-plugin-tsdoc'],
+  extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended', 'prettier'],
+  rules: {
+    'tsdoc/syntax': 'warn',
+
+    // Problems
+    'array-callback-return': [
+      'error',
+      {
+        allowImplicit: false,
+        checkForEach: true,
+      },
+    ],
+    'no-constant-binary-expression': 'error',
+    'no-constructor-return': 'error',
+    'no-duplicate-imports': 'error',
+    'no-promise-executor-return': 'error',
+    'no-self-compare': 'error',
+    'no-template-curly-in-string': 'error',
+    'no-unmodified-loop-condition': 'error',
+    'no-unreachable-loop': 'error',
+    'no-unused-private-class-members': 'error',
+    'require-atomic-updates': 'error',
+
+    // Suggestions
+    'capitalized-comments': ['error', 'always', { ignoreConsecutiveComments: true }],
+    complexity: ['error', 25], // TODO: Should be lower (15?), but validator has complex methods
+    curly: 'error',
+    'default-case-last': 'error',
+    'default-param-last': 'error',
+    eqeqeq: ['error', 'smart'],
+    'func-names': 'error',
+    'func-style': ['error', 'declaration', { allowArrowFunctions: true }],
+    'grouped-accessor-pairs': ['error', 'getBeforeSet'],
+    'max-depth': ['error', 4], // TODO: Should be lower (3), but validator has complex methods
+    'max-nested-callbacks': ['error', 2],
+    'max-params': ['error', 4], // TODO: Should be lower (3), but validator has complex methods,
+    'new-cap': ['error', { newIsCapExceptions: ['ctor'] }],
+    'no-caller': 'error',
+    'no-confusing-arrow': [
+      'error',
+      {
+        allowParens: true,
+      },
+    ],
+    'no-console': ['warn'], // We want this to debug, but the check workflow should accept no warns
+    'no-div-regex': 'error',
+    'no-eval': 'error',
+    'no-extend-native': 'error',
+    'no-extra-bind': 'error',
+    'no-extra-label': 'error',
+    'no-extra-semi': 'error',
+    'no-floating-decimal': 'error',
+    'no-implied-eval': 'error',
+    'no-invalid-this': 'error',
+    'no-labels': 'error',
+    'no-lonely-if': 'error',
+    'no-multi-assign': 'error',
+    'no-multi-str': 'error',
+    'no-nested-ternary': 'error',
+    'no-new': 'error',
+    'no-new-func': 'error',
+    'no-new-object': 'error',
+    'no-new-wrappers': 'error',
+    'no-param-reassign': 'error',
+    'no-proto': 'error',
+    'no-return-assign': 'error',
+    'no-return-await': 'error',
+    'no-sequences': 'error',
+    'no-shadow': 'off',
+    '@typescript-eslint/no-shadow': 'error', // https://stackoverflow.com/questions/63961803/eslint-says-all-enums-in-typescript-app-are-already-declared-in-the-upper-scope
+    'no-unneeded-ternary': 'error',
+    'no-useless-call': 'error',
+    'no-useless-computed-key': 'error',
+    'no-useless-concat': 'error',
+    'no-useless-rename': 'error',
+    'no-var': 'error',
+    'operator-assignment': ['error', 'always'],
+    'prefer-arrow-callback': 'error',
+    'prefer-const': 'error',
+    'prefer-exponentiation-operator': 'error',
+    'prefer-object-spread': 'error',
+    'prefer-promise-reject-errors': 'error',
+    'prefer-regex-literals': 'error',
+    'prefer-rest-params': 'error',
+    'prefer-spread': 'error',
+    'prefer-template': 'error',
+    'spaced-comment': ['error', 'always'],
+    'symbol-description': 'error',
+    yoda: 'error',
+  },
+}

package/.github/README.MD

@@ -0,0 +1,17 @@
+# Github workflows for EAv3 Framework
+
+**Please note that this work is in progress. The README may not be accurate**
+
+## Overview
+This directory contains a basic GitHub workflow that builds, tests, and ultimately publishes the EAv3 Framework to NPM
+1. Setup (caches dependencies to speed up other steps)
+2. Build/Prepare/Preflight (all the following happen at the same time)
+   1. yarn build => publish artifact of build
+   2. yarn lint
+   3. yarn test
+3. Publish (currently unimplemented)
+
+### Some steps that still need to be added in:
+1. Check that changelog has an entry matching the current version in package.json
+2. Check if a package is already published to NPM, and DON'T overwrite it unless a parameter explicitly allowing an overwrite has been passed
+3. npm-check step that produces a report as an artifact

package/.github/actions/setup/action.yaml

@@ -0,0 +1,13 @@
+name: 'Setup'
+description: 'Sets up the project, installs dependencies, and builds'
+runs:
+  using: 'composite'
+  steps:
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 16.x
+        registry-url: https://registry.npmjs.org
+        always-auth: true
+        cache: yarn
+    - run: yarn install --frozen-lockfile
+      shell: bash

package/.github/workflows/main.yaml

@@ -0,0 +1,39 @@
+# This is the entry point for CI. It will setup the application, then run lint, test, and eventually publish if not the master or main branch
+name: 'Main'
+on:
+  push:
+    branches:
+      - master
+  pull_request: ~
+
+jobs:
+  setup: # Load the dependencies cache for all jobs
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ./.github/actions/setup
+  build:
+    needs: setup
+    runs-on: ubuntu-latest
+    concurrency: build-${{ github.ref}}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ./.github/actions/setup
+      - run: yarn build
+  lint:
+    needs: setup
+    runs-on: ubuntu-latest
+    concurrency: lint-${{ github.ref }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ./.github/actions/setup
+      - run: yarn lint
+      - run: yarn prettier --check **/*.{ts,md}
+  test:
+    needs: setup
+    concurrency: test-${{ github.ref }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ./.github/actions/setup
+      - run: yarn test

package/.github/workflows/publish.yaml

@@ -0,0 +1,20 @@
+# This is the entry point for CI. It will setup the application, then run lint, test, and eventually publish if not the master or main branch
+name: 'Publish'
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+jobs:
+  publish: # Load the dependencies cache for all jobs
+    runs-on: ubuntu-latest
+    environment: main
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ./.github/actions/setup
+      - run: yarn build
+      - run: cp package.json dist/src/
+      - run: npm publish --access restricted #scoped packages are restricted by default, but this is set because not all branches currently have a scoped package name
+        working-directory: dist/src
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.prettierignore

@@ -0,0 +1,13 @@
+# don't ever lint node_modules
+node_modules
+# don't lint build output (make sure it's set to your correct build folder name)
+dist
+# don't lint nyc coverage output
+coverage
+test-payload.json
+.yarn
+.vscode
+.pnp.cjs
+.pnp.loader.mjs
+
+packages/k6/k8s/templates

package/README.md

@@ -0,0 +1,103 @@
+# EA Framework v3
+
+External adapters and its core framework serve as middleware to facilitate connections between Chainlink Nodes and Data Providers (DP). Their main purpose is threefold:
+
+- Abstract provider specific details, specifically:
+  - Transport (REST, WebSockets, RPC, SSE, etc.)
+  - Authentication (login flows, keys)
+  - Accept normalized request payloads and translate into the provider's interface (this also includes things like symbols/tickers)
+  - Parse provider responses into the desired data points (e.g. price from crypto endpoint)
+- Make the overall system more efficient by using as few resources (e.g. API credits, networking traffic, CPU usage) as possible to fetch data, achieved by features like:
+  - Caching: since DPs update data at various times and a request to their API incurs a certain latency, EAs keep a cache of values to
+    - Provide responses to the Chainlink Nodes as quickly as possible
+    - Communicate with DPs only when necessary
+  - Cache Warming: in order to make as many of the requests to EAs be fulfilled from the cache, EAs fetch values from DPs asynchronously to keep the local ones fresh.
+  - Batching: the CL Node requests feeds individually, but it's common for DPs to provide batch endpoints to get many data points at once. With Batching, EAs keep track of incoming requests and consolidate them into one batched request.
+  - Rate limiting: the EA framework additionally checks request rates (frequency) to make sure they fall within acceptable limits (like quotas for the DP's API, or adjusting based on the NOP's API tier).
+- Perform off chain computations (think aggregations, indexing, or any sort of data processing)
+
+By providing a framework that gives users easy access to those features, we reduce the complexity required for Nodes to communicate with DPs since by using EAs there is only one standardized way to do so, while at the same time optimizing said communication so it's as resource efficient as possible. It also makes internal and external development easier and faster, by serving as a strict guideline to implement and add new providers.
+
+## Qs
+
+- Store entire response in cache?
+- Check for valid result in adapter response?
+
+## Env vars
+
+These are all existing env vars, marked DONE if they have been ported to this version, or N/A if the new version disregards them altogether.
+
+| Name                                       | State | Comments                                                     |
+| :----------------------------------------- | :---: | :----------------------------------------------------------- |
+| API_TIMEOUT                                |  N/A  | Only used for WS with handler.noHTtp = true                  |
+| BASE_URL                                   |   √   |                                                              |
+| CACHE_ENABLED                              |  N/A  | Cache is integral to this fw, not including this for now     |
+| CACHE_KEY_IGNORED_PROPS                    |  ??   | Do we want this to be available in v3. Used for feed id      |
+| CACHE_KEY_GROUP                            |  ??   | Dunno if this applies to this fw                             |
+| CACHE_MAX_AGE                              |   √   |                                                              |
+| CACHE_MAX_ITEMS                            |   -   | Should add when replacing obj in local impl with LRU package |
+| CACHE_MIN_AGE                              |   -   | Used for rate limiting                                       |
+| CACHE_REDIS_CONNECTION_TIMEOUT             |   -   | TODO: Redis                                                  |
+| CACHE_REDIS_HOST                           |   -   | TODO: Redis                                                  |
+| CACHE_REDIS_MAX_QUEUED_ITEMS               |   -   | TODO: Redis                                                  |
+| CACHE_REDIS_MAX_RECONNECT_COOLDOWN         |   -   | TODO: Redis                                                  |
+| CACHE_REDIS_PASSWORD                       |   -   | TODO: Redis                                                  |
+| CACHE_REDIS_PATH                           |   -   | TODO: Redis                                                  |
+| CACHE_REDIS_PORT                           |   -   | TODO: Redis                                                  |
+| CACHE_REDIS_TIMEOUT                        |   -   | TODO: Redis                                                  |
+| CACHE_REDIS_URL                            |   -   | TODO: Redis                                                  |
+| CACHE_TYPE                                 |   -   | TODO: Cache factory                                          |
+| CACHE_UPDATE_AGE_ON_GET                    |  N/A  | No longer used in EA currently, apparently                   |
+| DEBUG                                      |       |                                                              |
+| DEFAULT_WS_HEARTBEAT_INTERVAL              |       |                                                              |
+| EA_HOST                                    |       |                                                              |
+| EA_PORT                                    |   √   |                                                              |
+| ENV_ADAPTER_URL                            |       |                                                              |
+| ENV_API_ENDPOINT                           |       |                                                              |
+| ENV_API_KEY                                |       |                                                              |
+| ENV_API_TIMEOUT                            |       |                                                              |
+| ENV_API_VERBOSE                            |       |                                                              |
+| ENV_WS_API_ENDPOINT                        |       |                                                              |
+| ENV_WS_API_KEY                             |       |                                                              |
+| ERROR_CAPACITY                             |       |                                                              |
+| EXPERIMENTAL_METRICS_ENABLED               |   √   | Maintaining for backwards compatibility. Defaults to true    |
+| LEGACY_ENV_ADAPTER_URL                     |       |                                                              |
+| LOG_LEVEL                                  |       |                                                              |
+| METRICS_ENABLED                            |   √   | Defaults to true                                             |
+| METRICS_NAME                               |   √   |                                                              |
+| METRICS_PORT                               |   √   |                                                              |
+| METRICS_USE_BASE_URL                       |   √   |                                                              |
+| NODE_ENV                                   |       |                                                              |
+| npm_package_version                        |       |                                                              |
+| RATE_LIMIT_API_TIER                        |       |                                                              |
+| RATE_LIMIT_CAPACITY                        |       |                                                              |
+| RATE_LIMIT_CAPACITY_MINUTE                 |       |                                                              |
+| RATE_LIMIT_CAPACITY_SECOND                 |       |                                                              |
+| RATE_LIMIT_ENABLED                         |       |                                                              |
+| RECORD                                     |       |                                                              |
+| REQUEST_COALESCING_ENABLED                 |       |                                                              |
+| REQUEST_COALESCING_ENTROPY_MAX             |       |                                                              |
+| REQUEST_COALESCING_INTERVAL                |       |                                                              |
+| REQUEST_COALESCING_INTERVAL_COEFFICIENT    |       |                                                              |
+| REQUEST_COALESCING_INTERVAL_MAX            |       |                                                              |
+| REQUEST_COALESCING_MAX_RETRIES             |       |                                                              |
+| RETRY                                      |       |                                                              |
+| SERVER_RATE_LIMIT_MAX                      |       |                                                              |
+| SERVER_SLOW_DOWN_AFTER_FACTOR              |       |                                                              |
+| SERVER_SLOW_DOWN_DELAY_MS                  |       |                                                              |
+| TIMEOUT                                    |       |                                                              |
+| WARMUP_ENABLED                             |       |                                                              |
+| WARMUP_INTERVAL                            |       |                                                              |
+| WARMUP_SUBSCRIPTION_TTL                    |       |                                                              |
+| WARMUP_UNHEALTHY_THRESHOLD                 |       |                                                              |
+| WS_CONNECTION_KEY                          |       |                                                              |
+| WS_CONNECTION_LIMIT                        |       |                                                              |
+| WS_CONNECTION_RETRY_DELAY                  |       |                                                              |
+| WS_CONNECTION_RETRY_LIMIT                  |       |                                                              |
+| WS_CONNECTION_TTL                          |       |                                                              |
+| WS_ENABLED                                 |  N/A  | Shouldn't be part of this fw                                 |
+| WS_SUBSCRIPTION_LIMIT                      |       |                                                              |
+| WS_SUBSCRIPTION_PRIORITY_LIST              |       |                                                              |
+| WS_SUBSCRIPTION_TTL                        |       |                                                              |
+| WS_SUBSCRIPTION_UNRESPONSIVE_TTL           |       |                                                              |
+| WS_TIME_UNTIL_HANDLE_NEXT_MESSAGE_OVERRIDE |       |                                                              |

package/dist/src/adapter.d.ts

@@ -0,0 +1,135 @@
+import { Cache } from './cache';
+import { AdapterConfig, BaseAdapterConfig, CustomSettingsType, SettingsMap } from './config';
+import { AdapterRateLimitTier, BackgroundExecuteRateLimiter, RequestRateLimiter } from './rate-limiting';
+import { Transport } from './transports';
+import { SubscriptionSetFactory } from './util';
+import { InputParameters } from './validation/input-params';
+/**
+ * Dependencies that will be injected into the Adapter on startup
+ */
+export interface AdapterDependencies {
+    cache: Cache;
+    requestRateLimiter: RequestRateLimiter;
+    backgroundExecuteRateLimiter: BackgroundExecuteRateLimiter;
+    subscriptionSetFactory: SubscriptionSetFactory;
+}
+/**
+ * Context that will be used on background executions of a Transport.
+ * For example, the endpointName used to log statements or generate Cache keys.
+ */
+export interface AdapterContext<CustomSettings extends CustomSettingsType<CustomSettings> = SettingsMap> {
+    adapterEndpoint: AdapterEndpoint<unknown, unknown, CustomSettings>;
+    adapterConfig: AdapterConfig<CustomSettings>;
+}
+/**
+ * Structure to describe rate limits specs for the Adapter
+ */
+interface AdapterRateLimitingConfig {
+    /** Adapter rate limits, gotten from the specific tier requested */
+    tiers: Record<string, AdapterRateLimitTier>;
+}
+/**
+ * Main structure of an External Adapter
+ */
+export interface AdapterParams<CustomSettings extends SettingsMap> {
+    /** Name of the adapter */
+    name: string;
+    /** If present, the string that will be used for requests with no specified endpoint */
+    defaultEndpoint?: string;
+    /**
+     * List of [[AdapterEndpoint]]s in the adapter. This is purposefully typed any; it's the correct type in this case.
+     *
+     * When you try to create an adapter and you provide an endpoint, if these generics were set to "unknown" instead
+     * what would happen is that Typescript would check if the types match, and would fail to assign unknown to the
+     * specific Params or Result in the transport itself.
+     * We also can't use generics, because if we had more than one transport with different requests (very likely)
+     * then those new types wouldn't match with each other.
+     */
+    endpoints: AdapterEndpoint<any, any, CustomSettings>[];
+    /** Map of overrides to the default config values for an Adapter */
+    envDefaultOverrides?: Partial<BaseAdapterConfig>;
+    /** List of custom env vars for this particular adapter (e.g. RPC_URL) */
+    customSettings?: SettingsMap;
+    /** Configuration relevant to outbound (EA --\> DP) communication rate limiting */
+    rateLimiting?: AdapterRateLimitingConfig;
+    /** Overrides for converting the 'base' parameter that are hardcoded into the adapter. */
+    overrides?: Record<string, string>;
+}
+/**
+ * Structure to describe rate limits specs for a specific adapter endpoint
+ */
+export interface EndpointRateLimitingConfig {
+    /**
+     * How much of the total limit for the adapter will be assigned to this specific endpoint.
+     * Should be a non-zero positive number up to 100.
+     * Endpoints in the same adapter without a specific allocation will divide the remaining limits equally.
+     */
+    allocationPercentage: number;
+}
+/**
+ * Structure to describe a specific endpoint in an [[Adapter]]
+ */
+export interface AdapterEndpointParams<Params, Result, CustomSettings extends SettingsMap> {
+    /** Name that will be used to match input params to this endpoint (case insensitive) */
+    name: string;
+    /** List of alternative endpoint names that will resolve to this same transport (case insensitive) */
+    aliases?: string[];
+    /** Transport that will be used to handle data processing and communication for this endpoint */
+    transport: Transport<Params, Result, CustomSettings>;
+    /** Specification of what the body of a request hitting this endpoint should look like (used for validation) */
+    inputParameters: InputParameters;
+    /** Specific details related to the rate limiting for this endpoint in particular */
+    rateLimiting?: EndpointRateLimitingConfig;
+}
+export declare class AdapterEndpoint<Params, Result, CustomSettings extends SettingsMap> implements AdapterEndpointParams<Params, Result, CustomSettings> {
+    name: string;
+    aliases?: string[] | undefined;
+    transport: Transport<Params, Result, CustomSettings>;
+    inputParameters: InputParameters;
+    rateLimiting?: EndpointRateLimitingConfig | undefined;
+    constructor(params: AdapterEndpointParams<Params, Result, CustomSettings>);
+}
+export declare class Adapter<CustomSettings extends SettingsMap = SettingsMap> implements AdapterParams<CustomSettings> {
+    name: string;
+    defaultEndpoint?: string | undefined;
+    endpoints: AdapterEndpoint<unknown, unknown, CustomSettings>[];
+    envDefaultOverrides?: Partial<BaseAdapterConfig> | undefined;
+    customSettings?: SettingsMap | undefined;
+    rateLimiting?: AdapterRateLimitingConfig | undefined;
+    overrides?: Record<string, string> | undefined;
+    initialized: boolean;
+    /** Object containing alias translations for all endpoints */
+    endpointsMap: Record<string, AdapterEndpoint<unknown, unknown, CustomSettings>>;
+    /** Initialized dependencies that the adapter will use */
+    dependencies: AdapterDependencies;
+    /** Configuration params for various adapter properties */
+    config: AdapterConfig;
+    constructor(params: AdapterParams<CustomSettings>);
+    /**
+     * Initializes all of the [[Transport]]s in the adapter, passing along any [[AdapterDependencies]] and [[AdapterConfig]].
+     * Additionally, it builds a map out of all the endpoint names and aliases (checking for duplicates).
+     */
+    initialize(dependencies?: Partial<AdapterDependencies>): Promise<void>;
+    /**
+     * Takes an adapter and normalizes all endpoint names and aliases, as well as the default endpoint.
+     * i.e. makes them lowercase for now
+     * @param adapter - an instance of an Adapter
+     */
+    private normalizeEndpointNames;
+    /**
+     * This function will take an adapter structure and go through each endpoint, calculating
+     * each one's allocation of the total rate limits that are set for the adapter as a whole.
+     *
+     * @param adapter - the adapter to initialize rate limiting for
+     */
+    private calculateRateLimitAllocations;
+    /**
+     * This function will process dependencies for an adapter, such as caches or rate limiters,
+     * in order to inject them into transports and other relevant places later in the lifecycle.
+     *
+     * @param inputDependencies - a partial obj of initialized dependencies to override the created ones
+     * @returns a set of AdapterDependencies all initialized
+     */
+    initializeDependencies(inputDependencies?: Partial<AdapterDependencies>): AdapterDependencies;
+}
+export {};

package/dist/src/adapter.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Adapter = exports.AdapterEndpoint = void 0;
+const cache_1 = require("./cache");
+const config_1 = require("./config");
+const rate_limiting_1 = require("./rate-limiting");
+const util_1 = require("./util");
+const logger = (0, util_1.makeLogger)('Adapter');
+class AdapterEndpoint {
+    constructor(params) {
+        this.name = params.name;
+        this.aliases = params.aliases;
+        this.transport = params.transport;
+        this.inputParameters = params.inputParameters;
+        this.rateLimiting = params.rateLimiting;
+    }
+}
+exports.AdapterEndpoint = AdapterEndpoint;
+// /**
+//  * Structure to describe an adapter that has been initialized
+//  */
+// export interface InitializedAdapter<Params, Result, CustomSettings extends SettingsMap>
+//   extends AdapterParams<Params, Result, CustomSettings> {
+//   /** Object containing alias translations for all endpoints */
+//   endpointsMap: Record<string, AdapterEndpoint<Params, Result, CustomSettings>>
+//   /** Initialized dependencies that the adapter will use */
+//   dependencies: AdapterDependencies
+//   /** Configuration params for various adapter properties */
+//   config: AdapterConfig
+// }
+class Adapter {
+    constructor(params) {
+        // After initialization
+        this.initialized = false;
+        /** Object containing alias translations for all endpoints */
+        this.endpointsMap = {};
+        // Copy over params
+        this.name = params.name;
+        this.defaultEndpoint = params.defaultEndpoint?.toLowerCase();
+        this.endpoints = params.endpoints;
+        this.envDefaultOverrides = params.envDefaultOverrides;
+        this.customSettings = params.customSettings;
+        this.rateLimiting = params.rateLimiting;
+        this.overrides = params.overrides;
+        this.config = (0, config_1.buildAdapterConfig)({
+            overrides: this.envDefaultOverrides,
+            customSettings: this.customSettings,
+        });
+        this.normalizeEndpointNames();
+        this.calculateRateLimitAllocations();
+    }
+    /**
+     * Initializes all of the [[Transport]]s in the adapter, passing along any [[AdapterDependencies]] and [[AdapterConfig]].
+     * Additionally, it builds a map out of all the endpoint names and aliases (checking for duplicates).
+     */
+    async initialize(dependencies) {
+        if (this.initialized) {
+            throw new Error('This adapter has already been initialized!');
+        }
+        this.dependencies = this.initializeDependencies(dependencies);
+        for (const endpoint of this.endpoints) {
+            // Add aliases to map to use in validation
+            const aliases = [endpoint.name, ...(endpoint.aliases || [])];
+            for (const alias of aliases) {
+                if (this.endpointsMap[alias]) {
+                    throw new Error(`Duplicate endpoint / alias: "${alias}"`);
+                }
+                this.endpointsMap[alias] = endpoint;
+            }
+            logger.debug(`Initializing transport for endpoint "${endpoint.name}"...`);
+            await endpoint.transport.initialize(this.dependencies);
+        }
+        logger.debug('Adapter initialization complete.');
+        this.initialized = true;
+    }
+    /**
+     * Takes an adapter and normalizes all endpoint names and aliases, as well as the default endpoint.
+     * i.e. makes them lowercase for now
+     * @param adapter - an instance of an Adapter
+     */
+    normalizeEndpointNames() {
+        for (const endpoint of this.endpoints) {
+            endpoint.name = endpoint.name.toLowerCase();
+            endpoint.aliases = endpoint.aliases?.map((a) => a.toLowerCase());
+        }
+    }
+    /**
+     * This function will take an adapter structure and go through each endpoint, calculating
+     * each one's allocation of the total rate limits that are set for the adapter as a whole.
+     *
+     * @param adapter - the adapter to initialize rate limiting for
+     */
+    calculateRateLimitAllocations() {
+        const numberOfEndpoints = this.endpoints.length;
+        const endpointsWithExplicitAllocations = this.endpoints.filter((e) => e.rateLimiting);
+        const totalExplicitAllocation = endpointsWithExplicitAllocations
+            .map((e) => e.rateLimiting?.allocationPercentage || 0)
+            .reduce((sum, next) => sum + next, 0);
+        if (totalExplicitAllocation > 100) {
+            throw new Error('The total allocation set for all endpoints summed cannot exceed 100%');
+        }
+        if (totalExplicitAllocation === 100 &&
+            numberOfEndpoints - endpointsWithExplicitAllocations.length > 0) {
+            throw new Error('The explicit allocation is at 100% but there are endpoints with implicit allocation');
+        }
+        const implicitAllocation = 100 - totalExplicitAllocation;
+        logger.debug('Adapter rate limit allocations:');
+        for (const endpoint of this.endpoints) {
+            if (!endpoint.rateLimiting) {
+                endpoint.rateLimiting = {
+                    allocationPercentage: implicitAllocation / (numberOfEndpoints - endpointsWithExplicitAllocations.length),
+                };
+            }
+            logger.debug(`Endpoint [${endpoint.name}] - ${endpoint.rateLimiting?.allocationPercentage}%`);
+        }
+    }
+    /**
+     * This function will process dependencies for an adapter, such as caches or rate limiters,
+     * in order to inject them into transports and other relevant places later in the lifecycle.
+     *
+     * @param inputDependencies - a partial obj of initialized dependencies to override the created ones
+     * @returns a set of AdapterDependencies all initialized
+     */
+    initializeDependencies(inputDependencies) {
+        const dependencies = inputDependencies || {};
+        if (!dependencies.cache) {
+            dependencies.cache = cache_1.CacheFactory.buildCache(this.config);
+        }
+        // In the future we might want something more complex, but for now it's better to simplify
+        // and just use the same rate limiting for everything. Once we have a more complex use case we
+        // can think of ways to make this more configurable.
+        const rateLimitingTier = (0, rate_limiting_1.getRateLimitingTier)(this.rateLimiting?.tiers, this.config.RATE_LIMIT_API_TIER);
+        if (!dependencies.requestRateLimiter) {
+            dependencies.requestRateLimiter = new rate_limiting_1.SimpleCountingRateLimiter().initialize(this.endpoints, rateLimitingTier);
+        }
+        if (!dependencies.backgroundExecuteRateLimiter) {
+            dependencies.backgroundExecuteRateLimiter = new rate_limiting_1.FixedFrequencyRateLimiter().initialize(this.endpoints, rateLimitingTier);
+        }
+        if (!dependencies.subscriptionSetFactory) {
+            dependencies.subscriptionSetFactory = new util_1.SubscriptionSetFactory(this.config);
+        }
+        return dependencies;
+    }
+}
+exports.Adapter = Adapter;

package/dist/src/background-executor.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { Server } from 'http';
+import { Adapter } from './adapter';
+/**
+ * Very simple background loop that will call the [[Transport.backgroundExecute]] functions in all Transports.
+ * It gets the time in ms to wait as the return value from those functions, and sleeps until next execution.
+ *
+ * @param adapter - an initialized External Adapter
+ * @param server - the http server to attach an on close listener to
+ */
+export declare function callBackgroundExecutes(adapter: Adapter, server?: Server): Promise<void>;