@steerprotocol/data-connector-loader 0.1.5 → 0.2.0

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerprotocol/data-connector-loader",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "App Loader for Steer Protocol",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",