@steerprotocol/data-connector-loader 0.1.5 → 1.0.0

package/lib/execution/executionDataConnector.d.ts

@@ -0,0 +1,9 @@
+import { ExecutionBase } from './executionBase';
+import { DataConnector } from '../bundle/bundleDataConnector';
+export declare class DataConnectorExecution extends ExecutionBase {
+    private dataConnectors;
+    constructor(dataConnectors: Array<DataConnector>, maxRetries?: number);
+    execute<T>(_vaultConfig: string): Promise<Array<T>>;
+    private handleRequestResponse;
+    private transformData;
+}

package/lib/execution/executionDataConnector.js

@@ -0,0 +1,110 @@
+"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.DataConnectorExecution = void 0;
+const executionBase_1 = require("./executionBase");
+const pluginManager_1 = require("../utils/pluginManager");
+const utils_1 = require("../utils/utils");
+class DataConnectorExecution extends executionBase_1.ExecutionBase {
+    constructor(dataConnectors, maxRetries = 3) {
+        super(maxRetries);
+        this.dataConnectors = dataConnectors;
+    }
+    execute(_vaultConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 executionContext = yield this.getExecutionContext(dataConnector, vaultConfig);
+                dataConnector.setExecutionContextDataConnector(executionContext);
+                const version = yield this.getDataConnectorVersion(dataConnector);
+                if (version === 1) {
+                    const initialRequest = yield dataConnector.execute('');
+                    const finalResponse = yield this.handleRequestResponse(dataConnector, pluginManager, initialRequest);
+                    const transformedData = yield this.transformData(dataConnector, finalResponse);
+                    transformationData.push(transformedData);
+                }
+                else {
+                    const finalResponse = yield dataConnector.execute('');
+                    const transformedData = yield this.transformData(dataConnector, finalResponse);
+                    transformationData.push(transformedData);
+                }
+            }
+            return transformationData;
+        });
+    }
+    handleRequestResponse(dataConnector, pluginManager, initialRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let request = initialRequest;
+            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 (0, utils_1.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;
+            }
+            return dataConnector.getResults();
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    transformData(dataConnector, rawData) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let transformedData = typeof rawData === 'string' ? JSON.parse(rawData) : rawData;
+            if (transformedData == null || transformedData.length == 0) {
+                const results = dataConnector.getResults();
+                const parsedResults = JSON.parse(results);
+                if (parsedResults.length == null) {
+                    transformedData = results;
+                }
+                else {
+                    transformedData = parsedResults;
+                }
+            }
+            const version = yield this.getDataConnectorVersion(dataConnector);
+            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;
+                    }
+                }
+            }
+            return transformedData;
+        });
+    }
+}
+exports.DataConnectorExecution = DataConnectorExecution;

package/lib/index.d.ts

@@ -1,15 +1,5 @@
-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 * from './types';
+export { DataConnector, DataConnectorExecution, ExecutionApp };

package/lib/index.js

@@ -1,200 +1,24 @@
 "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 };
+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.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; } });
+__exportStar(require("./types"), exports);

package/lib/types.d.ts

@@ -1,3 +1,4 @@
+import { ContractInterface } from 'ethers';
 export type VaultInput = {
     _id?: string;
     tokenId: string;
@@ -25,6 +26,7 @@ export interface VaultConfigPayload {
     dataConnectorsData: DataConnectorsDaum[];
     vaultAddress: string;
     epochTimestamp: number;
+    anchorBlockNumber?: number;
 }
 export interface StrategyConfigData {
     [key: string]: string | number;
@@ -55,6 +57,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 +74,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/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/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>;

package/lib/utils/utils.js

@@ -0,0 +1,146 @@
+"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.callWithRetry = exports.readSlot0Contract = exports.fetchData = exports.extendOHLCV = void 0;
+const axios_1 = __importDefault(require("axios"));
+const ethers_1 = require("ethers");
+const consts_1 = require("./consts");
+// The purpose of this function is to look at the end timestamp and extend the current candle array so that it backfills any missing candles up to the end timestamp
+const extendOHLCV = (rawData, period, endTimestamp) => {
+    // Sort rawData by timestamp
+    const sortedData = rawData.sort((a, b) => a.timestamp - b.timestamp);
+    const lastCandle = sortedData[sortedData.length - 1];
+    const startTimestamp = lastCandle ? lastCandle.timestamp : endTimestamp;
+    // Calculate the number of periods to backfill
+    const periodsToBackfill = Math.floor((endTimestamp - startTimestamp) / 1000 / period);
+    // Backfill the candles
+    for (let i = 0; i < periodsToBackfill; i++) {
+        const candleWidth = period * (i + 1);
+        const newCandle = {
+            timestamp: startTimestamp + candleWidth,
+            open: lastCandle.open,
+            high: lastCandle.open,
+            low: lastCandle.open,
+            close: lastCandle.open,
+            volume: 0, // You may need to replace these with appropriate logic
+        };
+        sortedData.push(newCandle);
+    }
+    // Return the converted data
+    return sortedData;
+};
+exports.extendOHLCV = extendOHLCV;
+function delay(ms) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    });
+}
+function 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;
+}
+function fetchData(request, attempts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 delay(exponentialBackoffDelay(attempts));
+                    return yield fetchData(request, attempts);
+                }
+                else {
+                    throw new Error('Maximum retry attempts reached');
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            if (attempts < 3) {
+                yield delay(exponentialBackoffDelay(attempts));
+                return yield fetchData(request, attempts);
+            }
+            else {
+                throw error;
+            }
+        }
+    });
+}
+exports.fetchData = fetchData;
+function readSlot0Contract({ address, abi, currentExecutionContext, functionName, provider, rpc, chainId, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Create a new contract instance
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (!provider)
+            throw new Error('Provider not initialized');
+        const contract = new ethers_1.Contract(address, abi, provider);
+        // For formatting the parameters if needed
+        const paramsArray = [];
+        // Calculate block number for determinism
+        // Best way to handle contextually non-null values?
+        // const syncedBlock = await getBlockFromTimestamp(this.executionContext!.epochTimestamp, this.providerIdentity!) //@note uncomment for deterministic blocks
+        // Call the desired method with the specified arguments at synced block
+        // , {blockTag: syncedBlock}
+        let result;
+        if (consts_1.CENTRALIZE_CONTRACT_INTERACTION_CHAINS.indexOf(chainId.toString()) === -1) {
+            result = yield contract[functionName](...paramsArray, {
+                blockTag: currentExecutionContext === null || currentExecutionContext === void 0 ? void 0 : currentExecutionContext.blockNumber,
+            }); //@note uncomment for deterministic blocks
+        }
+        else {
+            const viewContractConfig = {
+                epochTimestamp: currentExecutionContext.epochTimestamp,
+                address: address,
+                abi: abi,
+                arguments: paramsArray,
+                method: functionName,
+                rpcUrl: rpc,
+            };
+            result = yield callWithRetry(viewContractConfig);
+        }
+        // This gets stringified before calling main
+        return result;
+    });
+}
+exports.readSlot0Contract = readSlot0Contract;
+function callWithRetry(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let retries = 0;
+        let delay = consts_1.API_INITIAL_DELAY;
+        while (retries < consts_1.API_MAX_RETRIES) {
+            try {
+                const response = yield axios_1.default.post(consts_1.API_BASE_URL, config);
+                return JSON.parse(response.data); // Return the data if the call was successful
+            }
+            catch (error) {
+                console.error(`Attempt ${retries + 1} failed. Retrying in to fetch the contract method ${config.method} ${delay / 1000} seconds...`);
+                yield new Promise((resolve) => setTimeout(resolve, delay));
+                delay *= 2; // Double the delay for the next retry
+                retries++;
+            }
+        }
+        throw new Error(`Failed after ${consts_1.API_MAX_RETRIES} attempts. to call method ${config.method}`);
+    });
+}
+exports.callWithRetry = callWithRetry;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function log(...args) {
+    if (process.env.DEBUG === 'true') {
+        console.log(...args);
+    }
+}