@steerprotocol/data-connector-loader 0.0.2 → 0.0.4

package/lib/blockFinder.d.ts

@@ -0,0 +1,8 @@
+import { Provider } 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: Provider): Promise<number>;

package/lib/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/dataConnector.d.ts

@@ -1,19 +1,22 @@
 import { WasmModule } from '@steerprotocol/app-loader';
 import { ExecutionContext } from './types';
+import { Provider } from 'ethers';
 export declare class DataConnector {
     private wasmFile;
     module?: WasmModule;
     config: string;
     configObj: {
-        [key: string]: string;
+        [key: string]: any;
     };
     executionContext?: ExecutionContext & {
         epochTimestamp: number;
     };
-    constructor(wasmFile: string | ArrayBuffer, _config: string);
+    providerIdentity?: Provider;
+    constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: Provider);
     load(): Promise<WasmModule>;
     setExecutionContext(executionContext: ExecutionContext): void;
     execute(response: string): Promise<string>;
+    view(config: any): Promise<string>;
     getResults(): string;
     version(): number;
     private subtractDate;

package/lib/dataConnector.js

@@ -11,11 +11,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataConnector = void 0;
 const app_loader_1 = require("@steerprotocol/app-loader");
+const ethers_1 = require("ethers");
+const blockFinder_1 = require("./blockFinder");
 class DataConnector {
-    constructor(wasmFile, _config) {
+    // Identity should come from the node's IdentityManager.wallet
+    constructor(wasmFile, _config, identity) {
         this.wasmFile = wasmFile;
         this.config = _config;
         this.configObj = JSON.parse(_config);
+        this.providerIdentity = identity;
     }
     load() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -52,21 +56,24 @@ class DataConnector {
             if (!this.module)
                 throw new Error('Module not initialized');
             // Call the main function with the response
-            return this.module.execute(response);
+            return this.module["execute(param_1: string)"](response);
         });
     }
     // Makes contract instance and calls, returns stringified result
-    //   public async view(config: any): Promise<string> {
-    //     const contract = new Contract(config.address, config.abi, this.identityManager.wallet);
-    //     // For formatting the parameters if needed
-    //     const paramsArray = config.arguments;
-    //     // Calculate block number for determinism
-    //     // const syncedBlock = await getBlockFromTimestamp(this.timestamp,this.identityManager) //@note uncomment for deterministic blocks
-    //     // Call the desired method with the specified arguements at synced block
-    //     const result = await contract[config.method](...paramsArray); //, {blockTag: syncedBlock}) //@note uncomment for deterministic blocks
-    //     // This gets stringified before calling main
-    //     return result;
-    //   }
+    view(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = new ethers_1.ethers.Contract(config.address, config.abi, this.providerIdentity);
+            // For formatting the parameters if needed
+            const paramsArray = config.arguments;
+            // Calculate block number for determinism
+            // Best way to handle contextually non-null values?
+            const syncedBlock = yield (0, blockFinder_1.getBlockFromTimestamp)(this.executionContext.epochTimestamp, this.providerIdentity); //@note uncomment for deterministic blocks
+            // Call the desired method with the specified arguments at synced block
+            const result = yield contract[config.method](...paramsArray, { blockTag: syncedBlock }); //@note uncomment for deterministic blocks
+            // This gets stringified before calling main
+            return result;
+        });
+    }
     getResults() {
         if (!this.module)
             throw new Error('Module not initialized');

package/lib/index.js

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataConnectorExecution = void 0;
 const axios_1 = __importDefault(require("axios"));
+const pluginManager_1 = require("./pluginManager");
 class DataConnectorExecution {
     constructor(dataConnector) {
         this.dataConnector = dataConnector;
@@ -29,6 +30,8 @@ class DataConnectorExecution {
             // Each data connector results will be pushed into single array
             // they will passed to execution bundle
             const transformationData = [];
+            const pluginManager = new pluginManager_1.PluginManager();
+            yield pluginManager.registerFromPublicConfig();
             // Iterate over each data connector
             for (const connectorConfig of dataConnectorConfigs) {
                 // If bundle hash is not present, skip the data connector
@@ -51,15 +54,16 @@ class DataConnectorExecution {
                 let request = yield this.dataConnector.execute('');
                 let response;
                 while (request != 'true') {
-                    const parsedRequest = JSON.parse(request);
+                    const parsedRequest = yield pluginManager.process(JSON.parse(request));
                     // On Chain
-                    // if (this.dataConnector.configObj.isChainRead == true) {
-                    //   response = await this.dataConnector.view(parsedRequest);
-                    // } else {
-                    // Axios logic (off-chain)
-                    const ax_instance = axios_1.default.create();
-                    response = (yield ax_instance.request(parsedRequest)).data;
-                    // }
+                    if (this.dataConnector.configObj.isChainRead == true) {
+                        response = yield this.dataConnector.view(parsedRequest);
+                    }
+                    else {
+                        // Axios logic (off-chain)
+                        const ax_instance = axios_1.default.create();
+                        response = (yield ax_instance.request(parsedRequest)).data;
+                    }
                     // break;
                     request = yield this.dataConnector.execute(JSON.stringify(response));
                 }

package/lib/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/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://igk02ovpui.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerprotocol/data-connector-loader",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "App Loader for Steer Protocol",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -46,10 +46,10 @@
     "lib/**/*"
   ],
   "dependencies": {
-    "@steerprotocol/app-loader": "^0.1.0",
+    "@steerprotocol/app-loader": "0.1.6",
     "@steerprotocol/strategy-utils": "^2.1.0",
-    "axios": "^1.3.2",
-    "ethers": "^6.0.3",
+    "axios": "^1.3.4",
+    "ethers": "^6.1.0",
     "pondjs": "1.0.0-alpha.10"
   }
 }