@steerprotocol/data-connector-loader 0.0.1 → 0.0.3

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

@@ -53,13 +53,14 @@ class DataConnectorExecution {
                 while (request != 'true') {
                     const parsedRequest = 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerprotocol/data-connector-loader",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "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.0.9",
+    "@steerprotocol/app-loader": "0.1.6",
     "@steerprotocol/strategy-utils": "^2.1.0",
     "axios": "^1.3.2",
-    "ethers": "^6.0.3",
+    "ethers": "^6.1.0",
     "pondjs": "1.0.0-alpha.10"
   }
 }