@chainlink/external-adapter-framework 0.0.10 → 0.0.12

package/dist/src/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@chainlink/external-adapter-framework",
+  "version": "0.0.6",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^0.27.2",
+    "fastify": "^3.29.0",
+    "ioredis": "^5.0.4",
+    "pino": "^7.9.2",
+    "prom-client": "13.2.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.6.3",
+    "ws": "^8.5.0"
+  },
+  "scripts": {
+    "start": "ts-node src/test.ts",
+    "generate-docs": "typedoc src/**/*.ts",
+    "test": "LOG_LEVEL=error EA_PORT=0 c8 ava",
+    "test-debug": "LOG_LEVEL=trace DEBUG=true EA_PORT=0 c8 ava --verbose",
+    "build": "tsc",
+    "lint": "eslint ./src"
+  },
+  "devDependencies": {
+    "@sinonjs/fake-timers": "^9.1.2",
+    "@types/node": "^18.6.5",
+    "@types/sinonjs__fake-timers": "^8.1.2",
+    "@types/ws": "^8.5.3",
+    "@typescript-eslint/eslint-plugin": "^5.17.0",
+    "@typescript-eslint/parser": "^5.17.0",
+    "ava": "^4.2.0",
+    "c8": "^7.11.2",
+    "eslint": "^8.14.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-tsdoc": "^0.2.16",
+    "mock-socket": "^9.1.3",
+    "nock": "^13.2.4",
+    "pino-pretty": "^7.6.0",
+    "prettier": "^2.6.1",
+    "ts-loader": "^9.3.1",
+    "typedoc": "^0.22.15",
+    "webpack": "^5.74.0",
+    "webpack-cli": "^4.10.0"
+  },
+  "prettier": {
+    "semi": false,
+    "singleQuote": true,
+    "printWidth": 100,
+    "endOfLine": "auto",
+    "trailingComma": "all",
+    "arrowParens": "always"
+  },
+  "optionalDependencies": {
+    "bufferutil": "^4.0.6",
+    "utf-8-validate": "^5.0.9"
+  },
+  "ava": {
+    "files": [
+      "test/**/*.test.ts"
+    ],
+    "extensions": [
+      "ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "workerThreads": false,
+    "environmentVariables": {
+      "METRICS_ENABLED": "false"
+    }
+  }
+}

package/dist/src/rate-limiting/background/fixed-frequency.d.ts

@@ -0,0 +1,11 @@
+import { AdapterRateLimitTier, BackgroundExecuteRateLimiter } from '..';
+import { AdapterEndpoint } from '../../adapter';
+import { SettingsMap } from '../../config';
+export declare const DEFAULT_SHARED_MS_BETWEEN_REQUESTS = 5000;
+export declare class FixedFrequencyRateLimiter implements BackgroundExecuteRateLimiter {
+    msBetweenRequestsMap: {
+        [endpointName: string]: number;
+    };
+    initialize<Params, Result, CustomSettings extends SettingsMap>(endpoints: AdapterEndpoint<Params, Result, CustomSettings>[], limits?: AdapterRateLimitTier): this;
+    msUntilNextExecution(endpointName: string): number;
+}

package/dist/src/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;

package/dist/src/rate-limiting/index.d.ts

@@ -0,0 +1,55 @@
+import { AdapterEndpoint } from '../adapter';
+import { SettingsMap } from '../config';
+export * from './request/simple-counting';
+export * from './background/fixed-frequency';
+export interface AdapterRateLimitTier {
+    rateLimit1s?: number;
+    rateLimit1m?: number;
+    rateLimit1h?: number;
+    note?: string;
+}
+/**
+ * Common interface for all RateLimiter classes to implement
+ */
+export interface RateLimiter {
+    /**
+     * Method to ensure all RateLimiters can be initialized in the same manner.
+     *
+     * @param limits - settings for how much throughput to allow for the Adapter
+     * @param endpoints - list of adapter endpoints
+     */
+    initialize<Params, Result, CustomSettings extends SettingsMap>(endpoints: AdapterEndpoint<Params, Result, CustomSettings>[], limits: AdapterRateLimitTier): this;
+}
+/**
+ * RequestRateLimiters perform checks agains imminent outbound requests for any transport.
+ */
+export interface RequestRateLimiter extends RateLimiter {
+    /**
+     * This method will check using whatever strategy is implemented to determine if
+     * this request can be processed. If so, it returns true; if not, returns false.
+     */
+    isUnderLimits(): boolean;
+}
+/**
+ * BackgroundExecuteFrequencyRateLimiters will implement custom logic to calculate
+ * the period of time to wait between background executions for a transport.
+ */
+export interface BackgroundExecuteRateLimiter extends RateLimiter {
+    msUntilNextExecution(endpointName: string): number;
+}
+/**
+ * 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
+ */
+export declare const consolidateTierLimits: (limits?: AdapterRateLimitTier) => number;
+/**
+ * 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
+ */
+export declare const getRateLimitingTier: (tiers?: Record<string, AdapterRateLimitTier>, selectedTier?: string) => AdapterRateLimitTier | undefined;

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.d.ts

@@ -0,0 +1,3 @@
+import * as client from 'prom-client';
+export declare const retrieveCost: <ProviderResponseBody>(data: ProviderResponseBody) => number;
+export declare const rateLimitCreditsSpentTotal: client.Counter<"feed_id" | "participant_id">;

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

@@ -0,0 +1,44 @@
+"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 = exports.retrieveCost = void 0;
+const client = __importStar(require("prom-client"));
+// Retrieve cost field from response if exists
+// If not return default cost of 1
+const retrieveCost = (data) => {
+    const cost = data['cost'];
+    if (typeof cost === 'number' || typeof cost === 'string') {
+        return Number(cost);
+    }
+    else {
+        return 1;
+    }
+};
+exports.retrieveCost = retrieveCost;
+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'],
+});

package/dist/src/rate-limiting/request/simple-counting.d.ts

@@ -0,0 +1,21 @@
+import { AdapterRateLimitTier, RateLimiter } from '..';
+import { AdapterEndpoint } from '../../adapter';
+import { SettingsMap } from '../../config';
+/**
+ * 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.
+ */
+export declare class SimpleCountingRateLimiter implements RateLimiter {
+    latestSecondInterval: number;
+    requestsThisSecond: number;
+    latestMinuteInterval: number;
+    requestsThisMinute: number;
+    perSecondLimit: number;
+    perMinuteLimit: number;
+    initialize<Params, Result, CustomSettings extends SettingsMap>(endpoints: AdapterEndpoint<Params, Result, CustomSettings>[], limits?: AdapterRateLimitTier): this;
+    isUnderLimits(): boolean;
+}

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.d.ts

@@ -0,0 +1 @@
+export {};

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);

package/dist/src/transports/batch-warming.d.ts

@@ -0,0 +1,35 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Cache } from '../cache';
+import { AdapterConfig, SettingsMap } from '../config';
+import { BackgroundExecuteRateLimiter } from '../rate-limiting';
+import { SubscriptionSet } from '../util';
+import { AdapterRequest, ProviderResult } from '../util/request';
+import { Transport } from './';
+import { AdapterContext, AdapterDependencies } from '../adapter';
+/**
+ * Transport implementation that takes incoming batches requests and keeps a warm cache of values.
+ * Within the setup function, adapter params are added to an set that also keeps track and expires values.
+ * In the background execute, the list of non-expired items in the set is fetched.
+ * Then, the list is passed through the `prepareRequest` function, that returns an AxiosRequestConfig.
+ * The Data Provider response is, they are passed through the `parseResponse` function to create a [[CacheEntry]] list.
+ * Finally, the items in that [[CacheEntry]] list are set in the Cache so the Adapter can fetch values from there.
+ *
+ * @typeParam AdapterParams - interface for the adapter request body
+ * @typeParam ProviderRequestBody - interface for the body of the request to the Data Provider
+ * @typeParam ProviderResponseBody - interface for the body of the Data Provider's response
+ */
+export declare class BatchWarmingTransport<AdapterParams, ProviderRequestBody, ProviderResponseBody, CustomSettings extends SettingsMap> implements Transport<AdapterParams, ProviderResponseBody, CustomSettings> {
+    private config;
+    cache: Cache;
+    rateLimiter: BackgroundExecuteRateLimiter;
+    subscriptionSet: SubscriptionSet<AdapterParams>;
+    WARMER_ACTIVE: boolean;
+    constructor(config: {
+        prepareRequest: (params: AdapterParams[], context: AdapterContext<CustomSettings>) => AxiosRequestConfig<ProviderRequestBody>;
+        parseResponse: (res: AxiosResponse<ProviderResponseBody>, context: AdapterContext<CustomSettings>) => ProviderResult<AdapterParams>[];
+    });
+    initialize(dependencies: AdapterDependencies): Promise<void>;
+    hasBeenSetUp(req: AdapterRequest<AdapterParams>): Promise<boolean>;
+    setup(req: AdapterRequest<AdapterParams>, config: AdapterConfig<CustomSettings>): Promise<void>;
+    backgroundExecute(context: AdapterContext<CustomSettings>): Promise<number>;
+}

package/dist/src/transports/batch-warming.js

@@ -0,0 +1,101 @@
+"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.BatchWarmingTransport = void 0;
+const util_1 = require("../util");
+const _1 = require("./");
+const util_2 = require("./util");
+const rateLimitMetrics = __importStar(require("../rate-limiting/metrics"));
+const cacheMetrics = __importStar(require("../cache/metrics"));
+const WARMUP_BATCH_REQUEST_ID = '9002';
+const logger = (0, util_1.makeLogger)('BatchWarmingTransport');
+/**
+ * Transport implementation that takes incoming batches requests and keeps a warm cache of values.
+ * Within the setup function, adapter params are added to an set that also keeps track and expires values.
+ * In the background execute, the list of non-expired items in the set is fetched.
+ * Then, the list is passed through the `prepareRequest` function, that returns an AxiosRequestConfig.
+ * The Data Provider response is, they are passed through the `parseResponse` function to create a [[CacheEntry]] list.
+ * Finally, the items in that [[CacheEntry]] list are set in the Cache so the Adapter can fetch values from there.
+ *
+ * @typeParam AdapterParams - interface for the adapter request body
+ * @typeParam ProviderRequestBody - interface for the body of the request to the Data Provider
+ * @typeParam ProviderResponseBody - interface for the body of the Data Provider's response
+ */
+class BatchWarmingTransport {
+    constructor(config) {
+        this.config = config;
+        // Flag used to track whether the warmer has moved from having no entries to having some and vice versa
+        // Used for recording the cache warmer active metrics accurately
+        this.WARMER_ACTIVE = false;
+    }
+    async initialize(dependencies) {
+        this.cache = dependencies.cache;
+        this.rateLimiter = dependencies.backgroundExecuteRateLimiter;
+        this.subscriptionSet = dependencies.subscriptionSetFactory.buildSet();
+    }
+    async hasBeenSetUp(req) {
+        return !!(await this.subscriptionSet.get(req.requestContext.cacheKey));
+    }
+    async setup(req, config) {
+        logger.debug(`Adding entry to batch warming set: [${req.requestContext.cacheKey}] = ${req.requestContext.data}`);
+        await this.subscriptionSet.add(req.requestContext.cacheKey, req.requestContext.data, config.WARMUP_SUBSCRIPTION_TTL);
+    }
+    async backgroundExecute(context) {
+        logger.debug('Starting background execute');
+        const entries = await this.subscriptionSet.getAll();
+        if (!entries.length) {
+            logger.debug('No entries in batch warming set, skipping');
+            if (this.WARMER_ACTIVE) {
+                // Decrement count when warmer changed from having entries to having none
+                cacheMetrics.cacheWarmerCount.labels({ isBatched: 'true' }).dec();
+                this.WARMER_ACTIVE = false;
+            }
+            return this.rateLimiter.msUntilNextExecution(context.adapterEndpoint.name);
+        }
+        else if (this.WARMER_ACTIVE === false) {
+            // Increment count when warmer changed from having no entries to having some
+            cacheMetrics.cacheWarmerCount.labels({ isBatched: 'true' }).inc();
+            this.WARMER_ACTIVE = true;
+        }
+        const request = this.config.prepareRequest(entries, context);
+        logger.trace('Sending request to data provider...');
+        const providerResponse = await (0, util_2.axiosRequest)(request);
+        logger.debug(`Got response from provider, parsing (raw body: ${providerResponse.data})`);
+        const results = this.config.parseResponse(providerResponse, context);
+        const adapterResponses = (0, _1.buildCacheEntriesFromResults)(results, context);
+        logger.debug('Setting adapter responses in cache');
+        await this.cache.setMany(adapterResponses, context.adapterConfig.CACHE_MAX_AGE);
+        // Record cost of data provider call
+        const cost = rateLimitMetrics.retrieveCost(providerResponse.data);
+        rateLimitMetrics.rateLimitCreditsSpentTotal
+            .labels({
+            feed_id: 'N/A',
+            participant_id: WARMUP_BATCH_REQUEST_ID,
+        })
+            .inc(cost);
+        return this.rateLimiter.msUntilNextExecution(context.adapterEndpoint.name);
+    }
+}
+exports.BatchWarmingTransport = BatchWarmingTransport;