@steerprotocol/data-connector-loader 0.1.5 → 2.0.0

package/lib/base/bundleBase.d.ts

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

package/lib/base/bundleBase.js

@@ -0,0 +1,119 @@
+"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.BundleBase = void 0;
+const app_loader_1 = require("@steerprotocol/app-loader");
+const ethers_1 = require("ethers");
+class BundleBase {
+    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* () {
+            const instance = yield (0, app_loader_1.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 = (0, app_loader_1.loadWasmSync)(this.wasmFile, {});
+        return this.module;
+    }
+    execute(response) {
+        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 yield this.module.execute(response);
+        });
+    }
+    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 })));
+    }
+    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
+    // 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 ethers_1.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;
+    }
+}
+exports.BundleBase = BundleBase;

package/lib/base/loaderBase.d.ts

@@ -0,0 +1,14 @@
+import { ethers } from 'ethers';
+import { DataConnector } from '../bundleDataConnector';
+import { VaultConfigPayload, ExecutionContext } from '../types';
+export declare class ExecutionBase {
+    maxRetries: number;
+    constructor(maxRetries?: number);
+    protected delay(ms: number): Promise<void>;
+    protected log(...args: any[]): void;
+    protected getExecutionContext(dataConnector: DataConnector, vaultConfig: VaultConfigPayload): Promise<ExecutionContext>;
+    execute<T>(_vaultConfig: string): Promise<Array<T>>;
+    private getDataConnectorVersion;
+    getAverageBlockTime(provider: ethers.providers.Provider, blockCount?: number): Promise<number>;
+    getBlockNumberFromAvgBlockTime(provider: ethers.providers.Provider, targetTimestamp: number, avgBlockTime: number): Promise<number>;
+}

package/lib/base/loaderBase.js

@@ -0,0 +1,111 @@
+"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.ExecutionBase = void 0;
+class ExecutionBase {
+    constructor(maxRetries = 3) {
+        this.maxRetries = 0;
+        this.maxRetries = maxRetries;
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    log(...args) {
+        if (process.env.DEBUG === 'true') {
+            console.log(...args);
+        }
+    }
+    getExecutionContext(dataConnector, vaultConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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
+                blockNumber);
+            }
+            const context = {
+                executionTimestamp: new Date().getTime(),
+                epochTimestamp: vaultConfig.epochTimestamp,
+                epochLength: Number(vaultConfig.strategyConfigData.epochLength),
+                vaultAddress: vaultConfig.vaultAddress,
+                blockTime: blockTime,
+                blockNumber: blockNumber,
+            };
+            return context;
+        });
+    }
+    execute(_vaultConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Not implemented');
+        });
+    }
+    getDataConnectorVersion(dataConnector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let version = 1;
+            try {
+                version = yield dataConnector.version();
+            }
+            catch (e) {
+                // Data connector is missing version function, fallback to v1 logic
+            }
+            return version;
+        });
+    }
+    getAverageBlockTime(provider, blockCount = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latestBlock = yield provider.getBlock('latest');
+            if (latestBlock) {
+                const startBlockNumber = Math.max(0, latestBlock.number - blockCount + 1);
+                let totalTimeDiff = 0;
+                let previousBlock = yield provider.getBlock(startBlockNumber);
+                if (!previousBlock) {
+                    return 0;
+                }
+                for (let i = startBlockNumber + 1; i <= latestBlock.number; i++) {
+                    const currentBlock = yield provider.getBlock(i);
+                    if (!currentBlock || !previousBlock || !currentBlock.timestamp || !previousBlock.timestamp) {
+                        continue;
+                    }
+                    const timeDiff = currentBlock.timestamp - previousBlock.timestamp;
+                    totalTimeDiff += timeDiff;
+                    previousBlock = currentBlock;
+                }
+                const averageBlockTime = totalTimeDiff / (blockCount - 1);
+                return averageBlockTime;
+            }
+            else {
+                return 0;
+            }
+        });
+    }
+    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;
+            if (!latestBlock) {
+                return 0;
+            }
+            if (avgBlockTime === 0) {
+                return latestBlock.number;
+            }
+            // 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);
+        });
+    }
+}
+exports.ExecutionBase = ExecutionBase;

package/lib/bundle/bundleApp.d.ts

@@ -0,0 +1,6 @@
+import { providers } from 'ethers';
+import { BundleBase } from './bundleBase';
+import { EtherRpcConfig } from '../types';
+export declare class AppBundle extends BundleBase {
+    constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: providers.Provider, etherRpcConfig?: EtherRpcConfig);
+}

package/lib/bundle/bundleApp.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppBundle = void 0;
+const bundleBase_1 = require("./bundleBase");
+class AppBundle extends bundleBase_1.BundleBase {
+    // Identity should come from the node's IdentityManager.wallet
+    constructor(wasmFile, _config, identity, etherRpcConfig) {
+        super(wasmFile, _config, identity, etherRpcConfig);
+    }
+}
+exports.AppBundle = AppBundle;

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/bundle/bundleBase.js

@@ -0,0 +1,150 @@
+"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.BundleBase = void 0;
+const app_loader_1 = require("@steerprotocol/app-loader");
+const ethers_1 = require("ethers");
+class BundleBase {
+    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* () {
+            const instance = yield (0, app_loader_1.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 = (0, app_loader_1.loadWasmSync)(this.wasmFile, {});
+        return this.module;
+    }
+    execute(response) {
+        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 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
+    // 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 ethers_1.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;
+    }
+}
+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/bundle/bundleExecution.d.ts

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

package/lib/bundle/bundleExecution.js

@@ -0,0 +1,42 @@
+"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 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);
+    }
+    // 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;
+            // 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;
+        });
+    }
+}
+exports.DataConnector = DataConnector;

package/lib/bundleDataConnector.d.ts

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

package/lib/bundleDataConnector.js

@@ -0,0 +1,42 @@
+"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 bundleBase_1 = require("./base/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);
+    }
+    // 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;
+            // 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;
+        });
+    }
+}
+exports.DataConnector = DataConnector;