@steerprotocol/data-connector-loader 0.1.5 → 0.2.0

package/lib/index.d.ts

@@ -1,15 +1,4 @@
-import { DataConnector } from './dataConnector';
-import { ethers } from 'ethers';
-export { DataConnector };
-export declare class DataConnectorExecution {
-    private dataConnectors;
-    constructor(dataConnectors: Array<DataConnector>);
-    private delay;
-    private log;
-    private fetchData;
-    private exponentialBackoffDelay;
-    execute<T>(_vaultConfig: string): Promise<Array<T>>;
-    getAverageBlockTime(provider: ethers.providers.Provider, blockCount?: number): Promise<number>;
-    getBlockNumberFromAvgBlockTime(provider: ethers.providers.Provider, targetTimestamp: number, avgBlockTime: number): Promise<number>;
-    private downloadWasmBundle;
-}
+import { DataConnector } from './bundle/bundleDataConnector';
+import { DataConnectorExecution } from './execution/executionDataConnector';
+import { ExecutionApp } from './execution/executionApp';
+export { DataConnector, DataConnectorExecution, ExecutionApp };

package/lib/index.js

@@ -1,200 +1,9 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataConnectorExecution = exports.DataConnector = void 0;
-const dataConnector_1 = require("./dataConnector");
-Object.defineProperty(exports, "DataConnector", { enumerable: true, get: function () { return dataConnector_1.DataConnector; } });
-const axios_1 = __importDefault(require("axios"));
-const pluginManager_1 = require("./pluginManager");
-const utils_1 = require("./utils");
-class DataConnectorExecution {
-    constructor(dataConnectors) {
-        this.dataConnectors = dataConnectors;
-    }
-    delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    log(...args) {
-        if (process.env.DEBUG === 'true') {
-            console.log(...args);
-        }
-    }
-    fetchData(request, attempts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.log('Request payload: =============', request);
-            attempts = attempts + 1;
-            try {
-                const response = (yield (0, axios_1.default)(request)).data;
-                this.log('API Response: =============', response);
-                if ('errors' in response && response['errors'].length > 0) {
-                    if (attempts < 3) {
-                        yield this.delay(this.exponentialBackoffDelay(attempts));
-                        return yield this.fetchData(request, attempts);
-                    }
-                    else {
-                        throw new Error('Maximum retry attempts reached');
-                    }
-                }
-                return response;
-            }
-            catch (error) {
-                if (attempts < 3) {
-                    yield this.delay(this.exponentialBackoffDelay(attempts));
-                    return yield this.fetchData(request, attempts);
-                }
-                else {
-                    throw error;
-                }
-            }
-        });
-    }
-    exponentialBackoffDelay(attempts) {
-        const baseDelay = 1000; // 1 second
-        const maxDelay = 30000; // 30 seconds
-        const delay = Math.min(baseDelay * Math.pow(2, attempts - 1), maxDelay);
-        return delay;
-    }
-    execute(_vaultConfig) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            const executionTimestamp = new Date().getTime();
-            const vaultConfig = JSON.parse(_vaultConfig);
-            const transformationData = [];
-            const pluginManager = new pluginManager_1.PluginManager();
-            yield pluginManager.registerFromPublicConfig();
-            for (const dataConnector of this.dataConnectors) {
-                if (!dataConnector.module) {
-                    yield dataConnector.load();
-                }
-                const provider = dataConnector.getProvider({});
-                let blockTime = 0;
-                let blockNumber = 9;
-                if (provider) {
-                    blockTime = yield this.getAverageBlockTime(provider);
-                    blockNumber = yield this.getBlockNumberFromAvgBlockTime(provider, vaultConfig.epochTimestamp / 1000, // convert to seconds
-                    blockTime);
-                }
-                dataConnector.setExecutionContext({
-                    executionTimestamp,
-                    epochTimestamp: vaultConfig.epochTimestamp,
-                    epochLength: Number(vaultConfig.strategyConfigData.epochLength),
-                    vaultAddress: vaultConfig.vaultAddress,
-                    blockTime,
-                    blockNumber,
-                });
-                let version = 1;
-                try {
-                    version = yield dataConnector.version();
-                }
-                catch (e) {
-                    // Data connector is missing version function, fallback to v1 logic
-                }
-                let request = yield dataConnector.execute('');
-                let response;
-                try {
-                    while (request !== 'true') {
-                        if (dataConnector.configObj.isChainRead == true) {
-                            response = yield dataConnector.view(JSON.parse(request));
-                        }
-                        else {
-                            const parsedRequest = yield pluginManager.process(typeof request == 'string' ? JSON.parse(request) : request);
-                            yield this.delay(1000);
-                            response = yield this.fetchData(parsedRequest, 0);
-                        }
-                        request = yield dataConnector.execute(JSON.stringify(response));
-                    }
-                }
-                catch (e) {
-                    // process.env.SILENT_ERRORS
-                    if (process.env.DATA_LOADER_SILENT_ERRORS !== 'true') {
-                        console.error('Data connector failed to process.', e);
-                    }
-                    throw e;
-                }
-                let transformedData = JSON.parse(dataConnector.getResults());
-                if (version == 1 && transformedData.length > 0) {
-                    const keys = Object.keys(transformedData[0]);
-                    const requiredKeys = ['timestamp', 'open', 'high', 'low', 'close'];
-                    const hasAllKeys = requiredKeys.every((key) => keys.includes(key));
-                    // has the 'lookback' key
-                    const lookback = (_a = dataConnector === null || dataConnector === void 0 ? void 0 : dataConnector.configObj) === null || _a === void 0 ? void 0 : _a.lookback;
-                    if (hasAllKeys && !!lookback) {
-                        // Now that we have identified a v1 data connector, we need to transform the data so that the data is up to the current execution epoch timestamp
-                        if ((_b = dataConnector === null || dataConnector === void 0 ? void 0 : dataConnector.executionContext) === null || _b === void 0 ? void 0 : _b.epochTimestamp) {
-                            const extended = (0, utils_1.extendOHLCV)(transformedData, lookback, ((_c = dataConnector === null || dataConnector === void 0 ? void 0 : dataConnector.executionContext) === null || _c === void 0 ? void 0 : _c.epochTimestamp) * 1000);
-                            transformedData = extended;
-                        }
-                    }
-                }
-                transformationData.push(transformedData);
-            }
-            return transformationData;
-        });
-    }
-    getAverageBlockTime(provider, blockCount = 5) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const latestBlock = yield provider.getBlock('latest');
-            if (latestBlock) {
-                const startBlockNumber = Math.max(0, latestBlock.number - blockCount + 1);
-                let totalTimeDiff = 0;
-                let previousBlock = yield provider.getBlock(startBlockNumber);
-                if (!previousBlock) {
-                    return 0;
-                }
-                for (let i = startBlockNumber + 1; i <= latestBlock.number; i++) {
-                    const currentBlock = yield provider.getBlock(i);
-                    if (!currentBlock || !previousBlock || !currentBlock.timestamp || !previousBlock.timestamp) {
-                        continue;
-                    }
-                    const timeDiff = currentBlock.timestamp - previousBlock.timestamp;
-                    totalTimeDiff += timeDiff;
-                    previousBlock = currentBlock;
-                }
-                const averageBlockTime = totalTimeDiff / (blockCount - 1);
-                return averageBlockTime;
-            }
-            else {
-                return 0;
-            }
-        });
-    }
-    getBlockNumberFromAvgBlockTime(provider, targetTimestamp, avgBlockTime) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const latestBlock = yield provider.getBlock('latest');
-            const currentTime = Math.floor(Date.now() / 1000);
-            const timeDifference = currentTime - targetTimestamp;
-            if (!latestBlock) {
-                return 0;
-            }
-            if (avgBlockTime === 0) {
-                return latestBlock.number;
-            }
-            // Calculate the estimated number of blocks based on the average block time
-            const estimatedBlockCount = Math.floor(timeDifference / avgBlockTime);
-            // Calculate the estimated block number
-            const estimatedBlockNumber = latestBlock.number - estimatedBlockCount;
-            return Math.max(0, estimatedBlockNumber);
-        });
-    }
-    downloadWasmBundle(ipfsHash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield axios_1.default.get(`https://steerprotocol.mypinata.cloud/ipfs/${ipfsHash}`, {
-                responseType: 'arraybuffer',
-            });
-            const wasmFile = new Uint8Array(response.data);
-            return wasmFile;
-        });
-    }
-}
-exports.DataConnectorExecution = DataConnectorExecution;
+exports.ExecutionApp = exports.DataConnectorExecution = exports.DataConnector = void 0;
+const bundleDataConnector_1 = require("./bundle/bundleDataConnector");
+Object.defineProperty(exports, "DataConnector", { enumerable: true, get: function () { return bundleDataConnector_1.DataConnector; } });
+const executionDataConnector_1 = require("./execution/executionDataConnector");
+Object.defineProperty(exports, "DataConnectorExecution", { enumerable: true, get: function () { return executionDataConnector_1.DataConnectorExecution; } });
+const executionApp_1 = require("./execution/executionApp");
+Object.defineProperty(exports, "ExecutionApp", { enumerable: true, get: function () { return executionApp_1.ExecutionApp; } });

package/lib/loader/loaderBase.d.ts

@@ -0,0 +1,14 @@
+import { ethers } from 'ethers';
+import { DataConnector } from '../bundle/bundleDataConnector';
+import { VaultConfigPayload, ExecutionContext } from '../types';
+export declare class ExecutionBase {
+    maxRetries: number;
+    constructor(maxRetries?: number);
+    protected delay(ms: number): Promise<void>;
+    protected log(...args: any[]): void;
+    protected getExecutionContext(dataConnector: DataConnector, vaultConfig: VaultConfigPayload): Promise<ExecutionContext>;
+    execute<T>(_vaultConfig: string): Promise<Array<T>>;
+    protected getDataConnectorVersion(dataConnector: DataConnector): Promise<number>;
+    getAverageBlockTime(provider: ethers.providers.Provider, blockCount?: number): Promise<number>;
+    getBlockNumberFromAvgBlockTime(provider: ethers.providers.Provider, targetTimestamp: number, avgBlockTime: number): Promise<number>;
+}

package/lib/loader/loaderBase.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionBase = void 0;
+class ExecutionBase {
+    constructor(maxRetries = 3) {
+        this.maxRetries = 0;
+        this.maxRetries = maxRetries;
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    log(...args) {
+        if (process.env.DEBUG === 'true') {
+            console.log(...args);
+        }
+    }
+    getExecutionContext(dataConnector, vaultConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = dataConnector.getProvider({});
+            let blockTime = 0;
+            let blockNumber = 9;
+            if (provider) {
+                blockTime = yield this.getAverageBlockTime(provider);
+                blockNumber = yield this.getBlockNumberFromAvgBlockTime(provider, vaultConfig.epochTimestamp / 1000, // convert to seconds
+                blockNumber);
+            }
+            const context = {
+                executionTimestamp: new Date().getTime(),
+                epochTimestamp: vaultConfig.epochTimestamp,
+                epochLength: Number(vaultConfig.strategyConfigData.epochLength),
+                vaultAddress: vaultConfig.vaultAddress,
+                blockTime: blockTime,
+                blockNumber: blockNumber,
+            };
+            return context;
+        });
+    }
+    execute(_vaultConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Not implemented');
+        });
+    }
+    getDataConnectorVersion(dataConnector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let version = 1;
+            try {
+                version = yield dataConnector.version();
+            }
+            catch (e) {
+                // Data connector is missing version function, fallback to v1 logic
+            }
+            return version;
+        });
+    }
+    getAverageBlockTime(provider, blockCount = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latestBlock = yield provider.getBlock('latest');
+            if (latestBlock) {
+                const startBlockNumber = Math.max(0, latestBlock.number - blockCount + 1);
+                let totalTimeDiff = 0;
+                let previousBlock = yield provider.getBlock(startBlockNumber);
+                if (!previousBlock) {
+                    return 0;
+                }
+                for (let i = startBlockNumber + 1; i <= latestBlock.number; i++) {
+                    const currentBlock = yield provider.getBlock(i);
+                    if (!currentBlock || !previousBlock || !currentBlock.timestamp || !previousBlock.timestamp) {
+                        continue;
+                    }
+                    const timeDiff = currentBlock.timestamp - previousBlock.timestamp;
+                    totalTimeDiff += timeDiff;
+                    previousBlock = currentBlock;
+                }
+                const averageBlockTime = totalTimeDiff / (blockCount - 1);
+                return averageBlockTime;
+            }
+            else {
+                return 0;
+            }
+        });
+    }
+    getBlockNumberFromAvgBlockTime(provider, targetTimestamp, avgBlockTime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latestBlock = yield provider.getBlock('latest');
+            const currentTime = Math.floor(Date.now() / 1000);
+            const timeDifference = currentTime - targetTimestamp;
+            if (!latestBlock) {
+                return 0;
+            }
+            if (avgBlockTime === 0) {
+                return latestBlock.number;
+            }
+            // Calculate the estimated number of blocks based on the average block time
+            const estimatedBlockCount = Math.floor(timeDifference / avgBlockTime);
+            // Calculate the estimated block number
+            const estimatedBlockNumber = latestBlock.number - estimatedBlockCount;
+            return Math.max(0, estimatedBlockNumber);
+        });
+    }
+}
+exports.ExecutionBase = ExecutionBase;

package/lib/types.d.ts

@@ -1,3 +1,4 @@
+import { ContractInterface } from "ethers";
 export type VaultInput = {
     _id?: string;
     tokenId: string;
@@ -55,6 +56,16 @@ export interface ExecutionContext {
     blockNumber: number;
     epochTimestamp: number;
 }
+export interface Position {
+    startTick: number;
+    endTick: number;
+    weight: number;
+}
+export interface SmartPoolExecutionContext extends ExecutionContext {
+    positions: Position[];
+    currentTick: number;
+    lastExecutionTime: number;
+}
 export type RpcConfig = {
     url: string;
     network?: string;
@@ -62,3 +73,31 @@ export type RpcConfig = {
 export type EtherRpcConfig = {
     [key: string]: RpcConfig;
 };
+export interface ViewConfig {
+    address: string;
+    abi: ContractInterface;
+    method: string;
+    arguments: unknown[];
+}
+export interface Slot0 {
+    sqrtPriceX96?: bigint;
+    tick: number;
+    observationIndex?: number;
+    observationCardinality?: number;
+    observationCardinalityNext?: number;
+    feeProtocol?: number;
+    unlocked: boolean;
+    price?: bigint;
+    prevInitializedTick?: number;
+    fee?: number;
+    timepointIndex?: number;
+    communityFee?: number;
+}
+export type ViewContractConfig = {
+    epochTimestamp?: number;
+    address: string;
+    abi: any;
+    arguments: Array<any>;
+    method: string;
+    rpcUrl?: string;
+};

package/lib/utils/blockFinder.d.ts

@@ -0,0 +1,8 @@
+import { ethers } from 'ethers';
+/**
+ * Iterates down from current block to find the block previous or equal to the given timestamp
+ * Not the most efficient for far past timestamps, a binary search could be used for better performance
+ * @param timestamp
+ * @param Idenity
+ */
+export declare function getBlockFromTimestamp(timestamp: number, provider: ethers.providers.Provider): Promise<number>;

package/lib/utils/blockFinder.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlockFromTimestamp = void 0;
+// import { providers,  } from "ethers";
+/**
+ * Iterates down from current block to find the block previous or equal to the given timestamp
+ * Not the most efficient for far past timestamps, a binary search could be used for better performance
+ * @param timestamp
+ * @param Idenity
+ */
+function getBlockFromTimestamp(timestamp, provider) {
+    var _a, _b;
+    return __awaiter(this, void 0, void 0, function* () {
+        let currentBlock = (yield provider.getBlockNumber()) - 1;
+        let runningTimestamp = (_a = (yield provider.getBlock(currentBlock))) === null || _a === void 0 ? void 0 : _a.timestamp;
+        if (!runningTimestamp)
+            return currentBlock;
+        while (runningTimestamp > timestamp) {
+            currentBlock -= 1;
+            runningTimestamp = (_b = (yield provider.getBlock(currentBlock))) === null || _b === void 0 ? void 0 : _b.timestamp;
+            if (!runningTimestamp)
+                return currentBlock;
+        }
+        return currentBlock;
+    });
+}
+exports.getBlockFromTimestamp = getBlockFromTimestamp;

package/lib/utils/consts.d.ts

@@ -0,0 +1,4 @@
+export declare const API_BASE_URL = "https://cvrlulno2m.execute-api.ap-southeast-1.amazonaws.com/dev/contract-view-call";
+export declare const API_MAX_RETRIES = 3;
+export declare const API_INITIAL_DELAY = 1000;
+export declare const CENTRALIZE_CONTRACT_INTERACTION_CHAINS: string[];

package/lib/utils/consts.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CENTRALIZE_CONTRACT_INTERACTION_CHAINS = exports.API_INITIAL_DELAY = exports.API_MAX_RETRIES = exports.API_BASE_URL = void 0;
+exports.API_BASE_URL = "https://cvrlulno2m.execute-api.ap-southeast-1.amazonaws.com/dev/contract-view-call";
+exports.API_MAX_RETRIES = 3;
+exports.API_INITIAL_DELAY = 1000;
+exports.CENTRALIZE_CONTRACT_INTERACTION_CHAINS = ["2222", "42161", "9001", "137", "56"];

package/lib/utils/pluginManager.d.ts

@@ -0,0 +1,11 @@
+import { AxiosRequestConfig } from 'axios';
+export declare class PluginManager {
+    private registeredPluginConfigs;
+    constructor();
+    registerFromPublicConfig(): Promise<void>;
+    registerPluginConfig(name: string, domain: string, headers: object): void;
+    private findMatchingPluginConfigs;
+    private interpolateEnvVars;
+    private interpolateHeaders;
+    process(config: AxiosRequestConfig): Promise<AxiosRequestConfig>;
+}

package/lib/utils/pluginManager.js

@@ -0,0 +1,84 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+const axios_1 = __importDefault(require("axios"));
+class PluginManager {
+    constructor() {
+        this.registeredPluginConfigs = [];
+    }
+    registerFromPublicConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data: dataConnectorPlugins } = yield axios_1.default.get('https://ro81h8hq6b.execute-api.us-east-1.amazonaws.com/data-connector-plugins');
+            for (const plugin of dataConnectorPlugins) {
+                this.registerPluginConfig(plugin.name, plugin.domain, plugin.headers);
+            }
+        });
+    }
+    registerPluginConfig(name, domain, headers) {
+        this.registeredPluginConfigs.push({ name, domain, headers });
+    }
+    findMatchingPluginConfigs(url) {
+        const matchingHeaders = {};
+        for (const pluginConfig of this.registeredPluginConfigs) {
+            if (url.includes(pluginConfig.domain)) {
+                Object.assign(matchingHeaders, pluginConfig.headers);
+            }
+        }
+        return matchingHeaders;
+    }
+    interpolateEnvVars(str) {
+        return str.replace(/\{\{(\w+)\}\}/g, (_match, envVar) => {
+            const envValue = process.env[envVar];
+            if (envValue === undefined) {
+                console.log(`Environment variable '${envVar}' not found.`);
+                return '';
+            }
+            return envValue;
+        });
+    }
+    interpolateHeaders(headers) {
+        const interpolatedHeaders = {};
+        for (const [key, value] of Object.entries(headers)) {
+            interpolatedHeaders[key] = typeof value === 'string' ? this.interpolateEnvVars(value) : value;
+        }
+        return interpolatedHeaders;
+    }
+    process(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!config.url) {
+                throw new Error('Request URL is not provided');
+            }
+            const matchingHeaders = this.findMatchingPluginConfigs(config.url);
+            const interpolatedHeaders = this.interpolateHeaders(matchingHeaders);
+            const updatedHeaders = Object.assign(Object.assign({}, config.headers), interpolatedHeaders);
+            const updatedConfig = Object.assign(Object.assign({}, config), { headers: updatedHeaders });
+            return updatedConfig;
+        });
+    }
+}
+exports.PluginManager = PluginManager;
+// // Usage example:
+// (async () => {
+//   const headerMerger = new PluginManager();
+//   headerMerger.registerPluginConfig('Example API', 'example.com', { 'X-Custom-Header': '{{MY_ENV_VAR}}' });
+//   process.env['MY_ENV_VAR'] = 'ExampleValue';
+//   const requestConfig: AxiosRequestConfig = {
+//     url: 'https://example.com/api/some-resource',
+//     method: 'GET',
+//   };
+//   const updatedRequestConfig = await headerMerger.process(requestConfig);
+//   const response = await axios(updatedRequestConfig);
+//   console.log(response.data);
+// })();

package/lib/utils/utils.d.ts

@@ -0,0 +1,16 @@
+import { Candle } from "@steerprotocol/app-loader";
+import { AxiosRequestConfig } from "axios";
+import { ExecutionContext, ViewContractConfig } from "../types";
+import { providers } from "ethers";
+export declare const extendOHLCV: (rawData: Candle[], period: number, endTimestamp: number) => Candle[];
+export declare function fetchData(request: AxiosRequestConfig, attempts: number): Promise<any>;
+export declare function readSlot0Contract({ address, abi, currentExecutionContext, functionName, provider, rpc, chainId }: {
+    address: string;
+    abi: any;
+    currentExecutionContext: ExecutionContext;
+    functionName: string;
+    provider: providers.Provider;
+    rpc: string;
+    chainId: number;
+}): Promise<any>;
+export declare function callWithRetry(config: ViewContractConfig): Promise<any>;