@steerprotocol/data-connector-loader 0.1.5 → 2.0.0

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

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": "2.0.0",
   "description": "App Loader for Steer Protocol",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -46,8 +46,8 @@
     "lib/**/*"
   ],
   "dependencies": {
-    "@steerprotocol/app-loader": "1.0.1",
-    "@steerprotocol/strategy-utils": "^3.1.1",
+    "@steerprotocol/app-loader": "1.1.0",
+    "@steerprotocol/strategy-utils": "^3.1.2",
     "axios": "^1.3.4",
     "ethers": "^5.1.0",
     "timestring": "^7.0.0"