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

package/README.md

@@ -22,37 +22,153 @@ pnpm add @steerprotocol/data-connector-loader
 
 This package publishes both CommonJS and ESM entrypoints via `exports`.
 
+## Prereleases
+
+The `next` branch publishes prereleases under the npm `next` tag after CI passes.
+The release workflow can also be run manually on `next` with `dry_run` enabled.
+Versions are calculated from Git tags and conventional commits; a breaking
+change must be marked as such for the first prerelease of a new major version.
+The npm package must authorize `next-publish.yml` as a trusted publisher before
+that workflow can publish.
+
+## CI checks
+
+The shared `next-ci.yml` matrix verifies Node 22 and Node 24. Each job runs
+`npm ci` (which builds CommonJS and ESM through `prepare`), tests, Biome,
+and packed-consumer checks. Node 24 collects coverage during its test run;
+coverage comments are posted on same-repository pull requests with write access.
+Fork and Dependabot pull requests still run coverage without posting comments.
+
+Pull requests and non-release branch pushes run the shared CI directly.
+Pushes to `next` or `main` run it once through their release workflow, and
+publishing waits for both Node jobs. The release workflow filenames remain
+unchanged for npm trusted publishing. The packed-consumer check installs into
+a fresh temporary directory while reusing npm's download cache.
+
 ## Block-pinned strategy execution (recommended)
 
-Resolve the vault context with `@steerprotocol/sdk` 3.3+ and pass its successful
-`VaultExecutionContext` straight to `executeWithContext`. This path makes no
-pool, vault, subgraph, latest-block, average-block-time, or wall-clock reads.
-Uniswap v3-compatible, Algebra Integral, Aerodrome CL, and normalized Uniswap
-v4 contexts are supported. PoolShark remains unsupported by the SDK context API.
+Supply a resolved `SmartPoolExecutionContext` to `ExecutionApp.executeWithContext`.
+Strategy entrypoints return the exact string `"continue"` when no action is needed,
+or the decoded JSON result. Their generic `T` describes the complete JSON result
+(an action object or array), and the return type is `Promise<T | "continue">`.
+All other non-JSON output is rejected as `StrategyExecutionError`.
 
-```ts
-import { ExecutionApp } from '@steerprotocol/data-connector-loader';
-import { getVaultExecutionContext } from '@steerprotocol/sdk';
+The offline `strategyWasm.integration.test.ts` suite runs retained Liquid Arc and
+Static Stable binaries through the loader, covering both `continue` and JSON
+actions with supplied contexts. It checks binary hashes and runs with `npm test`
+in CI. To run just these cases:
+
+```sh
+npm test -- --runInBand strategyWasm.integration.test.ts
+```
+
+For connectors, pass an `ExecutionContext` to `DataConnectorExecution.executeWithContext`.
+`SmartPoolExecutionContext` extends `ExecutionContext`, so the same resolved
+context can be used for both. Both contexts include the chain ID for comparison
+against the execution configuration. This path does not resolve vault or pool
+state or infer the block or execution time.
 
-const response = await getVaultExecutionContext({ publicClient, vaultAddress, blockNumber, epochTimestamp });
-if (!response.success || !response.data) throw new Error(response.error ?? 'Context resolution failed');
+```ts
+import { DataConnectorExecution, ExecutionApp } from '@steerprotocol/data-connector-loader';
 
-const app = new ExecutionApp(legacyCompatibleConfig);
-const actions = await app.executeWithContext({
+// context is a previously resolved SmartPoolExecutionContext.
+const vaultConfig = JSON.stringify({
+  vaultAddress: context.vaultAddress,
+  anchorBlockNumber: context.blockNumber,
+  strategyConfigData: { epochLength: String(context.epochLength) },
+});
+const connectorOutputs = await new DataConnectorExecution(connectors).executeWithContext(vaultConfig, context);
+const actions = await new ExecutionApp(executionAppConfig).executeWithContext({
   wasmFile: strategyWasmBytes,
-  vaultConfig: JSON.stringify({ vaultAddress, anchorBlockNumber: Number(blockNumber), strategyConfigData: { epochLength: '3600' } }),
+  vaultConfig,
   data: connectorOutputs,
-  executionContext: response.data,
+  executionContext: context,
 });
 ```
 
-`vaultConfig` must include `vaultAddress`, `anchorBlockNumber`, and
-`strategyConfigData.epochLength`. Positions are translated at the WASM boundary
-from SDK `lowerTick`/`upperTick`/`relativeWeight` to
-`startTick`/`endTick`/`weight`; totals remain decimal strings. If SDK reports no
-last execution, WASM receives `lastExecutionTime: 0` (deterministic, no
-wall-clock fallback). Errors are `ExecutionContextError`
+Contexts must have matching vault, chain, block and epoch length values. Block
+and timestamp fields are safe integer numbers, with `executionTimestamp` in
+milliseconds and `epochTimestamp` in seconds. Positions use `startTick`,
+`endTick`, and `weight`; totals remain decimal strings. The former stable SDK
+`VaultExecutionContext` shape is not accepted by these entry points.
+Callers migrating from that shape must supply the resolved chain ID and use
+`SmartPoolExecutionContext` for strategies or `ExecutionContext` for connectors.
+Connector execution supports both v1 request/response loops and v2 bundles.
+The pinned path keeps contract reads on the supplied chain and block. A missing
+version export selects v1; version and connector execution errors are propagated.
+V1 connectors start with an empty response; v2 connectors execute without one.
+Use a separate connector instance for each concurrent execution. A connector holds mutable WASM state and execution context, so sharing one across concurrent runs can produce incorrect results.
+Errors are `ExecutionContextError`
 (`INVALID_EXECUTION_CONTEXT` or `EXECUTION_CONTEXT_MISMATCH`) and
 `StrategyExecutionError` (`STRATEGY_EXECUTION_ERROR`); neither is retryable
 until its input or strategy failure is corrected. External connector HTTP data
 remains external and unpinned.
+
+## vNext RPC configuration
+
+The loader uses viem for RPC and ABI handling. Construct connectors with an
+options object and either RPC URLs or an existing viem `PublicClient`:
+
+```ts
+import { DataConnector } from '@steerprotocol/data-connector-loader';
+
+const connector = new DataConnector({
+  wasmFile: connectorWasmBytes,
+  config: connectorConfigJson,
+  executionConfig: executionAppConfig,
+  rpc: { urls: ['https://your-primary-rpc', 'https://your-backup-rpc'] },
+  // Alternatively: rpc: { client: publicClient }
+});
+```
+
+URLs belong to `executionConfig.chainId`. The loader tries them in order and
+checks each endpoint's chain before sending a read, including during failover.
+This uses first-success failover, not ethers quorum voting. A supplied client
+is chain-checked by the execution path; the caller owns its transport setup and
+must ensure every endpoint in a custom fallback client serves that same chain.
+RPC configuration can be omitted for connectors that make no chain reads.
+
+This is a breaking TypeScript API change: the positional `DataConnector`
+constructor, ethers provider argument, `EtherRpcConfig`, and `getProvider()`
+are replaced by the options object, `RpcAccess`, and `getClient()`.
+The older `ExecutionApp.execute`, `executeStabilityVault`, and `executeDynamicJobs`
+methods accept one `rpc` argument in place of the old provider and RPC map
+arguments; `forceDeposit` follows it. Supplied-context strategy execution needs
+no RPC configuration.
+
+Existing WASM exports and initialization payloads are unchanged. ABI responses
+retain positional tuples, small integer numbers, and decimal strings for large
+integers when serialized into WASM. JSON and human-readable ABIs are supported,
+including the existing `tuple(...)` syntax and explicit overload signatures.
+`@steerprotocol/app-loader` is unchanged and still brings ethers transitively.
+The loader itself imports ethers only in tests as an ABI encoding reference.
+
+## Code quality system
+
+We use [Biome](https://biomejs.dev/) with its recommended lint rules, formatter,
+and import organization. `biome.json` is the shared configuration for local
+commands, editors, and CI. The exact version is pinned in `package.json`.
+
+The formatter uses Biome defaults (80-column preferred width, double quotes,
+semicolons, and trailing commas), with two-space indentation matching
+`.editorconfig`. There is no separate ESLint or Prettier configuration.
+
+- `npm run fix`: apply formatting, import organization, and safe lint fixes.
+- `npm run check:code`: verify all three without changing files, as CI does.
+- `npm run check`: run code checks, both builds, and all tests.
+- `npm run format` / `npm run format:check`: write/check formatting only.
+- `npm run lint` / `npm run lint:fix`: check/apply safe lint fixes only.
+
+Recommended lint errors, formatting differences, and import-order violations
+block CI and publication. Existing recommended warnings remain visible and
+advisory. Focused tests are errors; skipped tests are warnings. TypeScript
+compilation and Jest remain separate checks: Biome is not a type checker or a
+one-for-one replacement for every ESLint plugin rule.
+
+Avoid blanket rule overrides or unsafe automatic fixes.
+
+Checks cover source, tests, helpers, scripts, and root JSON/CommonJS config.
+Generated files, dependencies, lockfiles, and WASM binaries are excluded.
+Markdown and workflow YAML are outside this configuration's scope.
+In VS Code, install the recommended Biome extension; workspace settings apply
+formatting and import organization on save for JavaScript and TypeScript.

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

@@ -11,43 +11,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BundleBase = void 0;
 const app_loader_1 = require("@steerprotocol/app-loader");
-const ethers_1 = require("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_1.ethers.JsonRpcProvider(url));
-    return providers.length === 1 ? providers[0] : new ethers_1.ethers.FallbackProvider(providers);
-}
+const rpc_js_1 = require("../utils/rpc.js");
 function bigIntReplacer(_key, value) {
-    return typeof value === 'bigint' ? value.toString() : value;
+    return typeof value === "bigint" ? value.toString() : value;
 }
 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;
     }
     load() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -58,8 +32,8 @@ class BundleBase {
         });
     }
     loadSync() {
-        if (typeof this.wasmFile === 'string') {
-            throw new Error('Cannot load module synchronously unless wasmFile is of type ArrayBuffer');
+        if (typeof this.wasmFile === "string") {
+            throw new Error("Cannot load module synchronously unless wasmFile is of type ArrayBuffer");
         }
         this.module = (0, app_loader_1.loadWasmSync)(this.wasmFile, {});
         return this.module;
@@ -67,7 +41,7 @@ class BundleBase {
     execute(response) {
         return __awaiter(this, void 0, void 0, function* () {
             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) {
@@ -75,20 +49,22 @@ class BundleBase {
                     yield this.load();
                 }
                 catch (_a) {
-                    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 ? yield this.executeModuleWithResult() : yield this.executeModuleWithResult(response);
+                throw new Error("Module not initialized");
+            return response === undefined
+                ? yield this.executeModuleWithResult()
+                : yield this.executeModuleWithResult(response);
         });
     }
     // For dynamic job data connector
     transform() {
         return __awaiter(this, void 0, void 0, function* () {
             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) {
@@ -96,12 +72,12 @@ class BundleBase {
                     yield this.load();
                 }
                 catch (_a) {
-                    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 yield this.module.transform();
         });
@@ -109,7 +85,7 @@ class BundleBase {
     executeBundle(data) {
         return __awaiter(this, void 0, void 0, function* () {
             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) {
@@ -117,15 +93,15 @@ class BundleBase {
                     yield this.load();
                 }
                 catch (_a) {
-                    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 = yield this.executeModuleWithResult(...data);
             if (result === null) {
-                throw new Error('Module execution returned null');
+                throw new Error("Module execution returned null");
             }
             return result;
         });
@@ -133,7 +109,7 @@ class BundleBase {
     executeDynamicJobBundle(data) {
         return __awaiter(this, void 0, void 0, function* () {
             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) {
@@ -141,51 +117,57 @@ class BundleBase {
                     yield this.load();
                 }
                 catch (_a) {
-                    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 = yield 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) {
-        var _a;
+        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 = Object.assign(Object.assign({}, executionContext), { epochTimestamp: timestampInSecs });
         const completeConfig = Object.assign(Object.assign({}, JSON.parse(this.config)), this.executionContext);
-        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
         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");
         }
-        (_a = this.module) === null || _a === void 0 ? void 0 : _a.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) {
-        var _a;
+    initializeStrategyWithContext(executionContext, forceDeposit) {
+        if (!this.module)
+            throw new Error("Module not initialized");
         this.executionContext = executionContext;
-        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
         const completeConfig = Object.assign(Object.assign({}, 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");
         }
-        (_a = this.module) === null || _a === void 0 ? void 0 : _a.initialize(JSON.stringify(completeConfig, bigIntReplacer));
     }
     setExecutionContextDataConnector(executionContext) {
         var _a;
@@ -195,21 +177,23 @@ class BundleBase {
         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;
         (_a = this.module) === null || _a === void 0 ? void 0 : _a.initialize(JSON.stringify(completeConfig, bigIntReplacer));
     }
     /** Initializes a data connector with an immutable SDK anchor. */
-    setExecutionContextDataConnectorPinned(executionContext) {
-        var _a;
+    initializeDataConnectorWithContext(executionContext) {
+        if (!this.module)
+            throw new Error("Module not initialized");
         this.executionContext = executionContext;
-        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
         const completeConfig = Object.assign(Object.assign({}, JSON.parse(this.config)), { executionContext });
-        (_a = this.module) === null || _a === void 0 ? void 0 : _a.initialize(JSON.stringify(completeConfig, bigIntReplacer));
+        if (this.module.initialize(JSON.stringify(completeConfig, bigIntReplacer)) ===
+            false) {
+            throw new Error("Data connector initialization failed");
+        }
     }
     executeModule(response) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.module) {
-                throw new Error('Module not initialized');
+                throw new Error("Module not initialized");
             }
             return yield this.executeModuleWithResult(response);
         });
@@ -217,42 +201,26 @@ class BundleBase {
     executeModuleWithResult(...params) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.module) {
-                throw new Error('Module not initialized');
+                throw new Error("Module not initialized");
             }
             return yield 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) {
+    getClient() {
         var _a;
-        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((_a = rpcConfig.urls) !== null && _a !== void 0 ? _a : [rpcConfig.url]);
-        }
-        else {
-            return this.providerIdentity;
-        }
+        if (!this.rpc)
+            return undefined;
+        (_a = this.rpcClient) !== null && _a !== void 0 ? _a : (this.rpcClient = (0, rpc_js_1.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/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/bundle/bundleDataConnector.js

@@ -10,62 +10,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataConnector = void 0;
-const ethers_1 = require("ethers");
-const consts_js_1 = require("../utils/consts.js");
 const utils_js_1 = require("../utils/utils.js");
 const bundleBase_js_1 = require("./bundleBase.js");
 class DataConnector extends bundleBase_js_1.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
     view(config) {
         var _a, _b;
         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);
-            const paramsArray = config.arguments;
-            let result;
-            if (consts_js_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,
-                });
+            const executionContext = this.executionContext && Object.assign({}, this.executionContext);
+            const pinnedChainId = executionContext === null || executionContext === void 0 ? void 0 : executionContext.chainId;
+            const chainId = (_b = (_a = this.configObj.chainId) !== null && _a !== void 0 ? _a : config.chainId) !== null && _b !== void 0 ? _b : 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: (_b = this.executionContext) === null || _b === void 0 ? void 0 : _b.blockNumber,
-                    address: this.configObj.address || config.address,
-                    abi: config.abi,
-                    arguments: paramsArray,
-                    method: config.method,
-                    rpcUrl: this.getRpcUrl(config),
-                };
-                result = yield (0, utils_js_1.callWithRetry)(viewContractConfig);
+            const provider = this.getClient();
+            if (!provider)
+                throw new Error("Provider not initialized");
+            if (pinnedChainId !== undefined &&
+                (yield 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 (0, utils_js_1.readContract)({
+                address: config.address,
+                abi: config.abi,
+                functionName: config.method,
+                contractArguments: config.arguments,
+                provider,
+                currentExecutionContext: executionContext,
+            });
         });
     }
 }