@steerprotocol/data-connector-loader 4.1.0 → 5.0.0-next.10

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

@@ -1,7 +1,7 @@
-import type { WasmModule } from '@steerprotocol/app-loader';
-import { ethers } from 'ethers';
-import type { ExecutionAppConfig } from '../execution/executionApp.js';
-import type { EtherRpcConfig, ExecutionContext } from '../types.js';
+import type { WasmModule } from "@steerprotocol/app-loader";
+import type { PublicClient } from "viem";
+import type { ExecutionAppConfig } from "../execution/executionApp.js";
+import type { DataConnectorOptions, ExecutionContext, RpcAccess } from "../types.js";
 export declare class BundleBase {
     module?: WasmModule;
     protected wasmFile: ArrayBuffer | string;
@@ -9,14 +9,11 @@ export declare class BundleBase {
     configObj: {
         [key: string]: any;
     };
-    protected etherRpcConfig?: EtherRpcConfig;
-    protected providerIdentity?: ethers.Provider;
-    executionContext?: ExecutionContext & {
-        epochTimestamp: number;
-    };
-    protected scheduleEpochTimestamp?: number;
+    protected rpc?: RpcAccess;
+    private rpcClient?;
+    executionContext?: ExecutionContext;
     executionAppConfig: ExecutionAppConfig;
-    constructor(wasmFile: string | ArrayBuffer, _config: string, executionAppConfig: ExecutionAppConfig, identity?: ethers.Provider, etherRpcConfig?: EtherRpcConfig);
+    constructor({ wasmFile, config, executionConfig, rpc, }: DataConnectorOptions);
     load(): Promise<WasmModule>;
     loadSync(): WasmModule;
     execute(response?: string): Promise<string | null>;
@@ -29,13 +26,13 @@ export declare class BundleBase {
      * Initializes a strategy from an already resolved SDK context. Unlike the
      * legacy setter this deliberately does not derive a timestamp or block.
      */
-    setExecutionContextStrategyExecutionPinned(executionContext: ExecutionContext, forceDeposit?: boolean): void;
+    initializeStrategyWithContext(executionContext: ExecutionContext, forceDeposit?: boolean): void;
     setExecutionContextDataConnector(executionContext: ExecutionContext): void;
     /** Initializes a data connector with an immutable SDK anchor. */
-    setExecutionContextDataConnectorPinned(executionContext: ExecutionContext): void;
+    initializeDataConnectorWithContext(executionContext: ExecutionContext): void;
     protected executeModule(response: string): Promise<string | null>;
     protected executeModuleWithResult(...params: Array<number | string | ArrayBuffer | null>): Promise<string | null>;
-    getProvider(config: any): ethers.Provider | undefined;
+    getClient(): PublicClient | undefined;
     getResults(): string;
     version(): number;
     private subtractDate;

package/lib/esm/bundle/bundleBase.js

@@ -1,41 +1,15 @@
-import { loadWasm, loadWasmSync } from '@steerprotocol/app-loader';
-import { ethers } from 'ethers';
-const UNSTABLE_RPC_PATTERNS = [/drpc\.org/i];
-function createFallbackRpcProvider(urls) {
-    const seen = new Set();
-    const preferred = [];
-    const deprioritized = [];
-    for (const url of urls) {
-        const trimmed = url.trim();
-        if (trimmed.length === 0 || seen.has(trimmed)) {
-            continue;
-        }
-        seen.add(trimmed);
-        if (UNSTABLE_RPC_PATTERNS.some((pattern) => pattern.test(trimmed))) {
-            deprioritized.push(trimmed);
-        }
-        else {
-            preferred.push(trimmed);
-        }
-    }
-    const prioritized = preferred.length > 0 ? [...preferred, ...deprioritized] : [...preferred, ...deprioritized];
-    if (prioritized.length === 0) {
-        throw new Error('No RPC URLs configured');
-    }
-    const providers = prioritized.map((url) => new ethers.JsonRpcProvider(url));
-    return providers.length === 1 ? providers[0] : new ethers.FallbackProvider(providers);
-}
+import { loadWasm, loadWasmSync } from "@steerprotocol/app-loader";
+import { createRpcClient } from "../utils/rpc.js";
 function bigIntReplacer(_key, value) {
-    return typeof value === 'bigint' ? value.toString() : value;
+    return typeof value === "bigint" ? value.toString() : value;
 }
 export class BundleBase {
-    constructor(wasmFile, _config, executionAppConfig, identity, etherRpcConfig) {
+    constructor({ wasmFile, config, executionConfig, rpc, }) {
         this.wasmFile = wasmFile;
-        this.config = _config;
-        this.configObj = JSON.parse(_config);
-        this.providerIdentity = identity;
-        this.etherRpcConfig = etherRpcConfig;
-        this.executionAppConfig = executionAppConfig;
+        this.config = config;
+        this.configObj = JSON.parse(config);
+        this.rpc = rpc;
+        this.executionAppConfig = executionConfig;
     }
     async load() {
         const instance = await loadWasm(this.wasmFile, {});
@@ -44,15 +18,15 @@ export class BundleBase {
         return this.module;
     }
     loadSync() {
-        if (typeof this.wasmFile === 'string') {
-            throw new Error('Cannot load module synchronously unless wasmFile is of type ArrayBuffer');
+        if (typeof this.wasmFile === "string") {
+            throw new Error("Cannot load module synchronously unless wasmFile is of type ArrayBuffer");
         }
         this.module = loadWasmSync(this.wasmFile, {});
         return this.module;
     }
     async execute(response) {
         if (!this.executionContext) {
-            throw new Error('Execution context missing');
+            throw new Error("Execution context missing");
         }
         // If the module is not initialized, try to load it
         if (!this.module) {
@@ -60,18 +34,20 @@ export class BundleBase {
                 await this.load();
             }
             catch {
-                throw new Error('Module not initialized');
+                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');
-        return response === undefined ? await this.executeModuleWithResult() : await this.executeModuleWithResult(response);
+            throw new Error("Module not initialized");
+        return response === undefined
+            ? await this.executeModuleWithResult()
+            : await this.executeModuleWithResult(response);
     }
     // For dynamic job data connector
     async transform() {
         if (!this.executionContext) {
-            throw new Error('Execution context missing');
+            throw new Error("Execution context missing");
         }
         // If the module is not initialized, try to load it
         if (!this.module) {
@@ -79,18 +55,18 @@ export class BundleBase {
                 await this.load();
             }
             catch {
-                throw new Error('Module not initialized');
+                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');
+            throw new Error("Module not initialized");
         // Call the main function with the response
         return await this.module.transform();
     }
     async executeBundle(data) {
         if (!this.executionContext) {
-            throw new Error('Execution context missing');
+            throw new Error("Execution context missing");
         }
         // If the module is not initialized, try to load it
         if (!this.module) {
@@ -98,21 +74,21 @@ export class BundleBase {
                 await this.load();
             }
             catch {
-                throw new Error('Module not initialized');
+                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');
+            throw new Error("Module not initialized");
         const result = await this.executeModuleWithResult(...data);
         if (result === null) {
-            throw new Error('Module execution returned null');
+            throw new Error("Module execution returned null");
         }
         return result;
     }
     async executeDynamicJobBundle(data) {
         if (!this.executionContext) {
-            throw new Error('Execution context missing');
+            throw new Error("Execution context missing");
         }
         // If the module is not initialized, try to load it
         if (!this.module) {
@@ -120,108 +96,118 @@ export class BundleBase {
                 await this.load();
             }
             catch {
-                throw new Error('Module not initialized');
+                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');
+            throw new Error("Module not initialized");
         const result = await this.executeModuleWithResult(...data);
         if (result === null) {
-            throw new Error('Module execution returned null');
+            throw new Error("Module execution returned null");
         }
         return result;
     }
     reset() {
-        if (this.module && this.module['reset']) {
+        if (this.module && this.module["reset"]) {
             this.module.reset();
         }
     }
     setExecutionContextStrategyExecution(executionContext, forceDeposit) {
+        if (!this.module)
+            throw new Error("Module not initialized");
         // Determine the timestamp for epoch
         const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
         // Divide milliseconds data to seconds for transformation bundle
         const timestampInSecs = Math.floor(timestamp / 1000);
-        this.executionContext = { ...executionContext, epochTimestamp: timestampInSecs };
-        const completeConfig = { ...JSON.parse(this.config), ...this.executionContext };
-        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
+        this.executionContext = {
+            ...executionContext,
+            epochTimestamp: timestampInSecs,
+        };
+        const completeConfig = {
+            ...JSON.parse(this.config),
+            ...this.executionContext,
+        };
         if (completeConfig.triggerStyle && forceDeposit === true) {
-            completeConfig.triggerStyle = 'None';
+            completeConfig.triggerStyle = "None";
+        }
+        if (this.module.initialize(JSON.stringify(completeConfig, bigIntReplacer)) ===
+            false) {
+            throw new Error("Strategy initialization failed");
         }
-        this.module?.initialize(JSON.stringify(completeConfig, bigIntReplacer));
     }
     /**
      * Initializes a strategy from an already resolved SDK context. Unlike the
      * legacy setter this deliberately does not derive a timestamp or block.
      */
-    setExecutionContextStrategyExecutionPinned(executionContext, forceDeposit) {
+    initializeStrategyWithContext(executionContext, forceDeposit) {
+        if (!this.module)
+            throw new Error("Module not initialized");
         this.executionContext = executionContext;
-        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
-        const completeConfig = { ...JSON.parse(this.config), ...executionContext };
+        const completeConfig = {
+            ...JSON.parse(this.config),
+            ...executionContext,
+        };
         if (completeConfig.triggerStyle && forceDeposit === true) {
-            completeConfig.triggerStyle = 'None';
+            completeConfig.triggerStyle = "None";
+        }
+        if (this.module.initialize(JSON.stringify(completeConfig, bigIntReplacer)) ===
+            false) {
+            throw new Error("Strategy initialization failed");
         }
-        this.module?.initialize(JSON.stringify(completeConfig, bigIntReplacer));
     }
     setExecutionContextDataConnector(executionContext) {
         // Determine the timestamp for epoch
         const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
         // Divide milliseconds data to seconds for transformation bundle
         const timestampInSecs = Math.floor(timestamp / 1000);
-        this.executionContext = { ...executionContext, epochTimestamp: timestampInSecs };
-        const completeConfig = { ...JSON.parse(this.config), executionContext: this.executionContext };
-        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
+        this.executionContext = {
+            ...executionContext,
+            epochTimestamp: timestampInSecs,
+        };
+        const completeConfig = {
+            ...JSON.parse(this.config),
+            executionContext: this.executionContext,
+        };
         this.module?.initialize(JSON.stringify(completeConfig, bigIntReplacer));
     }
     /** Initializes a data connector with an immutable SDK anchor. */
-    setExecutionContextDataConnectorPinned(executionContext) {
+    initializeDataConnectorWithContext(executionContext) {
+        if (!this.module)
+            throw new Error("Module not initialized");
         this.executionContext = executionContext;
-        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
         const completeConfig = { ...JSON.parse(this.config), executionContext };
-        this.module?.initialize(JSON.stringify(completeConfig, bigIntReplacer));
+        if (this.module.initialize(JSON.stringify(completeConfig, bigIntReplacer)) ===
+            false) {
+            throw new Error("Data connector initialization failed");
+        }
     }
     async executeModule(response) {
         if (!this.module) {
-            throw new Error('Module not initialized');
+            throw new Error("Module not initialized");
         }
         return await this.executeModuleWithResult(response);
     }
     async executeModuleWithResult(...params) {
         if (!this.module) {
-            throw new Error('Module not initialized');
+            throw new Error("Module not initialized");
         }
         return await this.module.execute(...params);
     }
-    // This function returns a provider based on the chainId of the request
-    // The chainId is first checked in the data connector config, and if not found
-    // it is checked in the request config. If the chainId is found in either of
-    // these places, the provider is returned from the etherRpcConfig object
-    getProvider(config) {
-        let chainId;
-        // check if chainId is configured in data connector config
-        if (this.configObj.chainId) {
-            chainId = this.configObj.chainId;
-        }
-        else if (config && config.chainId) {
-            // if chainId is in the request config from dataconnector execution
-            chainId = config.chainId;
-        }
-        if (chainId && this.etherRpcConfig && this.etherRpcConfig[chainId]) {
-            const rpcConfig = this.etherRpcConfig[chainId];
-            return createFallbackRpcProvider(rpcConfig.urls ?? [rpcConfig.url]);
-        }
-        else {
-            return this.providerIdentity;
-        }
+    getClient() {
+        if (!this.rpc)
+            return undefined;
+        this.rpcClient ?? (this.rpcClient = createRpcClient(this.rpc, this.executionAppConfig.chainId));
+        return this.rpcClient;
     }
     getResults() {
         if (!this.module)
-            throw new Error('Module not initialized');
+            throw new Error("Module not initialized");
         return this.module.transform();
     }
     version() {
         if (!this.module)
-            throw new Error('Module not initialized');
+            throw new Error("Module not initialized");
         return Number(this.module.version());
     }
     subtractDate(timestamp, epochLength) {

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

@@ -1,9 +1,5 @@
-import type { ethers } from 'ethers';
-import type { ExecutionAppConfig } from '../execution/executionApp.js';
-import type { EtherRpcConfig, ViewConfig } from '../types.js';
-import { BundleBase } from './bundleBase.js';
+import type { ViewConfig } from "../types.js";
+import { BundleBase } from "./bundleBase.js";
 export declare class DataConnector extends BundleBase {
-    constructor(wasmFile: string | ArrayBuffer, _config: string, executionAppConfig: ExecutionAppConfig, identity?: ethers.Provider, etherRpcConfig?: EtherRpcConfig);
-    getRpcUrl(config: any): string | undefined;
     view(config: ViewConfig): Promise<string>;
 }

package/lib/esm/bundle/bundleDataConnector.js

@@ -1,56 +1,33 @@
-import { Contract } from 'ethers';
-import { CENTRALIZE_CONTRACT_INTERACTION_CHAINS } from '../utils/consts.js';
-import { callWithRetry } from '../utils/utils.js';
-import { BundleBase } from './bundleBase.js';
+import { readContract } from "../utils/utils.js";
+import { BundleBase } from "./bundleBase.js";
 export class DataConnector extends BundleBase {
-    // Identity should come from the node's IdentityManager.wallet
-    constructor(wasmFile, _config, executionAppConfig, identity, etherRpcConfig) {
-        super(wasmFile, _config, executionAppConfig, 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
     async view(config) {
-        const provider = this.getProvider(config);
-        if (!provider)
-            throw new Error('Provider not initialized');
-        const contract = new Contract(config.address, config.abi, provider);
-        const paramsArray = config.arguments;
-        let result;
-        if (CENTRALIZE_CONTRACT_INTERACTION_CHAINS.indexOf(this.configObj.chainId.toString()) === -1) {
-            result = await contract[config.method](...paramsArray, {
-                blockTag: this.executionContext?.blockNumber,
-            });
+        const executionContext = this.executionContext && {
+            ...this.executionContext,
+        };
+        const pinnedChainId = executionContext?.chainId;
+        const chainId = this.configObj.chainId ?? config.chainId ?? pinnedChainId;
+        if (pinnedChainId !== undefined &&
+            ((chainId !== undefined && Number(chainId) !== pinnedChainId) ||
+                (config.chainId !== undefined &&
+                    Number(config.chainId) !== pinnedChainId))) {
+            throw new Error("EXECUTION_CONTEXT_MISMATCH: contract request chain does not match supplied context.");
         }
-        else {
-            const viewContractConfig = {
-                epochTimestamp: this.scheduleEpochTimestamp,
-                blockNumber: this.executionContext?.blockNumber,
-                address: this.configObj.address || config.address,
-                abi: config.abi,
-                arguments: paramsArray,
-                method: config.method,
-                rpcUrl: this.getRpcUrl(config),
-            };
-            result = await callWithRetry(viewContractConfig);
+        const provider = this.getClient();
+        if (!provider)
+            throw new Error("Provider not initialized");
+        if (pinnedChainId !== undefined &&
+            (await provider.getChainId()) !== pinnedChainId) {
+            throw new Error("EXECUTION_CONTEXT_MISMATCH: provider chain does not match supplied context.");
         }
-        // This gets stringified before calling main
-        return result;
+        return readContract({
+            address: config.address,
+            abi: config.abi,
+            functionName: config.method,
+            contractArguments: config.arguments,
+            provider,
+            currentExecutionContext: executionContext,
+        });
     }
 }

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

@@ -1,14 +1,14 @@
-import type { ethers } from 'ethers';
-import type { EtherRpcConfig, ExecuteWithContextOptions, JobDetails } from '../types.js';
-import { ExecutionBase } from './executionBase.js';
+import type { ExecuteWithContextOptions, JobDetails, RpcAccess } from "../types.js";
+import { ExecutionBase } from "./executionBase.js";
 export interface ExecutionAppConfig {
     /** Vault address used for execution context and subgraph queries. */
     vault: string;
     /** Chain ID used to resolve RPC configuration and on-chain reads. */
     chainId: number;
-    /** Subgraph endpoint used for protocol data queries. */
-    steerSubgraph: string;
-    poolType: {
+    /** Required by execute() for protocol discovery queries. */
+    steerSubgraph?: string;
+    /** Required by execute() for pool discovery; unused by executeWithContext(). */
+    poolType?: {
         /** Set true when the pool uses Algebra v1 semantics. */
         isAlgebraPool: boolean;
         /** Set true when the pool uses Algebra Integral semantics. */
@@ -20,11 +20,11 @@ export interface ExecutionAppConfig {
         /** Set true when the pool uses Aerodrome semantics. */
         isAerodromePool: boolean;
     };
-    apiKeys: {
-        /** API key for The Graph Studio / gateway endpoints. */
-        subgraphStudioKey: string;
+    apiKeys?: {
+        /** Host-only Graph credential; never added to WASM configuration. */
+        subgraphStudioKey?: string;
         /** API key for Sentio endpoints, if applicable. */
-        sentioApiKey: string;
+        sentioApiKey?: string;
     };
     /** Maximum number of retries for execution operations. */
     maxRetries?: number;
@@ -38,22 +38,23 @@ export declare class ExecutionApp extends ExecutionBase {
     isDirectionalPool: boolean;
     isPoolSharkPool: boolean;
     isAerodromePool: boolean;
-    subgraphStudioKey: string;
     sentioApiKey: string;
     config: ExecutionAppConfig;
     constructor(config: ExecutionAppConfig);
-    execute<T>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, _identity?: ethers.Provider, _etherRpcConfig?: EtherRpcConfig, forceDeposit?: boolean): Promise<Array<T>>;
+    execute<T = unknown>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, rpc?: RpcAccess, forceDeposit?: boolean): Promise<T | "continue">;
     /**
-     * Executes a strategy against the immutable context resolved by SDK 3.3+.
+     * Executes a strategy against a supplied execution context.
      * This is the recommended API for new consumers. It intentionally bypasses
      * all legacy vault, pool, subgraph, clock, and block-estimation reads.
      */
-    executeWithContext<T>(options: ExecuteWithContextOptions): Promise<Array<T>>;
+    executeWithContext<T = unknown>(options: ExecuteWithContextOptions): Promise<T | "continue">;
+    /** T is the complete decoded JSON result. Only the exact sentinel skips JSON decoding. */
+    private parseStrategyResult;
     private parseVaultConfig;
-    private mapSdkExecutionContext;
+    private validateExecutionContext;
     private redactError;
-    executeStabilityVault<T>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, _identity?: ethers.Provider, _etherRpcConfig?: EtherRpcConfig, forceDeposit?: boolean): Promise<Array<T>>;
-    executeDynamicJobs<T>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, _job: JobDetails, _identity?: ethers.Provider, _etherRpcConfig?: EtherRpcConfig, forceDeposit?: boolean): Promise<Array<T>>;
+    executeStabilityVault<T = unknown>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, rpc?: RpcAccess, forceDeposit?: boolean): Promise<T | "continue">;
+    executeDynamicJobs<T = unknown>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, _job: JobDetails, rpc?: RpcAccess, forceDeposit?: boolean): Promise<T | "continue">;
     private getSmartPoolExecutionContext;
     private getPoolCurrentTick;
     private getTickSpacing;