@chainlink/external-adapter-framework 0.0.15 → 0.0.16

package/examples/coingecko/test/integration/fixtures.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMocks = void 0;
+const nock_1 = __importDefault(require("nock"));
+const capturedRequests_json_1 = __importDefault(require("./capturedRequests.json"));
+// This is a generic fixture file that can be copy-pasted to generate fixtures from a
+// capturedRequests.json file.  To generate a capturedRequests.json file,
+// set env var RECORD=true and run e2e tests.
+const createMocks = () => {
+    const mocks = [];
+    for (const baseUrl in capturedRequests_json_1.default) {
+        const mock = (0, nock_1.default)(baseUrl, { encodedQueryParams: true });
+        for (const request of capturedRequests_json_1.default[baseUrl]) {
+            if (request.method === 'GET') {
+                mock
+                    .get((uri) => {
+                    const deconstructedRequestUrl = uri.split(/[?=,&]+/);
+                    const deconstructedMockUrl = request.path.split(/[?=,&]+/);
+                    return (deconstructedRequestUrl.sort().join(',') === deconstructedMockUrl.sort().join(','));
+                })
+                    .times(100)
+                    .reply(request.statusCode, () => request.response, [
+                    'Content-Type',
+                    'application/json',
+                    'Connection',
+                    'close',
+                    'Vary',
+                    'Accept-Encoding',
+                    'Vary',
+                    'Origin',
+                ]);
+            }
+        }
+        mocks.push(mock);
+    }
+    return mocks;
+};
+exports.createMocks = createMocks;

package/examples/coingecko-old/batch-warming.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchEndpoint = void 0;
+const adapter_1 = require("../../adapter");
+const batch_warming_1 = require("../../transports/batch-warming");
+const DEFAULT_URL = 'https://pro-api.coingecko.com/api/v3';
+const 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,
+    },
+};
+const batchEndpointTransport = new batch_warming_1.BatchWarmingTransport({
+    prepareRequest: (params, context) => {
+        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: (params, res) => {
+        const entries = [];
+        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;
+    },
+});
+exports.batchEndpoint = new adapter_1.AdapterEndpoint({
+    name: 'batch',
+    transport: batchEndpointTransport,
+    inputParameters,
+});

package/examples/coingecko-old/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapter = void 0;
+const adapter_1 = require("../../adapter");
+const batch_warming_1 = require("./batch-warming");
+const rest_1 = require("./rest");
+exports.adapter = new adapter_1.Adapter({
+    name: 'coingecko',
+    defaultEndpoint: 'batch',
+    endpoints: [rest_1.restEndpoint, batch_warming_1.batchEndpoint],
+});

package/examples/coingecko-old/rest.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restEndpoint = void 0;
+const adapter_1 = require("../../adapter");
+const transports_1 = require("../../transports");
+const DEFAULT_URL = 'https://api.coingecko.com/api/v3';
+const 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,
+    },
+};
+const restEndpointTransport = new transports_1.RestTransport({
+    prepareRequest: (req) => {
+        return {
+            baseURL: DEFAULT_URL,
+            url: '/simple/price',
+            method: 'GET',
+            params: {
+                ids: req.requestContext.data.base,
+                vs_currencies: req.requestContext.data.quote,
+            },
+        };
+    },
+    parseResponse: (req, res) => {
+        return {
+            data: res.data,
+            statusCode: 200,
+            result: res.data[req.requestContext.data.base]?.[req.requestContext.data.quote],
+        };
+    },
+    options: {
+        coalescing: true,
+    },
+});
+exports.restEndpoint = new adapter_1.AdapterEndpoint({
+    name: 'rest',
+    aliases: ['qwe'],
+    transport: restEndpointTransport,
+    inputParameters,
+});

package/examples/ncfx/config/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customSettings = void 0;
+exports.customSettings = {
+    USERNAME: {
+        description: 'Username for the NCFX API',
+        type: 'string',
+        required: true,
+    },
+    PASSWORD: {
+        description: 'Password for the NCFX API',
+        type: 'string',
+        required: true,
+    },
+};

package/examples/ncfx/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapter = void 0;
+const adapter_1 = require("../../adapter");
+const config_1 = require("./config");
+const websocket_1 = require("./websocket");
+exports.adapter = new adapter_1.Adapter({
+    name: 'ncfx',
+    endpoints: [websocket_1.webSocketEndpoint],
+    customSettings: config_1.customSettings,
+});

package/examples/ncfx/websocket.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSocketEndpoint = exports.websocketTransport = exports.inputParameters = void 0;
+const adapter_1 = require("../../adapter");
+const websocket_1 = require("../../transports/websocket");
+const util_1 = require("../../util");
+exports.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,
+    },
+};
+const logger = (0, util_1.makeLogger)('NcfxWebSocketTransport');
+exports.websocketTransport = new websocket_1.WebSocketTransport({
+    url: 'wss://feed.newchangefx.com/cryptodata',
+    handlers: {
+        open(connection, context) {
+            return new Promise((resolve, reject) => {
+                // Set up listener
+                connection.on('message', (data) => {
+                    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) {
+            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) => ({
+            request: 'subscribe',
+            ccy: `${params.base}/${params.quote}`,
+        }),
+        unsubscribeMessage: (params) => ({
+            request: 'unsubscribe',
+            ccy: `${params.base}/${params.quote}`,
+        }),
+    },
+});
+exports.webSocketEndpoint = new adapter_1.AdapterEndpoint({
+    name: 'websocket',
+    transport: exports.websocketTransport,
+    inputParameters: exports.inputParameters,
+});

package/index.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = void 0;
+const fastify_1 = __importDefault(require("fastify"));
+const path_1 = require("path");
+const background_executor_1 = require("./background-executor");
+const cache_1 = require("./cache");
+const metrics_1 = require("./metrics");
+const transports_1 = require("./transports");
+const util_1 = require("./util");
+const test_payload_loader_1 = require("./util/test-payload-loader");
+const validation_1 = require("./validation");
+const logger = (0, util_1.makeLogger)('Main');
+const VERSION = process.env['npm_package_version'];
+/**
+ * Main function for the framework.
+ * Initializes config and dependencies, uses those to initialize Transports, and starts listening for requests.
+ *
+ * @param adapter - an object describing an External Adapter
+ * @param dependencies - an optional object with adapter dependencies to inject
+ * @returns a Promise that resolves to the http.Server listening for connections
+ */
+const expose = async (adapter, dependencies) => {
+    // Initialize adapter (create dependencies, inject them, build endpoint map, etc.)
+    await adapter.initialize(dependencies);
+    let server = undefined;
+    if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
+        (0, metrics_1.setupMetricsServer)(adapter.name, adapter.config);
+    }
+    if (adapter.config.EA_MODE === 'reader' || adapter.config.EA_MODE === 'reader-writer') {
+        // Main REST API server to handle incoming requests
+        const app = await buildRestApi(adapter);
+        // Start listening for incoming requests
+        try {
+            await app.listen(adapter.config.EA_PORT, adapter.config.EA_HOST);
+        }
+        catch (err) {
+            logger.fatal(`There was an error when starting the EA server: ${err}`);
+            process.exit();
+        }
+        logger.info(`Listening on port ${app.server.address().port}`);
+        server = app.server;
+    }
+    else {
+        logger.info('REST API is disabled; this instance will not process incoming requests.');
+    }
+    if (adapter.config.EA_MODE === 'writer' || adapter.config.EA_MODE === 'reader-writer') {
+        // Start background loop that will take care of calling any async Transports
+        logger.info('Starting background execution loop');
+        (0, background_executor_1.callBackgroundExecutes)(adapter, server);
+    }
+    else {
+        logger.info('Background executor is disabled; this instance will not perform async background executes.');
+    }
+    return server;
+};
+exports.expose = expose;
+async function buildRestApi(adapter) {
+    const app = (0, fastify_1.default)();
+    // Add healthcheck endpoint before middlewares to bypass them
+    app.get((0, path_1.join)(adapter.config.BASE_URL, 'health'), (req, res) => {
+        res.status(200).send({ message: 'OK', version: VERSION });
+    });
+    // Use global error handling
+    app.setErrorHandler(validation_1.errorCatchingMiddleware);
+    const transportHandler = await (0, transports_1.buildTransportHandler)(adapter);
+    app.register(async (router) => {
+        // Set up "middlewares" (hooks in fastify)
+        router.addHook('preHandler', (0, validation_1.validatorMiddleware)(adapter));
+        router.addHook('preHandler', (0, cache_1.buildCacheMiddleware)(adapter));
+        if (adapter.config['CORRELATION_ID_ENABLED']) {
+            router.addHook('onRequest', util_1.loggingContextMiddleware);
+        }
+        router.route({
+            url: adapter.config.BASE_URL,
+            method: 'POST',
+            handler: transportHandler,
+        });
+        if (adapter.config.METRICS_ENABLED && adapter.config.EXPERIMENTAL_METRICS_ENABLED) {
+            router.addHook('onResponse', metrics_1.buildMetricsMiddleware);
+        }
+    });
+    // Add smoke endpoint after middleware which are needed for tests
+    buildSmokeEndpoint(app, adapter.config);
+    return app;
+}
+/**
+ * Adds the /smoke endpoint to the API for smoke testing the adapter
+ *
+ * @param app - the Fastify instance
+ * @param config - the initialized adapter config
+ */
+function buildSmokeEndpoint(app, config) {
+    const testPayload = (0, test_payload_loader_1.loadTestPayload)(config.SMOKE_TEST_PAYLOAD_FILE_NAME);
+    app.get((0, path_1.join)(config.BASE_URL, 'smoke'), async (_, res) => {
+        if (testPayload.isDefault) {
+            return res.status(200).send('OK');
+        }
+        const errors = [];
+        for (const index in testPayload.requests) {
+            try {
+                const request = { id: index, data: testPayload.requests[index] };
+                // Use Fastify's app inject to pass smoke requests internally
+                const response = await app.inject({
+                    method: 'POST',
+                    url: '/',
+                    payload: request,
+                });
+                const parsedResponse = JSON.parse(response.body);
+                // Throw error if not 2xx status code
+                if (parsedResponse.statusCode < 200 || parsedResponse.statusCode > 299) {
+                    throw Error('Smoke test request failed');
+                }
+            }
+            catch (e) {
+                errors.push(e);
+            }
+        }
+        if (errors.length > 0) {
+            return res.status(500).send(errors);
+        }
+        return res.status(200).send('OK');
+    });
+}

package/metrics/constants.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestDurationBuckets = exports.MAX_FEED_ID_LENGTH = exports.HttpRequestType = void 0;
+var HttpRequestType;
+(function (HttpRequestType) {
+    HttpRequestType["CACHE_HIT"] = "cacheHit";
+    HttpRequestType["DATA_PROVIDER_HIT"] = "dataProviderHit";
+    HttpRequestType["ADAPTER_ERROR"] = "adapterError";
+    HttpRequestType["INPUT_ERROR"] = "inputError";
+    HttpRequestType["RATE_LIMIT_ERROR"] = "rateLimitError";
+    // BURST_LIMIT_ERROR = 'burstLimitError',
+    // BACKOFF_ERROR = 'backoffError',
+    HttpRequestType["DP_ERROR"] = "dataProviderError";
+    HttpRequestType["TIMEOUT_ERROR"] = "timeoutError";
+    HttpRequestType["CONNECTION_ERROR"] = "connectionError";
+    // RES_EMPTY_ERROR = 'responseEmptyError',
+    // RES_INVALID_ERROR = 'responseInvalidError',
+    HttpRequestType["CUSTOM_ERROR"] = "customError";
+})(HttpRequestType = exports.HttpRequestType || (exports.HttpRequestType = {}));
+/**
+ * Maxiumum number of characters that a feedId can contain.
+ */
+exports.MAX_FEED_ID_LENGTH = 300;
+// We should tune these as we collect data, this is the default bucket distribution that prom comes with
+exports.requestDurationBuckets = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];

package/metrics/index.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpRequestDurationSeconds = exports.httpRequestsTotal = exports.buildMetricsMiddleware = exports.setupMetrics = exports.setupMetricsServer = void 0;
+const client = __importStar(require("prom-client"));
+const constants_1 = require("./constants");
+const util_1 = require("../util");
+const fastify_1 = __importDefault(require("fastify"));
+const path_1 = require("path");
+const error_1 = require("../validation/error");
+const logger = (0, util_1.makeLogger)('Metrics');
+function setupMetricsServer(name, config) {
+    const metricsApp = (0, fastify_1.default)({
+        logger: false,
+    });
+    const metricsPort = config.METRICS_PORT;
+    const endpoint = config.METRICS_USE_BASE_URL ? (0, path_1.join)(config.BASE_URL, 'metrics') : '/metrics';
+    const eaHost = config.EA_HOST;
+    (0, exports.setupMetrics)(name, config);
+    metricsApp.get(endpoint, async (_, res) => {
+        res.type('txt');
+        res.send(await client.register.metrics());
+    });
+    metricsApp.listen(metricsPort, eaHost, () => logger.info(`Monitoring listening on port ${metricsPort}!`));
+}
+exports.setupMetricsServer = setupMetricsServer;
+const setupMetrics = (name, config) => {
+    client.collectDefaultMetrics();
+    client.register.setDefaultLabels({
+        app_name: config.METRICS_NAME || name || 'N/A',
+        app_version: config['npm_package_version'],
+    });
+};
+exports.setupMetrics = setupMetrics;
+/**
+ * Builds metrics middleware that records end to end EA response times
+ * and count of requests
+ *
+ * @returns the cache middleware function
+ */
+const buildMetricsMiddleware = (req, res, done) => {
+    const feedId = req.requestContext.meta?.metrics?.feedId || 'N/A';
+    const labels = buildHttpRequestMetricsLabel(feedId, req.requestContext.meta?.error, req.requestContext.meta?.metrics?.cacheHit);
+    // Record number of requests sent to EA
+    exports.httpRequestsTotal.labels(labels).inc();
+    // Record response time of request through entire EA
+    exports.httpRequestDurationSeconds.observe(res.getResponseTime());
+    logger.debug(`Response time for ${feedId}: ${res.getResponseTime()}ms`);
+    done();
+};
+exports.buildMetricsMiddleware = buildMetricsMiddleware;
+const buildHttpRequestMetricsLabel = (feedId, error, cacheHit) => {
+    const labels = {};
+    labels.method = 'POST';
+    labels.feed_id = feedId;
+    if (error instanceof error_1.AdapterError) {
+        // If error present and an instace of AdapterError, build label from error info
+        labels.type = error?.metricsLabel || constants_1.HttpRequestType.ADAPTER_ERROR;
+        labels.status_code = error?.statusCode;
+        labels.provider_status_code = error?.providerStatusCode;
+    }
+    else if (error instanceof Error) {
+        // If error present and not instance of generic Error, unexpected failure occurred
+        labels.type = constants_1.HttpRequestType.ADAPTER_ERROR;
+        labels.status_code = 500;
+    }
+    else {
+        // If no error present, request went as expected
+        labels.status_code = 200;
+        if (cacheHit) {
+            labels.type = constants_1.HttpRequestType.CACHE_HIT;
+        }
+        else {
+            labels.type = constants_1.HttpRequestType.DATA_PROVIDER_HIT;
+            labels.provider_status_code = 200;
+        }
+    }
+    return labels;
+};
+exports.httpRequestsTotal = new client.Counter({
+    name: 'http_requests_total',
+    help: 'The number of http requests this external adapter has serviced for its entire uptime',
+    labelNames: [
+        'method',
+        'status_code',
+        'retry',
+        'type',
+        'is_cache_warming',
+        'feed_id',
+        'provider_status_code',
+    ],
+});
+exports.httpRequestDurationSeconds = new client.Histogram({
+    name: 'http_request_duration_seconds',
+    help: 'A histogram bucket of the distribution of http request durations',
+    buckets: constants_1.requestDurationBuckets,
+});

package/metrics/util.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetricsMeta = void 0;
+const cache_1 = require("../cache");
+const getMetricsMeta = ({ adapterEndpoint, adapterConfig, }, data) => {
+    const feedId = (0, cache_1.calculateFeedId)({ adapterEndpoint, adapterConfig }, data);
+    return { feedId };
+};
+exports.getMetricsMeta = getMetricsMeta;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainlink/external-adapter-framework",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "main": "dist/index.js",
   "license": "MIT",
   "dependencies": {
@@ -9,8 +9,6 @@
     "ioredis": "^5.0.4",
     "pino": "^7.9.2",
     "prom-client": "13.2.0",
-    "supertest": "^6.2.4",
-    "ts-jest": "^28.0.7",
     "ts-node": "^10.9.1",
     "typescript": "^4.6.3",
     "ws": "^8.5.0"
@@ -22,16 +20,12 @@
     "test-debug": "LOG_LEVEL=trace DEBUG=true EA_PORT=0 c8 ava --verbose",
     "build": "tsc",
     "lint": "eslint ./src && prettier --check ./src/**/*.ts",
-    "lint-fix": "eslint --fix ./src && prettier --write ./src/**/*.ts",
-    "dev": "NODE_ENV=develop tsnd --respawn --transpile-only --project tsconfig.json './src/test.ts'",
-    "verify": "yarn lint && yarn build && yarn build -p ./test/tsconfig.json && yarn test"
+    "dev": "NODE_ENV=develop tsnd --respawn --transpile-only --project tsconfig.json './src/test.ts'"
   },
   "devDependencies": {
     "@sinonjs/fake-timers": "^9.1.2",
-    "@types/jest": "^28.1.7",
     "@types/node": "^18.6.5",
     "@types/sinonjs__fake-timers": "^8.1.2",
-    "@types/supertest": "^2.0.12",
     "@types/ws": "^8.5.3",
     "@typescript-eslint/eslint-plugin": "^5.17.0",
     "@typescript-eslint/parser": "^5.17.0",
@@ -44,13 +38,8 @@
     "nock": "^13.2.4",
     "pino-pretty": "^7.6.0",
     "prettier": "^2.6.1",
-    "ts-loader": "^9.3.1",
     "ts-node-dev": "2.0.0",
-    "typedoc": "^0.22.15",
-    "url": "^0.11.0",
-    "webpack": "^5.74.0",
-    "webpack-cli": "^4.10.0",
-    "webpack-merge": "^5.8.0"
+    "typedoc": "^0.22.15"
   },
   "prettier": {
     "semi": false,
@@ -77,6 +66,7 @@
     "workerThreads": false,
     "environmentVariables": {
       "METRICS_ENABLED": "false"
-    }
+    },
+    "timeout": "20s"
   }
 }

package/rate-limiting/background/fixed-frequency.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixedFrequencyRateLimiter = exports.DEFAULT_SHARED_MS_BETWEEN_REQUESTS = void 0;
+const __1 = require("..");
+const util_1 = require("../../util");
+const logger = (0, util_1.makeLogger)('FixedFrequencyRateLimiter');
+exports.DEFAULT_SHARED_MS_BETWEEN_REQUESTS = 5000;
+class FixedFrequencyRateLimiter {
+    constructor() {
+        this.msBetweenRequestsMap = {};
+    }
+    initialize(endpoints, limits) {
+        // Translate the hourly limit into reqs per minute
+        let sharedMsBetweenRequests = 1000 / (0, __1.consolidateTierLimits)(limits);
+        // If there is no limit set, we use some reasonable number
+        if (!limits?.rateLimit1h && !limits?.rateLimit1m && !limits?.rateLimit1s) {
+            // 5s period for all seems good
+            sharedMsBetweenRequests = exports.DEFAULT_SHARED_MS_BETWEEN_REQUESTS;
+        }
+        logger.debug('Using fixed frequency batch rate limiting');
+        for (const endpoint of endpoints) {
+            if (endpoint.rateLimiting?.allocationPercentage == null) {
+                throw new Error(`Allocation percentage for endpoint "${endpoint.name}" is null`);
+            }
+            this.msBetweenRequestsMap[endpoint.name] =
+                (sharedMsBetweenRequests / endpoint.rateLimiting?.allocationPercentage) * 100;
+            logger.debug(`Endpoint [${endpoint.name}]: ${this.msBetweenRequestsMap[endpoint.name] / 1000}s between requests`);
+        }
+        return this;
+    }
+    msUntilNextExecution(endpointName) {
+        return this.msBetweenRequestsMap[endpointName];
+    }
+}
+exports.FixedFrequencyRateLimiter = FixedFrequencyRateLimiter;