@steerprotocol/data-connector-loader 5.0.0-next.2 → 5.0.0-next.4

package/lib/execution/executionBase.d.ts

@@ -1,14 +1,14 @@
-import type { ethers } from 'ethers';
-import type { DataConnector } from '../bundle/bundleDataConnector.js';
-import type { EtherRpcConfig, LegacyExecutionContext, VaultConfigPayload } from '../types.js';
+import type { PublicClient } from "viem";
+import type { DataConnector } from "../bundle/bundleDataConnector.js";
+import type { ExecutionContext, RpcAccess, VaultConfigPayload } from "../types.js";
 export declare class ExecutionBase {
     maxRetries: number;
     constructor(maxRetries?: number);
     protected delay(ms: number): Promise<void>;
     protected log(...args: Array<any>): void;
-    protected getExecutionContext(dataConnector: DataConnector, vaultConfig: VaultConfigPayload): Promise<LegacyExecutionContext>;
-    execute<T>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, _identity?: ethers.Provider, _etherRpcConfig?: EtherRpcConfig): Promise<Array<T>>;
+    protected getExecutionContext(dataConnector: DataConnector, vaultConfig: VaultConfigPayload): Promise<ExecutionContext>;
+    execute<T>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, rpc?: RpcAccess): Promise<Array<T>>;
     protected getDataConnectorVersion(dataConnector: DataConnector): Promise<number>;
-    getAverageBlockTime(provider: ethers.Provider, blockCount?: number): Promise<number>;
-    getBlockNumberFromAvgBlockTime(provider: ethers.Provider, targetTimestamp: number, avgBlockTime: number): Promise<number>;
+    getAverageBlockTime(provider: PublicClient, blockCount?: number): Promise<number>;
+    getBlockNumberFromAvgBlockTime(provider: PublicClient, targetTimestamp: number, avgBlockTime: number): Promise<number>;
 }

package/lib/execution/executionBase.js

@@ -19,13 +19,19 @@ class ExecutionBase {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
     log(...args) {
-        if (process.env.DEBUG === 'true') {
+        if (process.env.DEBUG === "true") {
             console.log(...args);
         }
     }
     getExecutionContext(dataConnector, vaultConfig) {
         return __awaiter(this, void 0, void 0, function* () {
-            const provider = dataConnector.getProvider({});
+            const chainId = dataConnector.executionAppConfig.chainId;
+            if (!Number.isSafeInteger(chainId))
+                throw new Error("Invalid execution chain ID");
+            const provider = dataConnector.getClient();
+            if (provider && (yield provider.getChainId()) !== chainId) {
+                throw new Error("EXECUTION_CONTEXT_MISMATCH: provider chain does not match supplied context.");
+            }
             let blockTime = 0;
             let blockNumber = 9;
             // Use anchorBlockNumber if provided, otherwise calculate from average block time
@@ -41,6 +47,7 @@ class ExecutionBase {
                 blockNumber);
             }
             const context = {
+                chainId,
                 executionTimestamp: new Date().getTime(),
                 epochTimestamp: vaultConfig.epochTimestamp,
                 epochLength: Number(vaultConfig.strategyConfigData.epochLength),
@@ -51,9 +58,9 @@ class ExecutionBase {
             return context;
         });
     }
-    execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig) {
+    execute(_wasmFile, _vaultConfig, _data, rpc) {
         return __awaiter(this, void 0, void 0, function* () {
-            throw new Error('Not implemented');
+            throw new Error("Not implemented");
         });
     }
     getDataConnectorVersion(dataConnector) {
@@ -70,20 +77,27 @@ class ExecutionBase {
     }
     getAverageBlockTime(provider, blockCount = 5) {
         return __awaiter(this, void 0, void 0, function* () {
-            const latestBlock = yield provider.getBlock('latest');
+            const latestBlock = yield provider.getBlock({ blockTag: "latest" });
             if (latestBlock) {
-                const startBlockNumber = Math.max(0, latestBlock.number - blockCount + 1);
+                const startBlockNumber = Math.max(0, Number(latestBlock.number) - blockCount + 1);
                 let totalTimeDiff = 0;
-                let previousBlock = yield provider.getBlock(startBlockNumber);
+                let previousBlock = yield provider.getBlock({
+                    blockNumber: BigInt(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) {
+                    const currentBlock = yield provider.getBlock({
+                        blockNumber: BigInt(i),
+                    });
+                    if (!currentBlock ||
+                        !previousBlock ||
+                        !currentBlock.timestamp ||
+                        !previousBlock.timestamp) {
                         continue;
                     }
-                    const timeDiff = currentBlock.timestamp - previousBlock.timestamp;
+                    const timeDiff = Number(currentBlock.timestamp - previousBlock.timestamp);
                     totalTimeDiff += timeDiff;
                     previousBlock = currentBlock;
                 }
@@ -97,19 +111,19 @@ class ExecutionBase {
     }
     getBlockNumberFromAvgBlockTime(provider, targetTimestamp, avgBlockTime) {
         return __awaiter(this, void 0, void 0, function* () {
-            const latestBlock = yield provider.getBlock('latest');
+            const latestBlock = yield provider.getBlock({ blockTag: "latest" });
             const currentTime = Math.floor(Date.now() / 1000);
             const timeDifference = currentTime - targetTimestamp;
             if (!latestBlock) {
                 return 0;
             }
             if (avgBlockTime === 0) {
-                return latestBlock.number;
+                return Number(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;
+            const estimatedBlockNumber = Number(latestBlock.number) - estimatedBlockCount;
             return Math.max(0, estimatedBlockNumber);
         });
     }

package/lib/execution/executionDataConnector.d.ts

@@ -1,6 +1,6 @@
-import type { DataConnector } from '../bundle/bundleDataConnector.js';
-import { type ExecutionContext } from '../types.js';
-import { ExecutionBase } from './executionBase.js';
+import type { DataConnector } from "../bundle/bundleDataConnector.js";
+import { type ExecutionContext } from "../types.js";
+import { ExecutionBase } from "./executionBase.js";
 export declare class DataConnectorExecution extends ExecutionBase {
     private dataConnectors;
     constructor(dataConnectors: Array<DataConnector>, maxRetries?: number);
@@ -12,6 +12,9 @@ export declare class DataConnectorExecution extends ExecutionBase {
      */
     executeWithContext<T>(_vaultConfig: string, context: ExecutionContext): Promise<Array<T>>;
     private executeV2Bundle;
+    private getConnectorVersion;
+    private executeInitializedV2Bundle;
+    private executeV1Bundle;
     executeDynamicJob<T>(_vaultConfig: string): Promise<Array<T>>;
     private handleRequestResponse;
     private transformData;

package/lib/execution/executionDataConnector.js

@@ -8,10 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.DataConnectorExecution = void 0;
+const axios_1 = __importDefault(require("axios"));
 const types_js_1 = require("../types.js");
-const pluginManager_js_1 = require("../utils/pluginManager.js");
 const replace_old_subgraphs_js_1 = require("../utils/replace-old-subgraphs.js");
 const utils_js_1 = require("../utils/utils.js");
 const executionBase_js_1 = require("./executionBase.js");
@@ -24,39 +27,16 @@ class DataConnectorExecution extends executionBase_js_1.ExecutionBase {
         return __awaiter(this, void 0, void 0, function* () {
             const vaultConfig = JSON.parse(_vaultConfig);
             const transformationData = [];
-            const pluginManager = new pluginManager_js_1.PluginManager();
-            yield pluginManager.registerFromPublicConfig();
             for (const dataConnector of this.dataConnectors) {
-                if (!dataConnector.module) {
+                if (!dataConnector.module)
                     yield dataConnector.load();
-                }
-                let version = 1;
-                try {
-                    version = dataConnector.version();
-                }
-                catch (e) {
-                    version = 1;
-                }
-                if (version >= 2) {
-                    const transformData = yield this.executeV2Bundle(dataConnector, vaultConfig);
-                    transformationData.push(transformData);
+                if (this.getConnectorVersion(dataConnector) >= 2) {
+                    transformationData.push(yield this.executeV2Bundle(dataConnector, vaultConfig));
                 }
                 else {
-                    try {
-                        const executionContext = yield this.getExecutionContext(dataConnector, vaultConfig);
-                        dataConnector.setExecutionContextDataConnector(executionContext);
-                        const initialRequest = yield dataConnector.execute();
-                        if (initialRequest === null) {
-                            throw new Error('Data connector returned null request');
-                        }
-                        const finalResponse = yield this.handleRequestResponse(dataConnector, pluginManager, initialRequest);
-                        const transformedData = yield this.transformData(dataConnector, finalResponse);
-                        transformationData.push(transformedData);
-                    }
-                    catch (e) {
-                        const transformData = yield this.executeV2Bundle(dataConnector, vaultConfig);
-                        transformationData.push(transformData);
-                    }
+                    const executionContext = yield this.getExecutionContext(dataConnector, vaultConfig);
+                    dataConnector.setExecutionContextDataConnector(executionContext);
+                    transformationData.push(yield this.executeV1Bundle(dataConnector));
                 }
             }
             return transformationData;
@@ -82,34 +62,45 @@ class DataConnectorExecution extends executionBase_js_1.ExecutionBase {
                 context.executionTimestamp !== context.epochTimestamp * 1000 ||
                 !Number.isFinite(context.epochLength) ||
                 !Number.isFinite(context.blockTime) ||
-                typeof context.vaultAddress !== 'string' ||
+                typeof context.vaultAddress !== "string" ||
                 context.vaultAddress.length === 0) {
-                throw new Error('INVALID_EXECUTION_CONTEXT: supplied execution context is malformed.');
+                throw new Error("INVALID_EXECUTION_CONTEXT: supplied execution context is malformed.");
             }
-            if (context.vaultAddress.toLowerCase() !== vaultConfig.vaultAddress.toLowerCase()) {
-                throw new Error('EXECUTION_CONTEXT_MISMATCH: supplied context vault does not match vaultConfig.vaultAddress.');
+            if (context.vaultAddress.toLowerCase() !==
+                vaultConfig.vaultAddress.toLowerCase()) {
+                throw new Error("EXECUTION_CONTEXT_MISMATCH: supplied context vault does not match vaultConfig.vaultAddress.");
             }
             const requestChainId = vaultConfig.chainId;
             if (requestChainId !== undefined && requestChainId !== context.chainId) {
-                throw new Error('EXECUTION_CONTEXT_MISMATCH: supplied context chain does not match vaultConfig.chainId.');
+                throw new Error("EXECUTION_CONTEXT_MISMATCH: supplied context chain does not match vaultConfig.chainId.");
             }
             if (vaultConfig.anchorBlockNumber !== undefined &&
                 String(vaultConfig.anchorBlockNumber) !== String(context.blockNumber)) {
-                throw new Error('EXECUTION_CONTEXT_MISMATCH: supplied context block does not match anchorBlockNumber.');
+                throw new Error("EXECUTION_CONTEXT_MISMATCH: supplied context block does not match anchorBlockNumber.");
             }
-            if (Number((_a = vaultConfig.strategyConfigData) === null || _a === void 0 ? void 0 : _a.epochLength) !== context.epochLength) {
-                throw new Error('EXECUTION_CONTEXT_MISMATCH: supplied context epoch length does not match vaultConfig.');
+            if (Number((_a = vaultConfig.strategyConfigData) === null || _a === void 0 ? void 0 : _a.epochLength) !==
+                context.epochLength) {
+                throw new Error("EXECUTION_CONTEXT_MISMATCH: supplied context epoch length does not match vaultConfig.");
             }
+            const pinnedContext = Object.freeze(Object.assign({}, context));
             const transformationData = [];
             for (const dataConnector of this.dataConnectors) {
-                if (dataConnector.executionAppConfig.chainId !== context.chainId) {
-                    throw new Error('EXECUTION_CONTEXT_MISMATCH: supplied context chain does not match connector configuration.');
+                if (dataConnector.executionAppConfig.chainId !== pinnedContext.chainId) {
+                    throw new Error("EXECUTION_CONTEXT_MISMATCH: supplied context chain does not match connector configuration.");
+                }
+                if (dataConnector.configObj.chainId !== undefined &&
+                    Number(dataConnector.configObj.chainId) !== pinnedContext.chainId) {
+                    throw new Error("EXECUTION_CONTEXT_MISMATCH: supplied context chain does not match connector settings.");
                 }
                 if (!dataConnector.module)
                     yield dataConnector.load();
-                dataConnector.initializeDataConnectorWithContext(context);
-                yield dataConnector.execute();
-                transformationData.push(JSON.parse(yield dataConnector.transform()));
+                dataConnector.initializeDataConnectorWithContext(pinnedContext);
+                if (this.getConnectorVersion(dataConnector) >= 2) {
+                    transformationData.push(yield this.executeInitializedV2Bundle(dataConnector));
+                }
+                else {
+                    transformationData.push(yield this.executeV1Bundle(dataConnector, pinnedContext));
+                }
             }
             return transformationData;
         });
@@ -118,17 +109,39 @@ class DataConnectorExecution extends executionBase_js_1.ExecutionBase {
         return __awaiter(this, void 0, void 0, function* () {
             const executionContext = yield this.getExecutionContext(dataConnector, vaultConfig);
             dataConnector.setExecutionContextDataConnector(executionContext);
+            return this.executeInitializedV2Bundle(dataConnector);
+        });
+    }
+    getConnectorVersion(dataConnector) {
+        var _a;
+        if (typeof ((_a = dataConnector.module) === null || _a === void 0 ? void 0 : _a.version) !== "function")
+            return 1;
+        const version = dataConnector.version();
+        if (!Number.isInteger(version) || version < 1)
+            throw new Error("Invalid data connector version");
+        return version;
+    }
+    executeInitializedV2Bundle(dataConnector) {
+        return __awaiter(this, void 0, void 0, function* () {
             yield dataConnector.execute();
-            const result = yield dataConnector.transform();
-            return JSON.parse(result);
+            return JSON.parse(yield dataConnector.transform());
+        });
+    }
+    executeV1Bundle(dataConnector, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const initialRequest = yield dataConnector.execute("");
+            if (initialRequest === null)
+                throw new Error("Data connector returned null request");
+            const result = yield this.handleRequestResponse(dataConnector, initialRequest, context);
+            if (context)
+                return typeof result === "string" ? JSON.parse(result) : result;
+            return this.transformData(dataConnector, result);
         });
     }
     executeDynamicJob(_vaultConfig) {
         return __awaiter(this, void 0, void 0, function* () {
             const vaultConfig = JSON.parse(_vaultConfig);
             const transformationData = [];
-            const pluginManager = new pluginManager_js_1.PluginManager();
-            yield pluginManager.registerFromPublicConfig();
             for (const dataConnector of this.dataConnectors) {
                 if (!dataConnector.module) {
                     yield dataConnector.load();
@@ -142,40 +155,79 @@ class DataConnectorExecution extends executionBase_js_1.ExecutionBase {
             return transformationData;
         });
     }
-    handleRequestResponse(dataConnector, pluginManager, initialRequest) {
+    handleRequestResponse(dataConnector, initialRequest, context) {
         return __awaiter(this, void 0, void 0, function* () {
             let request = initialRequest;
             let response;
             try {
-                while (request !== 'true') {
-                    if (dataConnector.configObj.isChainRead == true) {
-                        response = yield dataConnector.view(JSON.parse(request));
+                while (request !== "true") {
+                    if (dataConnector.configObj.isChainRead === true) {
+                        const view = JSON.parse(request);
+                        if (context &&
+                            view.chainId !== undefined &&
+                            Number(view.chainId) !== context.chainId) {
+                            throw new Error("EXECUTION_CONTEXT_MISMATCH: contract request chain does not match supplied context.");
+                        }
+                        response = yield dataConnector.view(view);
                     }
                     else {
-                        const parsedRequest = yield pluginManager.process(typeof request == 'string' ? JSON.parse(request) : request);
+                        let parsedRequest = typeof request === "string" ? JSON.parse(request) : request;
                         const url = (0, replace_old_subgraphs_js_1.changeUrlIfOld)(parsedRequest.url, dataConnector.configObj.subgraphStudioKey);
                         parsedRequest.url = url;
-                        parsedRequest.headers = Object.assign({ 'Content-Type': url && !url.includes('subgraph-proxy-server') ? 'application/json' : 'text/plain;charset=UTF-8' }, ((url === null || url === void 0 ? void 0 : url.includes('sentio')) ? { 'api-key': dataConnector.executionAppConfig.apiKeys.sentioApiKey } : {}));
+                        let sentio = false;
+                        try {
+                            const destination = new URL(axios_1.default.getUri(parsedRequest));
+                            const hostname = destination.hostname.toLowerCase();
+                            sentio =
+                                destination.protocol === "https:" &&
+                                    (hostname === "sentio.xyz" || hostname.endsWith(".sentio.xyz"));
+                        }
+                        catch (_a) {
+                            /* Axios will report an invalid URL when sending the request. */
+                        }
+                        parsedRequest.headers = Object.assign(Object.assign({ "Content-Type": url && !url.includes("subgraph-proxy-server")
+                                ? "application/json"
+                                : "text/plain;charset=UTF-8" }, (sentio
+                            ? {
+                                "api-key": dataConnector.executionAppConfig.apiKeys.sentioApiKey,
+                            }
+                            : {})), parsedRequest.headers);
+                        if (sentio) {
+                            const { url, baseURL, method, params, data, headers, timeout, responseType, allowAbsoluteUrls, } = parsedRequest;
+                            parsedRequest = {
+                                url,
+                                baseURL,
+                                method,
+                                params,
+                                data,
+                                headers,
+                                timeout,
+                                responseType,
+                                allowAbsoluteUrls,
+                                proxy: false,
+                                maxRedirects: 0,
+                            };
+                        }
                         yield this.delay(1000);
                         try {
                             response = yield (0, utils_js_1.fetchData)(parsedRequest, 0);
                         }
                         catch (error) {
                             const message = error instanceof Error ? error.message : String(error);
-                            throw new types_js_1.DataConnectorTransportError(message.replace(/https?:\/\/[^\s@/]+(?::[^\s@/]+)?@/gi, 'https://[REDACTED]@'));
+                            throw new types_js_1.DataConnectorTransportError(message.replace(/https?:\/\/[^\s@/]+(?::[^\s@/]+)?@/gi, "https://[REDACTED]@"));
                         }
                     }
-                    const nextRequest = yield dataConnector.execute(JSON.stringify(response));
+                    const nextRequest = yield dataConnector.execute(JSON.stringify(response, (_key, value) => typeof value === "bigint" ? value.toString() : value));
                     if (nextRequest === null) {
-                        throw new Error('Data connector returned null request');
+                        throw new Error("Data connector returned null request");
                     }
                     request = nextRequest;
                 }
             }
             catch (e) {
                 // process.env.SILENT_ERRORS
-                if (process.env.DATA_LOADER_SILENT_ERRORS !== 'true') {
-                    console.error('Data connector failed to process.', e);
+                if (process.env.DATA_LOADER_SILENT_ERRORS !== "true") {
+                    console.error("Data connector failed to process.", e);
                 }
                 throw e;
             }
@@ -185,15 +237,16 @@ class DataConnectorExecution extends executionBase_js_1.ExecutionBase {
     transformData(dataConnector, rawData) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            let transformedData = typeof rawData === 'string' ? JSON.parse(rawData) : rawData;
-            const version = yield this.getDataConnectorVersion(dataConnector);
-            if (version == 1 && transformedData.length > 0) {
+            let transformedData = typeof rawData === "string" ? JSON.parse(rawData) : rawData;
+            if (Array.isArray(transformedData) &&
+                transformedData.length > 0 &&
+                transformedData[0] != null) {
                 const keys = Object.keys(transformedData[0]);
-                const requiredKeys = ['timestamp', 'open', 'high', 'low', 'close'];
+                const requiredKeys = ["timestamp", "open", "high", "low", "close"];
                 const hasAllKeys = requiredKeys.every((key) => keys.includes(key));
                 // has the 'lookback' key
                 const lookback = (_a = dataConnector === null || dataConnector === void 0 ? void 0 : dataConnector.configObj) === null || _a === void 0 ? void 0 : _a.lookback;
-                if (hasAllKeys && !!lookback) {
+                if (hasAllKeys && lookback) {
                     // Now that we have identified a v1 data connector, we need to transform the data so that the data is up to the current execution epoch timestamp
                     if ((_b = dataConnector === null || dataConnector === void 0 ? void 0 : dataConnector.executionContext) === null || _b === void 0 ? void 0 : _b.epochTimestamp) {
                         const extended = (0, utils_js_1.extendOHLCV)(transformedData, lookback, ((_c = dataConnector === null || dataConnector === void 0 ? void 0 : dataConnector.executionContext) === null || _c === void 0 ? void 0 : _c.epochTimestamp) * 1000);

package/lib/index.d.ts

@@ -1,8 +1,8 @@
-import { DataConnector } from './bundle/bundleDataConnector.js';
-import { ExecutionApp, type ExecutionAppConfig } from './execution/executionApp.js';
-import { DataConnectorExecution } from './execution/executionDataConnector.js';
-import type { ExecuteWithContextOptions, VaultConfigPayload } from './types.js';
-export type * from './types.js';
+import { DataConnector } from "./bundle/bundleDataConnector.js";
+import { ExecutionApp, type ExecutionAppConfig } from "./execution/executionApp.js";
+import { DataConnectorExecution } from "./execution/executionDataConnector.js";
+import type { ExecuteWithContextOptions, VaultConfigPayload } from "./types.js";
+export type * from "./types.js";
+export { DataConnectorTransportError, ExecutionContextError, StrategyExecutionError, } from "./types.js";
+export type { ExecuteWithContextOptions, ExecutionAppConfig, VaultConfigPayload, };
 export { DataConnector, DataConnectorExecution, ExecutionApp };
-export { DataConnectorTransportError, ExecutionContextError, StrategyExecutionError } from './types.js';
-export type { ExecuteWithContextOptions, ExecutionAppConfig, VaultConfigPayload };

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StrategyExecutionError = exports.ExecutionContextError = exports.DataConnectorTransportError = exports.ExecutionApp = exports.DataConnectorExecution = exports.DataConnector = void 0;
+exports.ExecutionApp = exports.DataConnectorExecution = exports.DataConnector = exports.StrategyExecutionError = exports.ExecutionContextError = exports.DataConnectorTransportError = void 0;
 const bundleDataConnector_js_1 = require("./bundle/bundleDataConnector.js");
 Object.defineProperty(exports, "DataConnector", { enumerable: true, get: function () { return bundleDataConnector_js_1.DataConnector; } });
 const executionApp_js_1 = require("./execution/executionApp.js");

package/lib/types.d.ts

@@ -1,8 +1,9 @@
-import type { ethers, InterfaceAbi } from 'ethers';
+import type { Abi, PublicClient } from "viem";
+import type { ExecutionAppConfig } from "./execution/executionApp.js";
 /** Error raised before a strategy is invoked when its supplied SDK anchor is unusable. */
 export declare class ExecutionContextError extends Error {
-    readonly code: 'INVALID_EXECUTION_CONTEXT' | 'EXECUTION_CONTEXT_MISMATCH';
-    constructor(code: ExecutionContextError['code'], message: string);
+    readonly code: "INVALID_EXECUTION_CONTEXT" | "EXECUTION_CONTEXT_MISMATCH";
+    constructor(code: ExecutionContextError["code"], message: string);
 }
 /** Error classification for failures in a connector transport request. */
 export declare class DataConnectorTransportError extends Error {
@@ -21,8 +22,6 @@ export interface ExecuteWithContextOptions {
     data: Array<unknown>;
     /** Resolved strategy execution context. */
     executionContext: SmartPoolExecutionContext;
-    identity?: ethers.Provider;
-    etherRpcConfig?: EtherRpcConfig;
     forceDeposit?: boolean;
 }
 export type VaultInput = {
@@ -84,8 +83,6 @@ export interface ExecutionContext {
     blockNumber: number;
     epochTimestamp: number;
 }
-/** Context produced by legacy execution paths, which may not have a chain binding. */
-export type LegacyExecutionContext = Omit<ExecutionContext, 'chainId'> & Partial<Pick<ExecutionContext, 'chainId'>>;
 export interface Position {
     startTick: number;
     endTick: number;
@@ -99,17 +96,25 @@ export interface SmartPoolExecutionContext extends ExecutionContext {
     totalAmount1: string;
     tickSpacing: number;
 }
-export type RpcConfig = {
-    url: string;
-    urls?: ReadonlyArray<string>;
-    network?: string;
-};
-export type EtherRpcConfig = {
-    [key: string]: RpcConfig;
+/** RPC access for one execution chain. URL endpoints are validated individually. */
+export type RpcAccess = {
+    client: PublicClient;
+    urls?: never;
+} | {
+    urls: readonly string[];
+    client?: never;
 };
+export interface DataConnectorOptions {
+    wasmFile: string | ArrayBuffer;
+    config: string;
+    executionConfig: ExecutionAppConfig;
+    rpc?: RpcAccess;
+}
+export type ContractAbi = Abi | readonly string[] | string;
 export interface ViewConfig {
+    chainId?: number;
     address: string;
-    abi: InterfaceAbi;
+    abi: ContractAbi;
     method: string;
     arguments: Array<unknown>;
 }
@@ -127,15 +132,6 @@ export interface Slot0 {
     timepointIndex?: number;
     communityFee?: number;
 }
-export type ViewContractConfig = {
-    epochTimestamp?: number;
-    blockNumber?: number;
-    address: string;
-    abi: any;
-    arguments: Array<any>;
-    method: string;
-    rpcUrl?: string;
-};
 export type JobDetails = {
     id: string;
     name: string;

package/lib/types.js

@@ -5,7 +5,7 @@ exports.StrategyExecutionError = exports.DataConnectorTransportError = exports.E
 class ExecutionContextError extends Error {
     constructor(code, message) {
         super(message);
-        this.name = 'ExecutionContextError';
+        this.name = "ExecutionContextError";
         this.code = code;
     }
 }
@@ -14,8 +14,8 @@ exports.ExecutionContextError = ExecutionContextError;
 class DataConnectorTransportError extends Error {
     constructor(message) {
         super(message);
-        this.code = 'DATA_CONNECTOR_TRANSPORT_ERROR';
-        this.name = 'DataConnectorTransportError';
+        this.code = "DATA_CONNECTOR_TRANSPORT_ERROR";
+        this.name = "DataConnectorTransportError";
     }
 }
 exports.DataConnectorTransportError = DataConnectorTransportError;
@@ -23,8 +23,8 @@ exports.DataConnectorTransportError = DataConnectorTransportError;
 class StrategyExecutionError extends Error {
     constructor(message) {
         super(message);
-        this.code = 'STRATEGY_EXECUTION_ERROR';
-        this.name = 'StrategyExecutionError';
+        this.code = "STRATEGY_EXECUTION_ERROR";
+        this.name = "StrategyExecutionError";
     }
 }
 exports.StrategyExecutionError = StrategyExecutionError;

package/lib/utils/blockFinder.d.ts

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

package/lib/utils/blockFinder.js

@@ -19,13 +19,13 @@ exports.getBlockFromTimestamp = void 0;
 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;
+        let currentBlock = Number(yield provider.getBlockNumber()) - 1;
+        let runningTimestamp = (_a = (yield provider.getBlock({ blockNumber: BigInt(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;
+            runningTimestamp = (_b = (yield provider.getBlock({ blockNumber: BigInt(currentBlock) }))) === null || _b === void 0 ? void 0 : _b.timestamp;
             if (!runningTimestamp)
                 return currentBlock;
         }