@chainlink/external-adapter-framework 0.0.6 → 0.0.7

package/dist/src/examples/bank-frick/util.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJWT = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const axios_1 = __importDefault(require("axios"));
+const util_1 = require("../../util");
+const logger = (0, util_1.makeLogger)('BankFrickUtil');
+// Used by all endpoints requiring authentication
+const generateJWT = async (config, signingAlgorithm = 'rsa-sha512') => {
+    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 = {
+        key: API_KEY,
+    };
+    const signature = crypto_1.default.sign(signingAlgorithm, Buffer.from(JSON.stringify(data)), PRIVATE_KEY);
+    const options = {
+        method: 'POST',
+        baseURL: API_ENDPOINT,
+        url: `authorize`,
+        headers: {
+            Signature: signature.toString('base64'),
+            algorithm: signingAlgorithm,
+        },
+        data,
+    };
+    const response = await axios_1.default.request(options);
+    return response.data.token;
+};
+exports.generateJWT = generateJWT;

package/dist/src/examples/coingecko/batch-warming.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchEndpoint = void 0;
+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: (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 = {
+    name: 'batch',
+    transport: batchEndpointTransport,
+    inputParameters,
+};

package/dist/src/examples/coingecko/index.js

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

package/dist/src/examples/coingecko/rest.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restEndpoint = void 0;
+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 = {
+    name: 'rest',
+    aliases: ['qwe'],
+    transport: restEndpointTransport,
+    inputParameters,
+};

package/dist/src/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/dist/src/examples/ncfx/index.js

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

package/dist/src/examples/ncfx/websocket.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSocketEndpoint = exports.websocketTransport = exports.inputParameters = void 0;
+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 = {
+    name: 'websocket',
+    transport: exports.websocketTransport,
+    inputParameters: exports.inputParameters,
+};

package/dist/src/index.js

@@ -0,0 +1,89 @@
+"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 adapter_1 = require("./adapter");
+const background_executor_1 = require("./background-executor");
+const cache_1 = require("./cache");
+const config_1 = require("./config");
+const metrics_1 = require("./metrics");
+const transports_1 = require("./transports");
+const util_1 = require("./util");
+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) => {
+    const config = (0, config_1.buildAdapterConfig)({
+        overrides: adapter.envDefaultOverrides,
+        customSettings: adapter.customSettings,
+    });
+    // Initialize adapter (create dependencies, inject them, build endpoint map, etc.)
+    const initializedAdapter = await (0, adapter_1.initializeAdapter)(adapter, config, dependencies);
+    let server = undefined;
+    if (config.METRICS_ENABLED && config.EXPERIMENTAL_METRICS_ENABLED) {
+        (0, metrics_1.setupMetricsServer)(adapter.name, config);
+    }
+    if (config.EA_MODE === 'reader' || config.EA_MODE === 'reader-writer') {
+        // Main REST API server to handle incoming requests
+        const app = await buildRestApi(config, initializedAdapter);
+        // Start listening for incoming requests
+        try {
+            await app.listen(config.EA_PORT, 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 (config.EA_MODE === 'writer' || 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)(initializedAdapter, server);
+    }
+    else {
+        logger.info('Background executor is disabled; this instance will not perform async background executes.');
+    }
+    return server;
+};
+exports.expose = expose;
+async function buildRestApi(config, initializedAdapter) {
+    const app = (0, fastify_1.default)();
+    // Add healthcheck endpoint before middlewares to bypass them
+    app.get((0, path_1.join)(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)(initializedAdapter);
+    app.register(async (router) => {
+        // Set up "middlewares" (hooks in fastify)
+        router.addHook('preHandler', (0, validation_1.validatorMiddleware)(initializedAdapter));
+        router.addHook('preHandler', (0, cache_1.buildCacheMiddleware)(initializedAdapter));
+        if (config['CORRELATION_ID_ENABLED']) {
+            router.addHook('onRequest', util_1.loggingContextMiddleware);
+        }
+        router.route({
+            url: config.BASE_URL,
+            method: 'POST',
+            handler: transportHandler,
+        }); // Pass config maybe? cleaner that multiple instances / dependencies
+    });
+    return app;
+}

package/dist/src/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";
+    // 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/dist/src/metrics/index.js

@@ -0,0 +1,76 @@
+"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.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 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;
+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/dist/src/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 = (endpoint, data) => {
+    const feedId = (0, cache_1.calculateFeedId)(endpoint, data);
+    return { feedId };
+};
+exports.getMetricsMeta = getMetricsMeta;

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

@@ -0,0 +1,37 @@
+"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) {
+            // TODO: See if we can remove this runtime check
+            if (endpoint.rateLimiting?.allocationPercentage == null) {
+                throw new Error(`Allocation percentage for endpoint "${endpoint.name}" is null`);
+            }
+            // TODO: Implement different strategy where this is not fixed, but rather divided based on whether all warmers are active
+            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;

package/dist/src/rate-limiting/index.js

@@ -0,0 +1,63 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRateLimitingTier = exports.consolidateTierLimits = void 0;
+__exportStar(require("./request/simple-counting"), exports);
+__exportStar(require("./background/fixed-frequency"), exports);
+/**
+ * This method will convert all possible settings for a rate limit tier and
+ * convert them all to requests per second, returning the lowest one
+ *
+ * @param limits - the rate limit tier set for the adapter
+ * @returns the most restrictive of the set options, in requests per second
+ */
+const consolidateTierLimits = (limits) => {
+    const perHourLimit = (limits?.rateLimit1h || Infinity) / (60 * 60);
+    const perMinuteLimit = (limits?.rateLimit1m || Infinity) / 60;
+    const perSecondLimit = limits?.rateLimit1s || Infinity;
+    return Math.min(perHourLimit, perMinuteLimit, perSecondLimit);
+};
+exports.consolidateTierLimits = consolidateTierLimits;
+/**
+ * Validates rate limiting tiers specified for the adapter, and returns the one to use.
+ *
+ * @param tiers - the adapter config listing the different available API tiers
+ * @param selectedTier - chosen API tier from settings, if present
+ * @returns the specified API tier, or a default one if none are specified
+ */
+const getRateLimitingTier = (tiers, selectedTier) => {
+    if (!tiers) {
+        return;
+    }
+    // Check that if the tiers object is defined, it has values
+    if (Object.values(tiers).length === 0) {
+        throw new Error(`The tiers object is defined, but has no entries`);
+    }
+    // Check that the tier set in the AdapterConfig is a valid one
+    if (selectedTier && !tiers[selectedTier]) {
+        const validTiersString = Object.keys(tiers)
+            .map((t) => `"${t}"`)
+            .join(', ');
+        throw new Error(`The selected rate limit tier "${selectedTier}" is not valid (can be one of ${validTiersString})`);
+    }
+    if (!selectedTier) {
+        // Sort the tiers by most to least restrictive
+        const sortedTiers = Object.values(tiers).sort((t1, t2) => (0, exports.consolidateTierLimits)(t1) - (0, exports.consolidateTierLimits)(t2));
+        return sortedTiers[0];
+    }
+    return tiers[selectedTier];
+};
+exports.getRateLimitingTier = getRateLimitingTier;

package/dist/src/rate-limiting/metrics.js

@@ -0,0 +1,32 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rateLimitCreditsSpentTotal = void 0;
+const client = __importStar(require("prom-client"));
+exports.rateLimitCreditsSpentTotal = new client.Counter({
+    name: 'rate_limit_credits_spent_total',
+    help: 'The number of data provider credits the adapter is consuming',
+    labelNames: ['participant_id', 'feed_id', 'experimental'],
+});

package/dist/src/rate-limiting/request/simple-counting.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleCountingRateLimiter = void 0;
+const util_1 = require("../../util");
+const logger = (0, util_1.makeLogger)('SimpleCountingRateLimiter');
+/**
+ * This rate limiter is the simplest stateful option.
+ * On startup, it'll compare the different thresholds for each tier, calculate them all
+ * in the finest window we'll use (seconds), and use the most restrictive one.
+ * This is so if the EA were to restart, we don't need to worry about persisting state
+ * for things like daily quotas. The downside is that this does not work well for bursty
+ * loads or spikes, in cases where e.g. the per second limit is high but daily quotas low.
+ */
+class SimpleCountingRateLimiter {
+    constructor() {
+        this.latestSecondInterval = 0;
+        this.requestsThisSecond = 0;
+        this.latestMinuteInterval = 0;
+        this.requestsThisMinute = 0;
+    }
+    initialize(endpoints, limits) {
+        // Translate the hourly limit into reqs per minute
+        const perHourLimit = (limits?.rateLimit1h || Infinity) / 60;
+        this.perMinuteLimit = Math.min(limits?.rateLimit1m || Infinity, perHourLimit);
+        this.perSecondLimit = limits?.rateLimit1s || Infinity;
+        logger.debug(`Using rate limiting settings: perMinute = ${this.perMinuteLimit} | perSecond: = ${this.perSecondLimit}`);
+        return this;
+    }
+    isUnderLimits() {
+        // If the limit is set to infinity, there was no tier limit specified
+        if (this.perSecondLimit === Infinity && this.perMinuteLimit === Infinity) {
+            return true;
+        }
+        const now = Date.now();
+        const nearestSecondInterval = Math.floor(now / 1000);
+        const nearestMinuteInterval = Math.floor(now / (1000 * 60));
+        // This should always run to completion, even if it doesn't look atomic; therefore the
+        // Ops should be "thread safe". Thank JS and its infinite single threaded dumbness.
+        if (nearestSecondInterval !== this.latestSecondInterval) {
+            logger.trace(`Clearing latest second interval, # of requests logged was: ${this.requestsThisSecond} `);
+            this.latestSecondInterval = nearestSecondInterval;
+            this.requestsThisSecond = 0;
+        }
+        if (nearestMinuteInterval !== this.latestMinuteInterval) {
+            logger.trace(`Clearing latest second minute, # of requests logged was: ${this.requestsThisMinute} `);
+            this.latestMinuteInterval = nearestMinuteInterval;
+            this.requestsThisMinute = 0;
+        }
+        if (this.requestsThisSecond < this.perSecondLimit &&
+            this.requestsThisMinute < this.perMinuteLimit) {
+            logger.trace('Request under limits, counting +1');
+            this.requestsThisSecond++;
+            this.requestsThisMinute++;
+            return true;
+        }
+        else {
+            logger.trace('Requests seen this interval are above limits');
+            return false;
+        }
+    }
+}
+exports.SimpleCountingRateLimiter = SimpleCountingRateLimiter;

package/dist/src/test.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const bank_frick_1 = require("./examples/bank-frick");
+// Start sample adapter
+(0, _1.expose)(bank_frick_1.adapter);