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

package/lib/esm/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/esm/execution/executionBase.js

@@ -7,12 +7,18 @@ export class ExecutionBase {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
     log(...args) {
-        if (process.env.DEBUG === 'true') {
+        if (process.env.DEBUG === "true") {
             console.log(...args);
         }
     }
     async getExecutionContext(dataConnector, vaultConfig) {
-        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 && (await 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
@@ -28,6 +34,7 @@ export class ExecutionBase {
             blockNumber);
         }
         const context = {
+            chainId,
             executionTimestamp: new Date().getTime(),
             epochTimestamp: vaultConfig.epochTimestamp,
             epochLength: Number(vaultConfig.strategyConfigData.epochLength),
@@ -37,8 +44,8 @@ export class ExecutionBase {
         };
         return context;
     }
-    async execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig) {
-        throw new Error('Not implemented');
+    async execute(_wasmFile, _vaultConfig, _data, rpc) {
+        throw new Error("Not implemented");
     }
     async getDataConnectorVersion(dataConnector) {
         let version = 1;
@@ -51,20 +58,27 @@ export class ExecutionBase {
         return version;
     }
     async getAverageBlockTime(provider, blockCount = 5) {
-        const latestBlock = await provider.getBlock('latest');
+        const latestBlock = await 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 = await provider.getBlock(startBlockNumber);
+            let previousBlock = await provider.getBlock({
+                blockNumber: BigInt(startBlockNumber),
+            });
             if (!previousBlock) {
                 return 0;
             }
             for (let i = startBlockNumber + 1; i <= latestBlock.number; i++) {
-                const currentBlock = await provider.getBlock(i);
-                if (!currentBlock || !previousBlock || !currentBlock.timestamp || !previousBlock.timestamp) {
+                const currentBlock = await 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;
             }
@@ -76,19 +90,19 @@ export class ExecutionBase {
         }
     }
     async getBlockNumberFromAvgBlockTime(provider, targetTimestamp, avgBlockTime) {
-        const latestBlock = await provider.getBlock('latest');
+        const latestBlock = await 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/esm/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/esm/execution/executionDataConnector.js

@@ -1,8 +1,8 @@
-import { DataConnectorTransportError } from '../types.js';
-import { PluginManager } from '../utils/pluginManager.js';
-import { changeUrlIfOld } from '../utils/replace-old-subgraphs.js';
-import { extendOHLCV, fetchData } from '../utils/utils.js';
-import { ExecutionBase } from './executionBase.js';
+import axios from "axios";
+import { DataConnectorTransportError, } from "../types.js";
+import { changeUrlIfOld } from "../utils/replace-old-subgraphs.js";
+import { extendOHLCV, fetchData } from "../utils/utils.js";
+import { ExecutionBase } from "./executionBase.js";
 export class DataConnectorExecution extends ExecutionBase {
     constructor(dataConnectors, maxRetries = 3) {
         super(maxRetries);
@@ -11,39 +11,16 @@ export class DataConnectorExecution extends ExecutionBase {
     async execute(_vaultConfig) {
         const vaultConfig = JSON.parse(_vaultConfig);
         const transformationData = [];
-        const pluginManager = new PluginManager();
-        await pluginManager.registerFromPublicConfig();
         for (const dataConnector of this.dataConnectors) {
-            if (!dataConnector.module) {
+            if (!dataConnector.module)
                 await dataConnector.load();
-            }
-            let version = 1;
-            try {
-                version = dataConnector.version();
-            }
-            catch (e) {
-                version = 1;
-            }
-            if (version >= 2) {
-                const transformData = await this.executeV2Bundle(dataConnector, vaultConfig);
-                transformationData.push(transformData);
+            if (this.getConnectorVersion(dataConnector) >= 2) {
+                transformationData.push(await this.executeV2Bundle(dataConnector, vaultConfig));
             }
             else {
-                try {
-                    const executionContext = await this.getExecutionContext(dataConnector, vaultConfig);
-                    dataConnector.setExecutionContextDataConnector(executionContext);
-                    const initialRequest = await dataConnector.execute();
-                    if (initialRequest === null) {
-                        throw new Error('Data connector returned null request');
-                    }
-                    const finalResponse = await this.handleRequestResponse(dataConnector, pluginManager, initialRequest);
-                    const transformedData = await this.transformData(dataConnector, finalResponse);
-                    transformationData.push(transformedData);
-                }
-                catch (e) {
-                    const transformData = await this.executeV2Bundle(dataConnector, vaultConfig);
-                    transformationData.push(transformData);
-                }
+                const executionContext = await this.getExecutionContext(dataConnector, vaultConfig);
+                dataConnector.setExecutionContextDataConnector(executionContext);
+                transformationData.push(await this.executeV1Bundle(dataConnector));
             }
         }
         return transformationData;
@@ -66,49 +43,77 @@ export class DataConnectorExecution extends 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(vaultConfig.strategyConfigData?.epochLength) !== context.epochLength) {
-            throw new Error('EXECUTION_CONTEXT_MISMATCH: supplied context epoch length does not match vaultConfig.');
+        if (Number(vaultConfig.strategyConfigData?.epochLength) !==
+            context.epochLength) {
+            throw new Error("EXECUTION_CONTEXT_MISMATCH: supplied context epoch length does not match vaultConfig.");
         }
+        const pinnedContext = Object.freeze({ ...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)
                 await dataConnector.load();
-            dataConnector.initializeDataConnectorWithContext(context);
-            await dataConnector.execute();
-            transformationData.push(JSON.parse(await dataConnector.transform()));
+            dataConnector.initializeDataConnectorWithContext(pinnedContext);
+            if (this.getConnectorVersion(dataConnector) >= 2) {
+                transformationData.push(await this.executeInitializedV2Bundle(dataConnector));
+            }
+            else {
+                transformationData.push(await this.executeV1Bundle(dataConnector, pinnedContext));
+            }
         }
         return transformationData;
     }
     async executeV2Bundle(dataConnector, vaultConfig) {
         const executionContext = await this.getExecutionContext(dataConnector, vaultConfig);
         dataConnector.setExecutionContextDataConnector(executionContext);
+        return this.executeInitializedV2Bundle(dataConnector);
+    }
+    getConnectorVersion(dataConnector) {
+        if (typeof dataConnector.module?.version !== "function")
+            return 1;
+        const version = dataConnector.version();
+        if (!Number.isInteger(version) || version < 1)
+            throw new Error("Invalid data connector version");
+        return version;
+    }
+    async executeInitializedV2Bundle(dataConnector) {
         await dataConnector.execute();
-        const result = await dataConnector.transform();
-        return JSON.parse(result);
+        return JSON.parse(await dataConnector.transform());
+    }
+    async executeV1Bundle(dataConnector, context) {
+        const initialRequest = await dataConnector.execute("");
+        if (initialRequest === null)
+            throw new Error("Data connector returned null request");
+        const result = await this.handleRequestResponse(dataConnector, initialRequest, context);
+        if (context)
+            return typeof result === "string" ? JSON.parse(result) : result;
+        return this.transformData(dataConnector, result);
     }
     async executeDynamicJob(_vaultConfig) {
         const vaultConfig = JSON.parse(_vaultConfig);
         const transformationData = [];
-        const pluginManager = new PluginManager();
-        await pluginManager.registerFromPublicConfig();
         for (const dataConnector of this.dataConnectors) {
             if (!dataConnector.module) {
                 await dataConnector.load();
@@ -121,57 +126,98 @@ export class DataConnectorExecution extends ExecutionBase {
         }
         return transformationData;
     }
-    async handleRequestResponse(dataConnector, pluginManager, initialRequest) {
+    async handleRequestResponse(dataConnector, initialRequest, context) {
         let request = initialRequest;
         let response;
         try {
-            while (request !== 'true') {
-                if (dataConnector.configObj.isChainRead == true) {
-                    response = await 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 = await dataConnector.view(view);
                 }
                 else {
-                    const parsedRequest = await pluginManager.process(typeof request == 'string' ? JSON.parse(request) : request);
+                    let parsedRequest = typeof request === "string" ? JSON.parse(request) : request;
                     const url = changeUrlIfOld(parsedRequest.url, dataConnector.configObj.subgraphStudioKey);
                     parsedRequest.url = url;
+                    let sentio = false;
+                    try {
+                        const destination = new URL(axios.getUri(parsedRequest));
+                        const hostname = destination.hostname.toLowerCase();
+                        sentio =
+                            destination.protocol === "https:" &&
+                                (hostname === "sentio.xyz" || hostname.endsWith(".sentio.xyz"));
+                    }
+                    catch {
+                        /* Axios will report an invalid URL when sending the request. */
+                    }
                     parsedRequest.headers = {
-                        'Content-Type': url && !url.includes('subgraph-proxy-server') ? 'application/json' : 'text/plain;charset=UTF-8',
-                        ...(url?.includes('sentio') ? { 'api-key': dataConnector.executionAppConfig.apiKeys.sentioApiKey } : {}),
+                        "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,
+                        };
+                    }
                     await this.delay(1000);
                     try {
                         response = await fetchData(parsedRequest, 0);
                     }
                     catch (error) {
                         const message = error instanceof Error ? error.message : String(error);
-                        throw new DataConnectorTransportError(message.replace(/https?:\/\/[^\s@/]+(?::[^\s@/]+)?@/gi, 'https://[REDACTED]@'));
+                        throw new DataConnectorTransportError(message.replace(/https?:\/\/[^\s@/]+(?::[^\s@/]+)?@/gi, "https://[REDACTED]@"));
                     }
                 }
-                const nextRequest = await dataConnector.execute(JSON.stringify(response));
+                const nextRequest = await 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;
         }
         return dataConnector.getResults();
     }
     async transformData(dataConnector, rawData) {
-        let transformedData = typeof rawData === 'string' ? JSON.parse(rawData) : rawData;
-        const version = await 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 = dataConnector?.configObj?.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 (dataConnector?.executionContext?.epochTimestamp) {
                     const extended = extendOHLCV(transformedData, lookback, dataConnector?.executionContext?.epochTimestamp * 1000);

package/lib/esm/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/esm/index.js

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

package/lib/esm/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/esm/types.js

@@ -2,7 +2,7 @@
 export class ExecutionContextError extends Error {
     constructor(code, message) {
         super(message);
-        this.name = 'ExecutionContextError';
+        this.name = "ExecutionContextError";
         this.code = code;
     }
 }
@@ -10,15 +10,15 @@ export class ExecutionContextError extends Error {
 export 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";
     }
 }
 /** Error classification for a WASM strategy failure. */
 export class StrategyExecutionError extends Error {
     constructor(message) {
         super(message);
-        this.code = 'STRATEGY_EXECUTION_ERROR';
-        this.name = 'StrategyExecutionError';
+        this.code = "STRATEGY_EXECUTION_ERROR";
+        this.name = "StrategyExecutionError";
     }
 }

package/lib/esm/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/esm/utils/blockFinder.js

@@ -5,13 +5,13 @@
  * @param Idenity
  */
 export async function getBlockFromTimestamp(timestamp, provider) {
-    let currentBlock = (await provider.getBlockNumber()) - 1;
-    let runningTimestamp = (await provider.getBlock(currentBlock))?.timestamp;
+    let currentBlock = Number(await provider.getBlockNumber()) - 1;
+    let runningTimestamp = (await provider.getBlock({ blockNumber: BigInt(currentBlock) }))?.timestamp;
     if (!runningTimestamp)
         return currentBlock;
     while (runningTimestamp > timestamp) {
         currentBlock -= 1;
-        runningTimestamp = (await provider.getBlock(currentBlock))?.timestamp;
+        runningTimestamp = (await provider.getBlock({ blockNumber: BigInt(currentBlock) }))?.timestamp;
         if (!runningTimestamp)
             return currentBlock;
     }