@steerprotocol/data-connector-loader 0.1.5 → 1.0.0

package/lib/bundle/bundleBase.d.ts

@@ -0,0 +1,29 @@
+import { WasmModule } from '@steerprotocol/app-loader';
+import { providers } from 'ethers';
+import { EtherRpcConfig, ExecutionContext } from '../types';
+export declare class BundleBase {
+    module?: WasmModule;
+    protected wasmFile: ArrayBuffer | string;
+    protected config: string;
+    configObj: {
+        [key: string]: any;
+    };
+    protected etherRpcConfig?: EtherRpcConfig;
+    protected providerIdentity?: providers.Provider;
+    executionContext?: ExecutionContext & {
+        epochTimestamp: number;
+    };
+    protected scheduleEpochTimestamp: number | undefined;
+    constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: providers.Provider, etherRpcConfig?: EtherRpcConfig);
+    load(): Promise<WasmModule>;
+    loadSync(): WasmModule;
+    execute(response: string): Promise<string>;
+    executeBundle(data: Array<any>): Promise<string>;
+    setExecutionContextStrategyExecution(executionContext: ExecutionContext): void;
+    setExecutionContextDataConnector(executionContext: ExecutionContext): void;
+    protected executeModule(response: string): Promise<string>;
+    getProvider(config: any): providers.Provider | undefined;
+    getResults(): string;
+    version(): number;
+    private subtractDate;
+}

package/lib/{dataConnector.js → bundle/bundleBase.js}

@@ -9,11 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataConnector = void 0;
+exports.BundleBase = void 0;
 const app_loader_1 = require("@steerprotocol/app-loader");
 const ethers_1 = require("ethers");
-class DataConnector {
-    // Identity should come from the node's IdentityManager.wallet
+class BundleBase {
     constructor(wasmFile, _config, identity, etherRpcConfig) {
         this.wasmFile = wasmFile;
         this.config = _config;
@@ -30,25 +29,11 @@ class DataConnector {
         });
     }
     loadSync() {
-        if (typeof this.wasmFile === "string")
-            throw new Error("Cannot load module synchronously unless wasmFile is of type ArrayBuffer");
+        if (typeof this.wasmFile === 'string')
+            throw new Error('Cannot load module synchronously unless wasmFile is of type ArrayBuffer');
         this.module = (0, app_loader_1.loadWasmSync)(this.wasmFile, {});
         return this.module;
     }
-    reset() {
-        if (this.module && this.module["reset"]) {
-            this.module.reset();
-        }
-    }
-    setExecutionContext(executionContext) {
-        var _a;
-        // Determine the timestamp for epoch
-        const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
-        // Divide milliseconds data to seconds for transformation bundle
-        const timestampInSecs = Math.floor(timestamp / 1000);
-        this.executionContext = Object.assign(Object.assign({}, executionContext), { epochTimestamp: timestampInSecs });
-        (_a = this.module) === null || _a === void 0 ? void 0 : _a.initialize(JSON.stringify(Object.assign(Object.assign({}, JSON.parse(this.config)), { executionContext: this.executionContext })));
-    }
     execute(response) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.executionContext) {
@@ -70,6 +55,59 @@ class DataConnector {
             return yield this.module.execute(response);
         });
     }
+    executeBundle(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.executionContext) {
+                throw new Error('Execution context missing');
+            }
+            // If the module is not initialized, try to load it
+            if (!this.module) {
+                try {
+                    yield this.load();
+                }
+                catch (_a) {
+                    throw new Error('Module not initialized');
+                }
+            }
+            // If the module is still not initialized, throw an error
+            if (!this.module)
+                throw new Error('Module not initialized');
+            // Call the main function with the response
+            return this.module.execute(...data);
+        });
+    }
+    setExecutionContextStrategyExecution(executionContext) {
+        var _a;
+        // Determine the timestamp for epoch
+        const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
+        // Divide milliseconds data to seconds for transformation bundle
+        const timestampInSecs = Math.floor(timestamp / 1000);
+        this.executionContext = Object.assign(Object.assign({}, executionContext), { epochTimestamp: timestampInSecs });
+        const completeConfig = Object.assign(Object.assign({}, JSON.parse(this.config)), this.executionContext);
+        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
+        console.log('Complete execution config : ', completeConfig);
+        (_a = this.module) === null || _a === void 0 ? void 0 : _a.initialize(JSON.stringify(completeConfig));
+    }
+    setExecutionContextDataConnector(executionContext) {
+        var _a;
+        // Determine the timestamp for epoch
+        const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
+        // Divide milliseconds data to seconds for transformation bundle
+        const timestampInSecs = Math.floor(timestamp / 1000);
+        this.executionContext = Object.assign(Object.assign({}, executionContext), { epochTimestamp: timestampInSecs });
+        const completeConfig = Object.assign(Object.assign({}, JSON.parse(this.config)), { executionContext: this.executionContext });
+        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
+        console.log('Complete execution config : ', completeConfig);
+        (_a = this.module) === null || _a === void 0 ? void 0 : _a.initialize(JSON.stringify(completeConfig));
+    }
+    executeModule(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.module) {
+                throw new Error('Module not initialized');
+            }
+            return yield this.module.execute(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
@@ -86,34 +124,13 @@ class DataConnector {
             chainId = config.chainId;
         }
         if (chainId && this.etherRpcConfig && this.etherRpcConfig[chainId]) {
-            const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.etherRpcConfig[chainId].url);
+            const provider = new ethers_1.providers.JsonRpcProvider(this.etherRpcConfig[chainId].url);
             return provider;
         }
         else {
             return this.providerIdentity;
         }
     }
-    // Makes contract instance and calls, returns stringified result
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    view(config) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = 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}
-            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;
-        });
-    }
     getResults() {
         if (!this.module)
             throw new Error('Module not initialized');
@@ -130,4 +147,4 @@ class DataConnector {
         return date;
     }
 }
-exports.DataConnector = DataConnector;
+exports.BundleBase = BundleBase;

package/lib/bundle/bundleDataConnector.d.ts

@@ -0,0 +1,8 @@
+import { providers } from 'ethers';
+import { EtherRpcConfig, ViewConfig } from '../types';
+import { BundleBase } from './bundleBase';
+export declare class DataConnector extends BundleBase {
+    constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: providers.Provider, etherRpcConfig?: EtherRpcConfig);
+    getRpcUrl(config: any): string | undefined;
+    view(config: ViewConfig): Promise<string>;
+}

package/lib/bundle/bundleDataConnector.js

@@ -0,0 +1,73 @@
+"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.DataConnector = void 0;
+const ethers_1 = require("ethers");
+const consts_1 = require("../utils/consts");
+const utils_1 = require("../utils/utils");
+const bundleBase_1 = require("./bundleBase");
+class DataConnector extends bundleBase_1.BundleBase {
+    // Identity should come from the node's IdentityManager.wallet
+    constructor(wasmFile, _config, identity, etherRpcConfig) {
+        super(wasmFile, _config, identity, etherRpcConfig);
+    }
+    // get rpc url from configuration
+    getRpcUrl(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]) {
+            return this.etherRpcConfig[chainId].url;
+        }
+        else {
+            return undefined;
+        }
+    }
+    // Makes contract instance and calls, returns stringified result
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    view(config) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider(config);
+            if (!provider)
+                throw new Error('Provider not initialized');
+            const contract = new ethers_1.Contract(config.address, config.abi, provider);
+            // For formatting the parameters if needed
+            const paramsArray = config.arguments;
+            let result;
+            if (consts_1.CENTRALIZE_CONTRACT_INTERACTION_CHAINS.indexOf(this.configObj.chainId.toString()) === -1) {
+                result = yield contract[config.method](...paramsArray, {
+                    blockTag: (_a = this.executionContext) === null || _a === void 0 ? void 0 : _a.blockNumber,
+                }); //@note uncomment for deterministic blocks
+            }
+            else {
+                const viewContractConfig = {
+                    epochTimestamp: this.scheduleEpochTimestamp,
+                    address: this.configObj.address || config.address,
+                    abi: config.abi,
+                    arguments: paramsArray,
+                    method: config.method,
+                    rpcUrl: this.getRpcUrl(config),
+                };
+                result = yield (0, utils_1.callWithRetry)(viewContractConfig);
+            }
+            // This gets stringified before calling main
+            return result;
+        });
+    }
+}
+exports.DataConnector = DataConnector;

package/lib/esm/bundle/bundleBase.d.ts

@@ -0,0 +1,29 @@
+import { WasmModule } from '@steerprotocol/app-loader';
+import { providers } from 'ethers';
+import { EtherRpcConfig, ExecutionContext } from '../types';
+export declare class BundleBase {
+    module?: WasmModule;
+    protected wasmFile: ArrayBuffer | string;
+    protected config: string;
+    configObj: {
+        [key: string]: any;
+    };
+    protected etherRpcConfig?: EtherRpcConfig;
+    protected providerIdentity?: providers.Provider;
+    executionContext?: ExecutionContext & {
+        epochTimestamp: number;
+    };
+    protected scheduleEpochTimestamp: number | undefined;
+    constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: providers.Provider, etherRpcConfig?: EtherRpcConfig);
+    load(): Promise<WasmModule>;
+    loadSync(): WasmModule;
+    execute(response: string): Promise<string>;
+    executeBundle(data: Array<any>): Promise<string>;
+    setExecutionContextStrategyExecution(executionContext: ExecutionContext): void;
+    setExecutionContextDataConnector(executionContext: ExecutionContext): void;
+    protected executeModule(response: string): Promise<string>;
+    getProvider(config: any): providers.Provider | undefined;
+    getResults(): string;
+    version(): number;
+    private subtractDate;
+}

package/lib/esm/bundle/bundleBase.js

@@ -0,0 +1,127 @@
+import { loadWasm, loadWasmSync } from '@steerprotocol/app-loader';
+import { providers } from 'ethers';
+export class BundleBase {
+    constructor(wasmFile, _config, identity, etherRpcConfig) {
+        this.wasmFile = wasmFile;
+        this.config = _config;
+        this.configObj = JSON.parse(_config);
+        this.providerIdentity = identity;
+        this.etherRpcConfig = etherRpcConfig;
+    }
+    async load() {
+        const instance = await loadWasm(this.wasmFile, {});
+        this.module = instance;
+        this.module.initialize(this.config);
+        return this.module;
+    }
+    loadSync() {
+        if (typeof this.wasmFile === 'string')
+            throw new Error('Cannot load module synchronously unless wasmFile is of type ArrayBuffer');
+        this.module = loadWasmSync(this.wasmFile, {});
+        return this.module;
+    }
+    async execute(response) {
+        if (!this.executionContext) {
+            throw new Error('Execution context missing');
+        }
+        // If the module is not initialized, try to load it
+        if (!this.module) {
+            try {
+                await this.load();
+            }
+            catch {
+                throw new Error('Module not initialized');
+            }
+        }
+        // If the module is still not initialized, throw an error
+        if (!this.module)
+            throw new Error('Module not initialized');
+        // Call the main function with the response
+        return await this.module.execute(response);
+    }
+    async executeBundle(data) {
+        if (!this.executionContext) {
+            throw new Error('Execution context missing');
+        }
+        // If the module is not initialized, try to load it
+        if (!this.module) {
+            try {
+                await this.load();
+            }
+            catch {
+                throw new Error('Module not initialized');
+            }
+        }
+        // If the module is still not initialized, throw an error
+        if (!this.module)
+            throw new Error('Module not initialized');
+        // Call the main function with the response
+        return this.module.execute(...data);
+    }
+    setExecutionContextStrategyExecution(executionContext) {
+        // Determine the timestamp for epoch
+        const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
+        // Divide milliseconds data to seconds for transformation bundle
+        const timestampInSecs = Math.floor(timestamp / 1000);
+        this.executionContext = { ...executionContext, epochTimestamp: timestampInSecs };
+        const completeConfig = { ...JSON.parse(this.config), ...this.executionContext };
+        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
+        console.log('Complete execution config : ', completeConfig);
+        this.module?.initialize(JSON.stringify(completeConfig));
+    }
+    setExecutionContextDataConnector(executionContext) {
+        // Determine the timestamp for epoch
+        const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
+        // Divide milliseconds data to seconds for transformation bundle
+        const timestampInSecs = Math.floor(timestamp / 1000);
+        this.executionContext = { ...executionContext, epochTimestamp: timestampInSecs };
+        const completeConfig = { ...JSON.parse(this.config), executionContext: this.executionContext };
+        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
+        console.log('Complete execution config : ', completeConfig);
+        this.module?.initialize(JSON.stringify(completeConfig));
+    }
+    async executeModule(response) {
+        if (!this.module) {
+            throw new Error('Module not initialized');
+        }
+        return await this.module.execute(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
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    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 providers.JsonRpcProvider(this.etherRpcConfig[chainId].url);
+            return provider;
+        }
+        else {
+            return this.providerIdentity;
+        }
+    }
+    getResults() {
+        if (!this.module)
+            throw new Error('Module not initialized');
+        return this.module.transform();
+    }
+    version() {
+        if (!this.module)
+            throw new Error('Module not initialized');
+        return Number(this.module.version());
+    }
+    subtractDate(timestamp, epochLength) {
+        const date = new Date(timestamp);
+        date.setSeconds(date.getSeconds() - epochLength);
+        return date;
+    }
+}

package/lib/esm/bundle/bundleDataConnector.d.ts

@@ -0,0 +1,8 @@
+import { providers } from 'ethers';
+import { EtherRpcConfig, ViewConfig } from '../types';
+import { BundleBase } from './bundleBase';
+export declare class DataConnector extends BundleBase {
+    constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: providers.Provider, etherRpcConfig?: EtherRpcConfig);
+    getRpcUrl(config: any): string | undefined;
+    view(config: ViewConfig): Promise<string>;
+}

package/lib/esm/bundle/bundleDataConnector.js

@@ -0,0 +1,57 @@
+import { Contract } from 'ethers';
+import { CENTRALIZE_CONTRACT_INTERACTION_CHAINS } from '../utils/consts';
+import { callWithRetry } from '../utils/utils';
+import { BundleBase } from './bundleBase';
+export class DataConnector extends BundleBase {
+    // Identity should come from the node's IdentityManager.wallet
+    constructor(wasmFile, _config, identity, etherRpcConfig) {
+        super(wasmFile, _config, identity, etherRpcConfig);
+    }
+    // get rpc url from configuration
+    getRpcUrl(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]) {
+            return this.etherRpcConfig[chainId].url;
+        }
+        else {
+            return undefined;
+        }
+    }
+    // Makes contract instance and calls, returns stringified result
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async view(config) {
+        const provider = this.getProvider(config);
+        if (!provider)
+            throw new Error('Provider not initialized');
+        const contract = new Contract(config.address, config.abi, provider);
+        // For formatting the parameters if needed
+        const paramsArray = config.arguments;
+        let result;
+        if (CENTRALIZE_CONTRACT_INTERACTION_CHAINS.indexOf(this.configObj.chainId.toString()) === -1) {
+            result = await contract[config.method](...paramsArray, {
+                blockTag: this.executionContext?.blockNumber,
+            }); //@note uncomment for deterministic blocks
+        }
+        else {
+            const viewContractConfig = {
+                epochTimestamp: this.scheduleEpochTimestamp,
+                address: this.configObj.address || config.address,
+                abi: config.abi,
+                arguments: paramsArray,
+                method: config.method,
+                rpcUrl: this.getRpcUrl(config),
+            };
+            result = await callWithRetry(viewContractConfig);
+        }
+        // This gets stringified before calling main
+        return result;
+    }
+}

package/lib/esm/execution/executionApp.d.ts

@@ -0,0 +1,17 @@
+import { ethers } from 'ethers';
+import { EtherRpcConfig } from '../types';
+import { ExecutionBase } from './executionBase';
+export declare class ExecutionApp extends ExecutionBase {
+    steerSubgraph: string;
+    vault: string;
+    isAlgebraPool: boolean;
+    isDirectionalPool: boolean;
+    chainId: number;
+    constructor(vault: string, steerSubgraph: string, isAlgebraPool: boolean, isDirectionalPool: boolean, chainId: number, maxRetries?: number);
+    execute<T>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, _identity?: ethers.providers.Provider, _etherRpcConfig?: EtherRpcConfig): Promise<Array<T>>;
+    private getSmartPoolExecutionContext;
+    private getPoolCurrentTick;
+    private getVaultPoolAddress;
+    private getSlot0;
+    private getGlobalState;
+}