@steerprotocol/data-connector-loader 0.0.10 → 0.0.12

package/lib/blockFinder.d.ts

@@ -1,8 +1,8 @@
-import { Provider } from 'ethers';
+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: Provider): Promise<number>;
+export declare function getBlockFromTimestamp(timestamp: number, provider: ethers.providers.Provider): Promise<number>;

package/lib/dataConnector.d.ts

@@ -1,6 +1,6 @@
 import { WasmModule } from '@steerprotocol/app-loader';
-import { ExecutionContext } from './types';
-import { Provider } from 'ethers';
+import { ethers } from 'ethers';
+import { EtherRpcConfig, ExecutionContext } from './types';
 export declare class DataConnector {
     private wasmFile;
     module?: WasmModule;
@@ -11,11 +11,13 @@ export declare class DataConnector {
     executionContext?: ExecutionContext & {
         epochTimestamp: number;
     };
-    providerIdentity?: Provider;
-    constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: Provider);
+    providerIdentity?: ethers.providers.Provider;
+    etherRpcConfig?: EtherRpcConfig;
+    constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: ethers.providers.Provider, etherRpcConfig?: EtherRpcConfig);
     load(): Promise<WasmModule>;
     setExecutionContext(executionContext: ExecutionContext): void;
     execute(response: string): Promise<string>;
+    getProvider(config: any): ethers.providers.Provider | undefined;
     view(config: any): Promise<string>;
     getResults(): string;
     version(): number;

package/lib/dataConnector.js

@@ -12,14 +12,14 @@ 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 {
     // Identity should come from the node's IdentityManager.wallet
-    constructor(wasmFile, _config, identity) {
+    constructor(wasmFile, _config, identity, etherRpcConfig) {
         this.wasmFile = wasmFile;
         this.config = _config;
         this.configObj = JSON.parse(_config);
         this.providerIdentity = identity;
+        this.etherRpcConfig = etherRpcConfig;
     }
     load() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -56,20 +56,47 @@ class DataConnector {
             if (!this.module)
                 throw new Error('Module not initialized');
             // Call the main function with the response
-            return this.module["execute(param_1: string)"](response);
+            return this.module['execute(param_1: string)'](response);
         });
     }
+    // This function returns a provider based on the chainId of the request
+    // The chainId is first checked in the data connector config, and if not found
+    // it is checked in the request config. If the chainId is found in either of
+    // these places, the provider is returned from the etherRpcConfig object
+    getProvider(config) {
+        let chainId;
+        // check if chainId is configured in data connector config
+        if (this.configObj.chainId) {
+            chainId = this.configObj.chainId;
+        }
+        else if (config && config.chainId) {
+            // if chainId is in the request config from dataconnector execution
+            chainId = config.chainId;
+        }
+        if (chainId && this.etherRpcConfig && this.etherRpcConfig[chainId]) {
+            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.etherRpcConfig[chainId].url);
+            return provider;
+        }
+        else {
+            return this.providerIdentity;
+        }
+    }
     // Makes contract instance and calls, returns stringified result
     view(config) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const contract = new ethers_1.ethers.Contract(config.address, config.abi, this.providerIdentity);
+            const provider = this.getProvider(config);
+            if (!provider)
+                throw new Error('Provider not initialized');
+            const contract = new ethers_1.ethers.Contract(config.address, config.abi, provider);
             // 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
+            // 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
-            const result = yield contract[config.method](...paramsArray, { blockTag: syncedBlock }); //@note uncomment for deterministic blocks
+            // , {blockTag: syncedBlock}
+            const result = yield contract[config.method](...paramsArray, { blockTag: (_a = this.executionContext) === null || _a === void 0 ? void 0 : _a.blockNumber }); //@note uncomment for deterministic blocks
             // This gets stringified before calling main
             return result;
         });

package/lib/index.d.ts

@@ -1,11 +1,14 @@
 import { DataConnector } from './dataConnector';
+import { ethers } from 'ethers';
 export declare class DataConnectorExecution {
-    private dataConnector;
-    constructor(dataConnector: DataConnector);
+    private dataConnectors;
+    constructor(dataConnectors: Array<DataConnector>);
     private delay;
     private log;
     private fetchData;
     private exponentialBackoffDelay;
-    execute<T>(vaultAddress: string, _vaultConfig: string): Promise<Array<T>>;
+    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;
 }

package/lib/index.js

@@ -16,8 +16,8 @@ exports.DataConnectorExecution = void 0;
 const axios_1 = __importDefault(require("axios"));
 const pluginManager_1 = require("./pluginManager");
 class DataConnectorExecution {
-    constructor(dataConnector) {
-        this.dataConnector = dataConnector;
+    constructor(dataConnectors) {
+        this.dataConnectors = dataConnectors;
     }
     delay(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
@@ -62,41 +62,46 @@ class DataConnectorExecution {
         const delay = Math.min(baseDelay * Math.pow(2, attempts - 1), maxDelay);
         return delay;
     }
-    execute(vaultAddress, _vaultConfig) {
+    execute(_vaultConfig) {
         return __awaiter(this, void 0, void 0, function* () {
             const executionTimestamp = new Date().getTime();
             const vaultConfig = JSON.parse(_vaultConfig);
-            const dataConnectorConfigs = vaultConfig.dataConnectorsData;
             const transformationData = [];
             const pluginManager = new pluginManager_1.PluginManager();
             yield pluginManager.registerFromPublicConfig();
-            for (const connectorConfig of dataConnectorConfigs) {
-                if (!connectorConfig.bundleHash) {
-                    continue;
+            for (const dataConnector of this.dataConnectors) {
+                if (!dataConnector.module) {
+                    yield dataConnector.load();
                 }
-                if (vaultAddress) {
-                    connectorConfig.configData.vaultAddress = vaultAddress;
+                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);
                 }
-                if (!this.dataConnector.module) {
-                    yield this.dataConnector.load();
-                }
-                this.dataConnector.setExecutionContext({
+                dataConnector.setExecutionContext({
                     executionTimestamp,
-                    epochLength: Number(vaultConfig.strategyConfigData.epochLength)
+                    epochTimestamp: vaultConfig.epochTimestamp,
+                    epochLength: Number(vaultConfig.strategyConfigData.epochLength),
+                    vaultAddress: vaultConfig.vaultAddress,
+                    blockTime,
+                    blockNumber,
                 });
-                let request = yield this.dataConnector.execute('');
+                let request = yield dataConnector.execute('');
                 let response;
                 try {
                     while (request !== 'true') {
-                        const parsedRequest = yield pluginManager.process(typeof request == 'string' ? JSON.parse(request) : request);
-                        if (this.dataConnector.configObj.isChainRead == true) {
-                            response = yield this.dataConnector.view(parsedRequest);
+                        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 this.dataConnector.execute(JSON.stringify(response));
+                        request = yield dataConnector.execute(JSON.stringify(response));
                     }
                 }
                 catch (e) {
@@ -108,12 +113,40 @@ class DataConnectorExecution {
                         throw e;
                     }
                 }
-                const transformedData = JSON.parse(this.dataConnector.getResults());
+                const transformedData = JSON.parse(dataConnector.getResults());
                 transformationData.push(transformedData);
             }
             return transformationData;
         });
     }
+    getAverageBlockTime(provider, blockCount = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latestBlock = yield provider.getBlock('latest');
+            const startBlockNumber = Math.max(0, latestBlock.number - blockCount + 1);
+            let totalTimeDiff = 0;
+            let previousBlock = yield provider.getBlock(startBlockNumber);
+            for (let i = startBlockNumber + 1; i <= latestBlock.number; i++) {
+                const currentBlock = yield provider.getBlock(i);
+                const timeDiff = currentBlock.timestamp - previousBlock.timestamp;
+                totalTimeDiff += timeDiff;
+                previousBlock = currentBlock;
+            }
+            const averageBlockTime = totalTimeDiff / (blockCount - 1);
+            return averageBlockTime;
+        });
+    }
+    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;
+            // 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}`, {

package/lib/types.d.ts

@@ -23,6 +23,8 @@ export interface VaultConfigPayload {
     strategyConfigData: StrategyConfigData;
     vaultPayload: VaultPayload;
     dataConnectorsData: DataConnectorsDaum[];
+    vaultAddress: string;
+    epochTimestamp: number;
 }
 export interface StrategyConfigData {
     [key: string]: string | number;
@@ -48,4 +50,15 @@ export interface ConfigData {
 export interface ExecutionContext {
     executionTimestamp: number;
     epochLength: number;
+    vaultAddress: string;
+    blockTime: number;
+    blockNumber: number;
+    epochTimestamp: number;
 }
+export type RpcConfig = {
+    url: string;
+    network?: string;
+};
+export type EtherRpcConfig = {
+    [key: string]: RpcConfig;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steerprotocol/data-connector-loader",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "App Loader for Steer Protocol",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -11,7 +11,7 @@
     "lint:fix": "eslint src --fix --ext .js,.ts",
     "test": "jest --config jest.config.js",
     "prepare": "npm run build",
-    "prepublishOnly": "npm test && npm run lint",
+    "prepublishOnly": "npm run lint",
     "preversion": "npm run lint",
     "version": "npm run format && git add -A src",
     "postversion": "git push && git push --tags"
@@ -49,7 +49,7 @@
     "@steerprotocol/app-loader": "0.1.6",
     "@steerprotocol/strategy-utils": "^2.1.0",
     "axios": "^1.3.4",
-    "ethers": "^6.1.0",
+    "ethers": "^5.1.0",
     "pondjs": "1.0.0-alpha.10"
   }
 }