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

package/lib/esm/execution/executionApp.js

@@ -1,44 +1,42 @@
-import { DataConnector } from '../bundle/bundleDataConnector.js';
-import { ExecutionContextError, StrategyExecutionError } from '../types.js';
-import { fetchData, readContract } from '../utils/utils.js';
-import { ExecutionBase } from './executionBase.js';
+import { DataConnector } from "../bundle/bundleDataConnector.js";
+import { ExecutionContextError, StrategyExecutionError } from "../types.js";
+import { fetchData, readContract } from "../utils/utils.js";
+import { ExecutionBase } from "./executionBase.js";
 export class ExecutionApp extends ExecutionBase {
     constructor(config) {
         super(config.maxRetries ?? 3);
-        this.getSlot0 = async (pool, currentExecutionContext, provider, rpc) => {
+        this.getSlot0 = async (pool, currentExecutionContext, provider) => {
             const slot0Abi = [
                 {
                     inputs: [],
-                    name: 'slot0',
+                    name: "slot0",
                     outputs: [
-                        { internalType: 'uint160', name: 'sqrtPriceX96', type: 'uint160' },
-                        { internalType: 'int24', name: 'tick', type: 'int24' },
-                        { internalType: 'uint16', name: 'observationIndex', type: 'uint16' },
+                        { internalType: "uint160", name: "sqrtPriceX96", type: "uint160" },
+                        { internalType: "int24", name: "tick", type: "int24" },
+                        { internalType: "uint16", name: "observationIndex", type: "uint16" },
                         {
-                            internalType: 'uint16',
-                            name: 'observationCardinality',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "observationCardinality",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'observationCardinalityNext',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "observationCardinalityNext",
+                            type: "uint16",
                         },
-                        { internalType: 'uint8', name: 'feeProtocol', type: 'uint8' },
-                        { internalType: 'bool', name: 'unlocked', type: 'bool' },
+                        { internalType: "uint8", name: "feeProtocol", type: "uint8" },
+                        { internalType: "bool", name: "unlocked", type: "bool" },
                     ],
-                    stateMutability: 'view',
-                    type: 'function',
+                    stateMutability: "view",
+                    type: "function",
                 },
             ];
             const slot0 = await readContract({
                 address: pool,
                 abi: slot0Abi,
                 currentExecutionContext,
-                functionName: 'slot0',
+                functionName: "slot0",
                 provider,
-                rpc,
-                chainId: this.chainId,
             });
             return {
                 sqrtPriceX96: slot0[0],
@@ -50,55 +48,53 @@ export class ExecutionApp extends ExecutionBase {
                 unlocked: slot0[6],
             };
         };
-        this.getSlot0Aerodrome = async (pool, currentExecutionContext, provider, rpc) => {
+        this.getSlot0Aerodrome = async (pool, currentExecutionContext, provider) => {
             const slot0Abi = [
                 {
                     inputs: [],
-                    name: 'slot0',
+                    name: "slot0",
                     outputs: [
                         {
-                            internalType: 'uint160',
-                            name: 'sqrtPriceX96',
-                            type: 'uint160',
+                            internalType: "uint160",
+                            name: "sqrtPriceX96",
+                            type: "uint160",
                         },
                         {
-                            internalType: 'int24',
-                            name: 'tick',
-                            type: 'int24',
+                            internalType: "int24",
+                            name: "tick",
+                            type: "int24",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'observationIndex',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "observationIndex",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'observationCardinality',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "observationCardinality",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'observationCardinalityNext',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "observationCardinalityNext",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'bool',
-                            name: 'unlocked',
-                            type: 'bool',
+                            internalType: "bool",
+                            name: "unlocked",
+                            type: "bool",
                         },
                     ],
-                    stateMutability: 'view',
-                    type: 'function',
+                    stateMutability: "view",
+                    type: "function",
                 },
             ];
             const slot0 = await readContract({
                 address: pool,
                 abi: slot0Abi,
                 currentExecutionContext,
-                functionName: 'slot0',
+                functionName: "slot0",
                 provider,
-                rpc,
-                chainId: this.chainId,
             });
             return {
                 sqrtPriceX96: slot0[0],
@@ -113,317 +109,315 @@ export class ExecutionApp extends ExecutionBase {
             if (this.isAlgebraIntegralPool) {
                 return {
                     inputs: [],
-                    name: 'globalState',
+                    name: "globalState",
                     outputs: [
                         {
-                            internalType: 'uint160',
-                            name: 'price',
-                            type: 'uint160',
+                            internalType: "uint160",
+                            name: "price",
+                            type: "uint160",
                         },
                         {
-                            internalType: 'int24',
-                            name: 'tick',
-                            type: 'int24',
+                            internalType: "int24",
+                            name: "tick",
+                            type: "int24",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'lastFee',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "lastFee",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'uint8',
-                            name: 'pluginConfig',
-                            type: 'uint8',
+                            internalType: "uint8",
+                            name: "pluginConfig",
+                            type: "uint8",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'communityFee',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "communityFee",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'bool',
-                            name: 'unlocked',
-                            type: 'bool',
+                            internalType: "bool",
+                            name: "unlocked",
+                            type: "bool",
                         },
                     ],
-                    stateMutability: 'view',
-                    type: 'function',
+                    stateMutability: "view",
+                    type: "function",
                 };
             }
             else if (this.isDirectionalPool) {
                 return {
                     inputs: [],
-                    name: 'globalState',
+                    name: "globalState",
                     outputs: [
                         {
-                            internalType: 'uint160',
-                            name: 'price',
-                            type: 'uint160',
+                            internalType: "uint160",
+                            name: "price",
+                            type: "uint160",
                         },
                         {
-                            internalType: 'int24',
-                            name: 'tick',
-                            type: 'int24',
+                            internalType: "int24",
+                            name: "tick",
+                            type: "int24",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'feeZto',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "feeZto",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'feeOtz',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "feeOtz",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'timepointIndex',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "timepointIndex",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'uint8',
-                            name: 'communityFeeToken0',
-                            type: 'uint8',
+                            internalType: "uint8",
+                            name: "communityFeeToken0",
+                            type: "uint8",
                         },
                         {
-                            internalType: 'uint8',
-                            name: 'communityFeeToken1',
-                            type: 'uint8',
+                            internalType: "uint8",
+                            name: "communityFeeToken1",
+                            type: "uint8",
                         },
                         {
-                            internalType: 'bool',
-                            name: 'unlocked',
-                            type: 'bool',
+                            internalType: "bool",
+                            name: "unlocked",
+                            type: "bool",
                         },
                     ],
-                    stateMutability: 'view',
-                    type: 'function',
+                    stateMutability: "view",
+                    type: "function",
                 };
             }
             else if (this.isPoolSharkPool) {
                 return {
                     inputs: [],
-                    name: 'globalState',
+                    name: "globalState",
                     outputs: [
                         {
                             components: [
                                 {
                                     components: [
                                         {
-                                            internalType: 'uint16',
-                                            name: 'index',
-                                            type: 'uint16',
+                                            internalType: "uint16",
+                                            name: "index",
+                                            type: "uint16",
                                         },
                                         {
-                                            internalType: 'uint16',
-                                            name: 'count',
-                                            type: 'uint16',
+                                            internalType: "uint16",
+                                            name: "count",
+                                            type: "uint16",
                                         },
                                         {
-                                            internalType: 'uint16',
-                                            name: 'countMax',
-                                            type: 'uint16',
+                                            internalType: "uint16",
+                                            name: "countMax",
+                                            type: "uint16",
                                         },
                                     ],
-                                    internalType: 'struct PoolsharkStructs.SampleState',
-                                    name: 'samples',
-                                    type: 'tuple',
+                                    internalType: "struct PoolsharkStructs.SampleState",
+                                    name: "samples",
+                                    type: "tuple",
                                 },
                                 {
-                                    internalType: 'uint200',
-                                    name: 'feeGrowthGlobal0',
-                                    type: 'uint200',
+                                    internalType: "uint200",
+                                    name: "feeGrowthGlobal0",
+                                    type: "uint200",
                                 },
                                 {
-                                    internalType: 'uint200',
-                                    name: 'feeGrowthGlobal1',
-                                    type: 'uint200',
+                                    internalType: "uint200",
+                                    name: "feeGrowthGlobal1",
+                                    type: "uint200",
                                 },
                                 {
-                                    internalType: 'uint160',
-                                    name: 'secondsPerLiquidityAccum',
-                                    type: 'uint160',
+                                    internalType: "uint160",
+                                    name: "secondsPerLiquidityAccum",
+                                    type: "uint160",
                                 },
                                 {
-                                    internalType: 'uint160',
-                                    name: 'price',
-                                    type: 'uint160',
+                                    internalType: "uint160",
+                                    name: "price",
+                                    type: "uint160",
                                 },
                                 {
-                                    internalType: 'uint128',
-                                    name: 'liquidity',
-                                    type: 'uint128',
+                                    internalType: "uint128",
+                                    name: "liquidity",
+                                    type: "uint128",
                                 },
                                 {
-                                    internalType: 'int56',
-                                    name: 'tickSecondsAccum',
-                                    type: 'int56',
+                                    internalType: "int56",
+                                    name: "tickSecondsAccum",
+                                    type: "int56",
                                 },
                                 {
-                                    internalType: 'int24',
-                                    name: 'tickAtPrice',
-                                    type: 'int24',
+                                    internalType: "int24",
+                                    name: "tickAtPrice",
+                                    type: "int24",
                                 },
                                 {
-                                    internalType: 'uint16',
-                                    name: 'protocolSwapFee0',
-                                    type: 'uint16',
+                                    internalType: "uint16",
+                                    name: "protocolSwapFee0",
+                                    type: "uint16",
                                 },
                                 {
-                                    internalType: 'uint16',
-                                    name: 'protocolSwapFee1',
-                                    type: 'uint16',
+                                    internalType: "uint16",
+                                    name: "protocolSwapFee1",
+                                    type: "uint16",
                                 },
                             ],
-                            internalType: 'struct PoolsharkStructs.RangePoolState',
-                            name: 'pool',
-                            type: 'tuple',
+                            internalType: "struct PoolsharkStructs.RangePoolState",
+                            name: "pool",
+                            type: "tuple",
                         },
                         {
                             components: [
                                 {
-                                    internalType: 'uint160',
-                                    name: 'price',
-                                    type: 'uint160',
+                                    internalType: "uint160",
+                                    name: "price",
+                                    type: "uint160",
                                 },
                                 {
-                                    internalType: 'uint128',
-                                    name: 'liquidity',
-                                    type: 'uint128',
+                                    internalType: "uint128",
+                                    name: "liquidity",
+                                    type: "uint128",
                                 },
                                 {
-                                    internalType: 'uint128',
-                                    name: 'protocolFees',
-                                    type: 'uint128',
+                                    internalType: "uint128",
+                                    name: "protocolFees",
+                                    type: "uint128",
                                 },
                                 {
-                                    internalType: 'uint16',
-                                    name: 'protocolFillFee',
-                                    type: 'uint16',
+                                    internalType: "uint16",
+                                    name: "protocolFillFee",
+                                    type: "uint16",
                                 },
                                 {
-                                    internalType: 'int24',
-                                    name: 'tickAtPrice',
-                                    type: 'int24',
+                                    internalType: "int24",
+                                    name: "tickAtPrice",
+                                    type: "int24",
                                 },
                             ],
-                            internalType: 'struct PoolsharkStructs.LimitPoolState',
-                            name: 'pool0',
-                            type: 'tuple',
+                            internalType: "struct PoolsharkStructs.LimitPoolState",
+                            name: "pool0",
+                            type: "tuple",
                         },
                         {
                             components: [
                                 {
-                                    internalType: 'uint160',
-                                    name: 'price',
-                                    type: 'uint160',
+                                    internalType: "uint160",
+                                    name: "price",
+                                    type: "uint160",
                                 },
                                 {
-                                    internalType: 'uint128',
-                                    name: 'liquidity',
-                                    type: 'uint128',
+                                    internalType: "uint128",
+                                    name: "liquidity",
+                                    type: "uint128",
                                 },
                                 {
-                                    internalType: 'uint128',
-                                    name: 'protocolFees',
-                                    type: 'uint128',
+                                    internalType: "uint128",
+                                    name: "protocolFees",
+                                    type: "uint128",
                                 },
                                 {
-                                    internalType: 'uint16',
-                                    name: 'protocolFillFee',
-                                    type: 'uint16',
+                                    internalType: "uint16",
+                                    name: "protocolFillFee",
+                                    type: "uint16",
                                 },
                                 {
-                                    internalType: 'int24',
-                                    name: 'tickAtPrice',
-                                    type: 'int24',
+                                    internalType: "int24",
+                                    name: "tickAtPrice",
+                                    type: "int24",
                                 },
                             ],
-                            internalType: 'struct PoolsharkStructs.LimitPoolState',
-                            name: 'pool1',
-                            type: 'tuple',
+                            internalType: "struct PoolsharkStructs.LimitPoolState",
+                            name: "pool1",
+                            type: "tuple",
                         },
                         {
-                            internalType: 'uint128',
-                            name: 'liquidityGlobal',
-                            type: 'uint128',
+                            internalType: "uint128",
+                            name: "liquidityGlobal",
+                            type: "uint128",
                         },
                         {
-                            internalType: 'uint32',
-                            name: 'positionIdNext',
-                            type: 'uint32',
+                            internalType: "uint32",
+                            name: "positionIdNext",
+                            type: "uint32",
                         },
                         {
-                            internalType: 'uint32',
-                            name: 'epoch',
-                            type: 'uint32',
+                            internalType: "uint32",
+                            name: "epoch",
+                            type: "uint32",
                         },
                         {
-                            internalType: 'uint8',
-                            name: 'unlocked',
-                            type: 'uint8',
+                            internalType: "uint8",
+                            name: "unlocked",
+                            type: "uint8",
                         },
                     ],
-                    stateMutability: 'view',
-                    type: 'function',
+                    stateMutability: "view",
+                    type: "function",
                 };
             }
             else {
                 return {
                     inputs: [],
-                    name: 'globalState',
+                    name: "globalState",
                     outputs: [
                         {
-                            internalType: 'uint160',
-                            name: 'price',
-                            type: 'uint160',
+                            internalType: "uint160",
+                            name: "price",
+                            type: "uint160",
                         },
                         {
-                            internalType: 'int24',
-                            name: 'tick',
-                            type: 'int24',
+                            internalType: "int24",
+                            name: "tick",
+                            type: "int24",
                         },
                         {
-                            internalType: 'int24',
-                            name: 'prevInitializedTick',
-                            type: 'int24',
+                            internalType: "int24",
+                            name: "prevInitializedTick",
+                            type: "int24",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'fee',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "fee",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'uint16',
-                            name: 'timepointIndex',
-                            type: 'uint16',
+                            internalType: "uint16",
+                            name: "timepointIndex",
+                            type: "uint16",
                         },
                         {
-                            internalType: 'uint8',
-                            name: 'communityFee',
-                            type: 'uint8',
+                            internalType: "uint8",
+                            name: "communityFee",
+                            type: "uint8",
                         },
                         {
-                            internalType: 'bool',
-                            name: 'unlocked',
-                            type: 'bool',
+                            internalType: "bool",
+                            name: "unlocked",
+                            type: "bool",
                         },
                     ],
-                    stateMutability: 'view',
-                    type: 'function',
+                    stateMutability: "view",
+                    type: "function",
                 };
             }
         };
-        this.getGlobalState = async (pool, currentExecutionContext, provider, rpc) => {
+        this.getGlobalState = async (pool, currentExecutionContext, provider) => {
             const slot0Abi = [this.getGlobalStateAbi()];
             const slot0 = await readContract({
                 address: pool,
                 abi: slot0Abi,
                 currentExecutionContext,
-                functionName: 'globalState',
+                functionName: "globalState",
                 provider,
-                rpc,
-                chainId: this.chainId,
             });
             if (this.isPoolSharkPool) {
                 return {
@@ -457,48 +451,65 @@ export class ExecutionApp extends ExecutionBase {
                 };
         };
         this.vault = config.vault;
-        this.steerSubgraph = config.steerSubgraph;
+        this.steerSubgraph = config.steerSubgraph ?? "";
         this.chainId = config.chainId;
-        this.isAlgebraPool = config.poolType.isAlgebraPool;
-        this.isAlgebraIntegralPool = config.poolType.isAlgebraIntegralPool;
-        this.isDirectionalPool = config.poolType.isDirectionalPool;
-        this.isPoolSharkPool = config.poolType.isPoolSharkPool;
-        this.isAerodromePool = config.poolType.isAerodromePool;
-        this.subgraphStudioKey = config.apiKeys.subgraphStudioKey;
-        this.sentioApiKey = config.apiKeys.sentioApiKey;
+        this.isAlgebraPool = config.poolType?.isAlgebraPool ?? false;
+        this.isAlgebraIntegralPool =
+            config.poolType?.isAlgebraIntegralPool ?? false;
+        this.isDirectionalPool = config.poolType?.isDirectionalPool ?? false;
+        this.isPoolSharkPool = config.poolType?.isPoolSharkPool ?? false;
+        this.isAerodromePool = config.poolType?.isAerodromePool ?? false;
+        this.sentioApiKey = config.apiKeys?.sentioApiKey ?? "";
         this.config = config;
     }
-    async execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig, forceDeposit) {
-        const dataConnector = new DataConnector(_wasmFile, _vaultConfig, this.config, _identity, _etherRpcConfig);
+    async execute(_wasmFile, _vaultConfig, _data, rpc, forceDeposit) {
+        if (!this.config.poolType) {
+            throw new Error("poolType is required by execute() for pool discovery.");
+        }
+        if (!this.steerSubgraph.trim()) {
+            throw new Error("steerSubgraph is required by execute() for pool discovery.");
+        }
+        const dataConnector = new DataConnector({
+            wasmFile: _wasmFile,
+            config: _vaultConfig,
+            executionConfig: this.config,
+            rpc,
+        });
         await dataConnector.loadSync();
         const executionContext = await this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
-        let rpc = '';
-        if (_etherRpcConfig) {
-            rpc = _etherRpcConfig[this.chainId.toString()].url;
-        }
-        const smartPoolExecutionContext = await this.getSmartPoolExecutionContext(executionContext, dataConnector, JSON.parse(_vaultConfig), rpc);
+        const smartPoolExecutionContext = await this.getSmartPoolExecutionContext(executionContext, dataConnector, JSON.parse(_vaultConfig));
         dataConnector.setExecutionContextStrategyExecution({
             ...executionContext,
             ...smartPoolExecutionContext,
         }, forceDeposit);
         _data = _data.map((element) => JSON.stringify(element));
         const result = await dataConnector.executeBundle(_data);
-        return JSON.parse(result);
+        return this.parseStrategyResult(result);
     }
     /**
-     * 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.
      */
     async executeWithContext(options) {
         const vaultConfig = this.parseVaultConfig(options.vaultConfig);
-        const executionContext = this.mapSdkExecutionContext(options.executionContext, vaultConfig);
-        const dataConnector = new DataConnector(options.wasmFile, options.vaultConfig, this.config, options.identity, options.etherRpcConfig);
+        this.validateExecutionContext(options.executionContext, vaultConfig);
+        const executionContext = {
+            ...options.executionContext,
+            positions: options.executionContext.positions.map((position) => ({
+                ...position,
+            })),
+        };
+        const dataConnector = new DataConnector({
+            wasmFile: options.wasmFile,
+            config: options.vaultConfig,
+            executionConfig: this.config,
+        });
         try {
             await dataConnector.loadSync();
-            dataConnector.setExecutionContextStrategyExecutionPinned(executionContext, options.forceDeposit);
+            dataConnector.initializeStrategyWithContext(executionContext, options.forceDeposit);
             const result = await dataConnector.executeBundle(options.data.map((item) => JSON.stringify(item)));
-            return JSON.parse(result);
+            return this.parseStrategyResult(result);
         }
         catch (error) {
             if (error instanceof ExecutionContextError)
@@ -506,98 +517,92 @@ export class ExecutionApp extends ExecutionBase {
             throw new StrategyExecutionError(this.redactError(error));
         }
     }
+    /** T is the complete decoded JSON result. Only the exact sentinel skips JSON decoding. */
+    parseStrategyResult(result) {
+        if (result === "continue")
+            return result;
+        try {
+            return JSON.parse(result);
+        }
+        catch (error) {
+            throw new StrategyExecutionError(this.redactError(error));
+        }
+    }
     parseVaultConfig(vaultConfig) {
         try {
             return JSON.parse(vaultConfig);
         }
         catch {
-            throw new ExecutionContextError('INVALID_EXECUTION_CONTEXT', 'vaultConfig must be valid JSON.');
+            throw new ExecutionContextError("INVALID_EXECUTION_CONTEXT", "vaultConfig must be valid JSON.");
         }
     }
-    mapSdkExecutionContext(context, vaultConfig) {
-        if (!context || typeof context !== 'object') {
-            throw new ExecutionContextError('INVALID_EXECUTION_CONTEXT', 'A successful SDK VaultExecutionContext is required.');
+    validateExecutionContext(context, vaultConfig) {
+        if (!context || typeof context !== "object") {
+            throw new ExecutionContextError("INVALID_EXECUTION_CONTEXT", "An execution context is required.");
         }
-        const requiredStringFields = [
-            'blockNumber',
-            'epochTimestamp',
-            'vaultAddress',
-            'totalAmount0',
-            'totalAmount1',
-        ];
-        for (const field of requiredStringFields) {
-            if (typeof context[field] !== 'string' || context[field].length === 0) {
-                throw new ExecutionContextError('INVALID_EXECUTION_CONTEXT', `SDK execution context has invalid ${field}.`);
-            }
-        }
-        if (!Number.isInteger(context.chainId) ||
+        if (!Number.isSafeInteger(context.chainId) ||
+            !Number.isSafeInteger(context.blockNumber) ||
+            context.blockNumber < 0 ||
+            !Number.isSafeInteger(context.epochTimestamp) ||
+            context.epochTimestamp < 0 ||
+            !Number.isSafeInteger(context.executionTimestamp) ||
+            context.executionTimestamp < 0 ||
+            context.executionTimestamp !== context.epochTimestamp * 1000 ||
+            !Number.isFinite(context.epochLength) ||
+            !Number.isFinite(context.blockTime) ||
             !Number.isInteger(context.currentTick) ||
-            !Number.isInteger(context.tickSpacing)) {
-            throw new ExecutionContextError('INVALID_EXECUTION_CONTEXT', 'SDK execution context has invalid chain or pool state.');
-        }
-        if (!Array.isArray(context.positions) ||
-            !/^\d+$/.test(context.blockNumber) ||
-            !/^\d+$/.test(context.epochTimestamp)) {
-            throw new ExecutionContextError('INVALID_EXECUTION_CONTEXT', 'SDK execution context has malformed anchor fields.');
-        }
-        if (!/^\d+$/.test(context.totalAmount0) || !/^\d+$/.test(context.totalAmount1)) {
-            throw new ExecutionContextError('INVALID_EXECUTION_CONTEXT', 'SDK execution context totals must be decimal strings.');
+            !Number.isInteger(context.tickSpacing) ||
+            typeof context.vaultAddress !== "string" ||
+            context.vaultAddress.length === 0 ||
+            typeof context.totalAmount0 !== "string" ||
+            !/^\d+$/.test(context.totalAmount0) ||
+            typeof context.totalAmount1 !== "string" ||
+            !/^\d+$/.test(context.totalAmount1) ||
+            !Array.isArray(context.positions) ||
+            !Number.isFinite(context.lastExecutionTime) ||
+            context.lastExecutionTime < 0) {
+            throw new ExecutionContextError("INVALID_EXECUTION_CONTEXT", "Execution context is malformed.");
         }
         const sameAddress = (left, right) => left?.toLowerCase() === right?.toLowerCase();
         if (!sameAddress(this.vault, context.vaultAddress) ||
             !sameAddress(vaultConfig.vaultAddress, context.vaultAddress)) {
-            throw new ExecutionContextError('EXECUTION_CONTEXT_MISMATCH', 'Supplied context vault does not match the execution request.');
+            throw new ExecutionContextError("EXECUTION_CONTEXT_MISMATCH", "Supplied context vault does not match the execution request.");
         }
         if (this.chainId !== context.chainId ||
-            (vaultConfig.chainId !== undefined && Number(vaultConfig.chainId) !== context.chainId)) {
-            throw new ExecutionContextError('EXECUTION_CONTEXT_MISMATCH', 'Supplied context chain does not match the execution request.');
+            (vaultConfig.chainId !== undefined &&
+                Number(vaultConfig.chainId) !== context.chainId)) {
+            throw new ExecutionContextError("EXECUTION_CONTEXT_MISMATCH", "Supplied context chain does not match the execution request.");
         }
-        if (vaultConfig.anchorBlockNumber !== undefined && String(vaultConfig.anchorBlockNumber) !== context.blockNumber) {
-            throw new ExecutionContextError('EXECUTION_CONTEXT_MISMATCH', 'Supplied context block does not match anchorBlockNumber.');
+        if (vaultConfig.anchorBlockNumber !== undefined &&
+            String(vaultConfig.anchorBlockNumber) !== String(context.blockNumber)) {
+            throw new ExecutionContextError("EXECUTION_CONTEXT_MISMATCH", "Supplied context block does not match anchorBlockNumber.");
         }
-        const epochLength = Number(vaultConfig.strategyConfigData?.epochLength);
-        if (!Number.isFinite(epochLength)) {
-            throw new ExecutionContextError('INVALID_EXECUTION_CONTEXT', 'vaultConfig.strategyConfigData.epochLength is required.');
+        if (Number(vaultConfig.strategyConfigData?.epochLength) !==
+            context.epochLength) {
+            throw new ExecutionContextError("EXECUTION_CONTEXT_MISMATCH", "Supplied context epoch length does not match vaultConfig.");
         }
         for (const position of context.positions) {
-            if (!Number.isInteger(position.lowerTick) ||
-                !Number.isInteger(position.upperTick) ||
-                !Number.isFinite(position.relativeWeight)) {
-                throw new ExecutionContextError('INVALID_EXECUTION_CONTEXT', 'SDK execution context contains an invalid position.');
+            if (!position ||
+                !Number.isInteger(position.startTick) ||
+                !Number.isInteger(position.endTick) ||
+                !Number.isFinite(position.weight)) {
+                throw new ExecutionContextError("INVALID_EXECUTION_CONTEXT", "Execution context contains an invalid position.");
             }
         }
-        // Null is deterministic: WASM receives zero elapsed seconds, never wall-clock time.
-        const lastExecutionTime = context.lastExecutionTimeSeconds === null ? 0 : Number(context.lastExecutionTimeSeconds);
-        if (!Number.isFinite(lastExecutionTime) || lastExecutionTime < 0) {
-            throw new ExecutionContextError('INVALID_EXECUTION_CONTEXT', 'SDK execution context has invalid lastExecutionTimeSeconds.');
-        }
-        return {
-            executionTimestamp: Number(context.epochTimestamp) * 1000,
-            epochTimestamp: Number(context.epochTimestamp),
-            epochLength,
-            vaultAddress: context.vaultAddress,
-            blockTime: 0,
-            blockNumber: Number(context.blockNumber),
-            currentTick: context.currentTick,
-            tickSpacing: context.tickSpacing,
-            positions: context.positions.map(({ lowerTick, upperTick, relativeWeight }) => ({
-                startTick: lowerTick,
-                endTick: upperTick,
-                weight: relativeWeight,
-            })),
-            totalAmount0: context.totalAmount0,
-            totalAmount1: context.totalAmount1,
-            lastExecutionTime,
-        };
     }
     redactError(error) {
         const message = error instanceof Error ? error.message : String(error);
         return message
-            .replace(/https?:\/\/[^\s@/]+(?::[^\s@/]+)?@/gi, 'https://[REDACTED]@')
-            .replace(/([?&](?:key|token|api[_-]?key|password)=)[^&\s]+/gi, '$1[REDACTED]');
+            .replace(/https?:\/\/[^\s@/]+(?::[^\s@/]+)?@/gi, "https://[REDACTED]@")
+            .replace(/([?&](?:key|token|api[_-]?key|password)=)[^&\s]+/gi, "$1[REDACTED]");
     }
-    async executeStabilityVault(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig, forceDeposit) {
-        const dataConnector = new DataConnector(_wasmFile, _vaultConfig, this.config, _identity, _etherRpcConfig);
+    async executeStabilityVault(_wasmFile, _vaultConfig, _data, rpc, forceDeposit) {
+        const dataConnector = new DataConnector({
+            wasmFile: _wasmFile,
+            config: _vaultConfig,
+            executionConfig: this.config,
+            rpc,
+        });
         await dataConnector.loadSync();
         const executionContext = await this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
         const dynamicJobExecutionContext = {};
@@ -607,15 +612,20 @@ export class ExecutionApp extends ExecutionBase {
         }, forceDeposit);
         _data = _data.map((element) => JSON.stringify(element));
         const result = await dataConnector.executeDynamicJobBundle(_data);
-        return JSON.parse(result);
+        return this.parseStrategyResult(result);
     }
-    async executeDynamicJobs(_wasmFile, _vaultConfig, _data, _job, _identity, _etherRpcConfig, forceDeposit) {
-        const dataConnector = new DataConnector(_wasmFile, _vaultConfig, this.config, _identity, _etherRpcConfig);
+    async executeDynamicJobs(_wasmFile, _vaultConfig, _data, _job, rpc, forceDeposit) {
+        const dataConnector = new DataConnector({
+            wasmFile: _wasmFile,
+            config: _vaultConfig,
+            executionConfig: this.config,
+            rpc,
+        });
         await dataConnector.loadSync();
         const executionContext = await this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
         const smartRewardsContractAddress = _job.targetAddresses[0];
         if (!smartRewardsContractAddress) {
-            throw new Error('Dynamic job must include at least one target address');
+            throw new Error("Dynamic job must include at least one target address");
         }
         const dynamicJobExecutionContext = {
             smartRewardsContractAddress,
@@ -626,18 +636,20 @@ export class ExecutionApp extends ExecutionBase {
         }, forceDeposit);
         _data = _data.map((element) => JSON.stringify(element));
         const result = await dataConnector.executeDynamicJobBundle(_data);
-        return JSON.parse(result);
+        return this.parseStrategyResult(result);
     }
-    async getSmartPoolExecutionContext(currentExecutionContext, dataConnector, vaultConfig, rpc) {
+    async getSmartPoolExecutionContext(currentExecutionContext, dataConnector, vaultConfig) {
         const smartPoolExecutionContext = {};
         const request = {
-            method: 'POST',
+            method: "POST",
             url: this.steerSubgraph,
             headers: {
-                'Content-Type': !this.steerSubgraph.includes('subgraph-proxy-server')
-                    ? 'application/json'
-                    : 'text/plain;charset=UTF-8',
-                ...(this.steerSubgraph.includes('sentio') ? { 'api-key': this.sentioApiKey } : {}),
+                "Content-Type": !this.steerSubgraph.includes("subgraph-proxy-server")
+                    ? "application/json"
+                    : "text/plain;charset=UTF-8",
+                ...(this.steerSubgraph.includes("sentio")
+                    ? { "api-key": this.sentioApiKey }
+                    : {}),
             },
             data: {
                 query: `
@@ -657,15 +669,17 @@ export class ExecutionApp extends ExecutionBase {
             },
         };
         const response = await fetchData(request, 4);
-        this.log('Subgraph response vault positions :', response);
+        this.log("Subgraph response vault positions :", response);
         const requestSnapshot = {
-            method: 'POST',
+            method: "POST",
             url: this.steerSubgraph,
             headers: {
-                'Content-Type': !this.steerSubgraph.includes('subgraph-proxy-server')
-                    ? 'application/json'
-                    : 'text/plain;charset=UTF-8',
-                ...(this.steerSubgraph.includes('sentio') ? { 'api-key': this.sentioApiKey } : {}),
+                "Content-Type": !this.steerSubgraph.includes("subgraph-proxy-server")
+                    ? "application/json"
+                    : "text/plain;charset=UTF-8",
+                ...(this.steerSubgraph.includes("sentio")
+                    ? { "api-key": this.sentioApiKey }
+                    : {}),
             },
             data: {
                 query: `
@@ -682,9 +696,10 @@ export class ExecutionApp extends ExecutionBase {
             },
         };
         const responseSnapshot = await fetchData(requestSnapshot, 4);
-        this.log('Subgraph response current snapshot', responseSnapshot);
+        this.log("Subgraph response current snapshot", responseSnapshot);
         const positions = [];
-        if (response?.data?.vaultPositions && response?.data?.vaultPositions.length > 0) {
+        if (response?.data?.vaultPositions &&
+            response?.data?.vaultPositions.length > 0) {
             const positionResponse = response?.data?.vaultPositions[0];
             for (let i = 0; i < positionResponse.upperTick.length; i++) {
                 const position = positionResponse;
@@ -696,25 +711,31 @@ export class ExecutionApp extends ExecutionBase {
             }
         }
         let lastSnapshot;
-        if (responseSnapshot?.data?.vaultSnapshots && responseSnapshot?.data?.vaultSnapshots.length > 0) {
+        if (responseSnapshot?.data?.vaultSnapshots &&
+            responseSnapshot?.data?.vaultSnapshots.length > 0) {
             lastSnapshot = responseSnapshot?.data?.vaultSnapshots[0];
         }
-        this.log('Subgraph response vault positions', positions);
+        this.log("Subgraph response vault positions", positions);
         smartPoolExecutionContext.positions = positions;
         if (lastSnapshot) {
-            smartPoolExecutionContext.lastExecutionTime = (Date.now() - Number(lastSnapshot.timestamp) * 1000) / 1000;
+            smartPoolExecutionContext.lastExecutionTime =
+                (Date.now() - Number(lastSnapshot.timestamp) * 1000) / 1000;
         }
         else {
-            smartPoolExecutionContext.lastExecutionTime = currentExecutionContext.epochTimestamp;
+            smartPoolExecutionContext.lastExecutionTime =
+                currentExecutionContext.epochTimestamp;
         }
-        const provider = dataConnector.getProvider(vaultConfig);
+        const provider = dataConnector.getClient();
         if (!provider) {
-            throw new Error('Provider configuration issue, unable to process Smart Pool execution context.');
+            throw new Error("Provider configuration issue, unable to process Smart Pool execution context.");
+        }
+        if ((await provider.getChainId()) !== currentExecutionContext.chainId) {
+            throw new Error("EXECUTION_CONTEXT_MISMATCH: provider chain does not match supplied context.");
         }
         const poolAddress = await this.getVaultPoolAddress();
-        const currentTick = await this.getPoolCurrentTick(poolAddress, provider, currentExecutionContext, rpc);
-        const tickSpacing = await this.getTickSpacing(poolAddress, provider, rpc, currentExecutionContext);
-        const totalAmounts = await this.getTotalAmounts(this.vault, currentExecutionContext, provider, rpc);
+        const currentTick = await this.getPoolCurrentTick(poolAddress, provider, currentExecutionContext);
+        const tickSpacing = await this.getTickSpacing(poolAddress, provider, currentExecutionContext);
+        const totalAmounts = await this.getTotalAmounts(this.vault, currentExecutionContext, provider);
         // Handle both bigint and serialized bigint from centralized API
         smartPoolExecutionContext.totalAmount0 = this.convertToString(totalAmounts.total0);
         smartPoolExecutionContext.totalAmount1 = this.convertToString(totalAmounts.total1);
@@ -723,58 +744,56 @@ export class ExecutionApp extends ExecutionBase {
         // "currentTick": 10,
         return smartPoolExecutionContext;
     }
-    async getPoolCurrentTick(poolAddress, provider, currentExecutionContext, rpc) {
+    async getPoolCurrentTick(poolAddress, provider, currentExecutionContext) {
         if (this.isAlgebraPool || this.isPoolSharkPool) {
-            const slot0 = await this.getGlobalState(poolAddress, currentExecutionContext, provider, rpc);
+            const slot0 = await this.getGlobalState(poolAddress, currentExecutionContext, provider);
             return slot0.tick;
         }
         else if (this.isAerodromePool) {
-            const slot0 = await this.getSlot0Aerodrome(poolAddress, currentExecutionContext, provider, rpc);
+            const slot0 = await this.getSlot0Aerodrome(poolAddress, currentExecutionContext, provider);
             return slot0.tick;
         }
         else {
-            const slot0 = await this.getSlot0(poolAddress, currentExecutionContext, provider, rpc);
+            const slot0 = await this.getSlot0(poolAddress, currentExecutionContext, provider);
             return slot0.tick;
         }
     }
-    async getTickSpacing(poolAddress, provider, rpc, currentExecutionContext) {
+    async getTickSpacing(poolAddress, provider, currentExecutionContext) {
         const tickSpacingAbi = [
             this.isPoolSharkPool
                 ? {
                     inputs: [],
-                    name: 'tickSpacing',
+                    name: "tickSpacing",
                     outputs: [
                         {
-                            internalType: 'int24',
-                            name: '',
-                            type: 'int24',
+                            internalType: "int24",
+                            name: "",
+                            type: "int24",
                         },
                     ],
-                    stateMutability: 'view',
-                    type: 'function',
+                    stateMutability: "view",
+                    type: "function",
                 }
                 : {
                     inputs: [],
-                    name: 'tickSpacing',
+                    name: "tickSpacing",
                     outputs: [
                         {
-                            internalType: 'int16',
-                            name: '',
-                            type: 'int16',
+                            internalType: "int16",
+                            name: "",
+                            type: "int16",
                         },
                     ],
-                    stateMutability: 'pure',
-                    type: 'function',
+                    stateMutability: "pure",
+                    type: "function",
                 },
         ];
         const tickSpacing = await readContract({
             address: poolAddress,
             abi: tickSpacingAbi,
             currentExecutionContext,
-            functionName: 'tickSpacing',
+            functionName: "tickSpacing",
             provider,
-            rpc,
-            chainId: this.chainId,
         });
         return tickSpacing;
     }
@@ -783,17 +802,17 @@ export class ExecutionApp extends ExecutionBase {
      * from the centralized API
      */
     convertToString(value) {
-        if (typeof value === 'bigint') {
+        if (typeof value === "bigint") {
             return value.toString();
         }
-        if (typeof value === 'number') {
+        if (typeof value === "number") {
             return value.toString();
         }
-        if (typeof value === 'string') {
+        if (typeof value === "string") {
             return value;
         }
         // Handle serialized bigint from centralized API (e.g., { type: 'BigNumber', hex: '0x...' })
-        if (value && typeof value === 'object') {
+        if (value && typeof value === "object") {
             // If it's a BigNumber-like object with hex property
             if (value.hex !== undefined) {
                 return BigInt(value.hex).toString();
@@ -803,34 +822,33 @@ export class ExecutionApp extends ExecutionBase {
                 return BigInt(value._hex).toString();
             }
             // If it has toString method, try using it
-            if (typeof value.toString === 'function' && value.toString() !== '[object Object]') {
+            if (typeof value.toString === "function" &&
+                value.toString() !== "[object Object]") {
                 return value.toString();
             }
         }
         // Fallback: convert to string (may result in '[object Object]' if not handled above)
         return String(value);
     }
-    async getTotalAmounts(vaultAddress, currentExecutionContext, provider, rpc) {
+    async getTotalAmounts(vaultAddress, currentExecutionContext, provider) {
         const getTotalAmountsABI = [
             {
                 inputs: [],
-                name: 'getTotalAmounts',
+                name: "getTotalAmounts",
                 outputs: [
-                    { internalType: 'uint256', name: 'total0', type: 'uint256' },
-                    { internalType: 'uint256', name: 'total1', type: 'uint256' },
+                    { internalType: "uint256", name: "total0", type: "uint256" },
+                    { internalType: "uint256", name: "total1", type: "uint256" },
                 ],
-                stateMutability: 'view',
-                type: 'function',
+                stateMutability: "view",
+                type: "function",
             },
         ];
         const totalAmounts = await readContract({
             address: vaultAddress,
             abi: getTotalAmountsABI,
             currentExecutionContext,
-            functionName: 'getTotalAmounts',
+            functionName: "getTotalAmounts",
             provider,
-            rpc,
-            chainId: this.chainId,
         });
         return {
             total0: totalAmounts[0],
@@ -839,7 +857,7 @@ export class ExecutionApp extends ExecutionBase {
     }
     async getVaultPoolAddress() {
         const requestSnapshot = {
-            method: 'POST',
+            method: "POST",
             url: this.steerSubgraph,
             data: {
                 query: `
@@ -852,10 +870,12 @@ export class ExecutionApp extends ExecutionBase {
               `,
             },
             headers: {
-                'Content-Type': !this.steerSubgraph.includes('subgraph-proxy-server')
-                    ? 'application/json'
-                    : 'text/plain;charset=UTF-8',
-                ...(this.steerSubgraph.includes('sentio') ? { 'api-key': this.sentioApiKey } : {}),
+                "Content-Type": !this.steerSubgraph.includes("subgraph-proxy-server")
+                    ? "application/json"
+                    : "text/plain;charset=UTF-8",
+                ...(this.steerSubgraph.includes("sentio")
+                    ? { "api-key": this.sentioApiKey }
+                    : {}),
             },
         };
         const response = await fetchData(requestSnapshot, 4);