@steerprotocol/data-connector-loader 3.1.1 → 3.2.2

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

@@ -1,11 +1,11 @@
-import { ethers } from 'ethers';
-import { DataConnector } from '../bundle/bundleDataConnector';
-import { VaultConfigPayload, ExecutionContext, EtherRpcConfig } from '../types';
+import type { ethers } from 'ethers';
+import type { DataConnector } from '../bundle/bundleDataConnector.js';
+import type { EtherRpcConfig, ExecutionContext, VaultConfigPayload } from '../types.js';
 export declare class ExecutionBase {
     maxRetries: number;
     constructor(maxRetries?: number);
     protected delay(ms: number): Promise<void>;
-    protected log(...args: any[]): void;
+    protected log(...args: Array<any>): void;
     protected getExecutionContext(dataConnector: DataConnector, vaultConfig: VaultConfigPayload): Promise<ExecutionContext>;
     execute<T>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, _identity?: ethers.Provider, _etherRpcConfig?: EtherRpcConfig): Promise<Array<T>>;
     protected getDataConnectorVersion(dataConnector: DataConnector): Promise<number>;

package/lib/esm/execution/executionBase.js

@@ -6,7 +6,6 @@ export class ExecutionBase {
     delay(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     log(...args) {
         if (process.env.DEBUG === 'true') {
             console.log(...args);
@@ -16,25 +15,25 @@ export class ExecutionBase {
         const provider = dataConnector.getProvider({});
         let blockTime = 0;
         let blockNumber = 9;
-        const anchorBlockNumber = vaultConfig.anchorBlockNumber;
-        const anchorProvided = typeof anchorBlockNumber === 'number' && anchorBlockNumber >= 0;
-        if (provider) {
-            blockTime = await this.getAverageBlockTime(provider);
-            if (!anchorProvided) {
-                blockNumber = await this.getBlockNumberFromAvgBlockTime(provider, vaultConfig.epochTimestamp / 1000, // convert to seconds
-                blockTime);
+        // Use anchorBlockNumber if provided, otherwise calculate from average block time
+        if (vaultConfig.anchorBlockNumber !== undefined) {
+            blockNumber = vaultConfig.anchorBlockNumber;
+            if (provider) {
+                blockTime = await this.getAverageBlockTime(provider);
             }
         }
-        if (anchorProvided) {
-            blockNumber = anchorBlockNumber;
+        else if (provider) {
+            blockTime = await this.getAverageBlockTime(provider);
+            blockNumber = await this.getBlockNumberFromAvgBlockTime(provider, vaultConfig.epochTimestamp / 1000, // convert to seconds
+            blockNumber);
         }
         const context = {
             executionTimestamp: new Date().getTime(),
             epochTimestamp: vaultConfig.epochTimestamp,
             epochLength: Number(vaultConfig.strategyConfigData.epochLength),
             vaultAddress: vaultConfig.vaultAddress,
-            blockTime: blockTime,
-            blockNumber: blockNumber,
+            blockTime,
+            blockNumber,
         };
         return context;
     }

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

@@ -1,9 +1,11 @@
-import { ExecutionBase } from './executionBase';
-import { DataConnector } from '../bundle/bundleDataConnector';
+import type { DataConnector } from '../bundle/bundleDataConnector.js';
+import { ExecutionBase } from './executionBase.js';
 export declare class DataConnectorExecution extends ExecutionBase {
     private dataConnectors;
     constructor(dataConnectors: Array<DataConnector>, maxRetries?: number);
     execute<T>(_vaultConfig: string): Promise<Array<T>>;
+    private executeV2Bundle;
+    executeDynamicJob<T>(_vaultConfig: string): Promise<Array<T>>;
     private handleRequestResponse;
     private transformData;
 }

package/lib/esm/execution/executionDataConnector.js

@@ -1,6 +1,7 @@
-import { ExecutionBase } from './executionBase';
-import { PluginManager } from '../utils/pluginManager';
-import { extendOHLCV, fetchData } from '../utils/utils';
+import { PluginManager } from '../utils/pluginManager.js';
+import { changeUrlIfOld } from '../utils/replace-old-subgraphs.js';
+import { extendOHLCV, fetchData } from '../utils/utils.js';
+import { ExecutionBase } from './executionBase.js';
 export class DataConnectorExecution extends ExecutionBase {
     constructor(dataConnectors, maxRetries = 3) {
         super(maxRetries);
@@ -15,20 +16,55 @@ export class DataConnectorExecution extends ExecutionBase {
             if (!dataConnector.module) {
                 await dataConnector.load();
             }
-            const executionContext = await this.getExecutionContext(dataConnector, vaultConfig);
-            dataConnector.setExecutionContextDataConnector(executionContext);
-            const version = await this.getDataConnectorVersion(dataConnector);
-            if (version === 1) {
-                const initialRequest = await dataConnector.execute('');
-                const finalResponse = await this.handleRequestResponse(dataConnector, pluginManager, initialRequest);
-                const transformedData = await this.transformData(dataConnector, finalResponse);
-                transformationData.push(transformedData);
+            let version = 1;
+            try {
+                version = dataConnector.version();
+            }
+            catch (e) {
+                version = 1;
+            }
+            if (version >= 2) {
+                const transformData = await this.executeV2Bundle(dataConnector, vaultConfig);
+                transformationData.push(transformData);
             }
             else {
-                const finalResponse = await dataConnector.execute('');
-                const transformedData = await this.transformData(dataConnector, finalResponse);
-                transformationData.push(transformedData);
+                try {
+                    const executionContext = await this.getExecutionContext(dataConnector, vaultConfig);
+                    dataConnector.setExecutionContextDataConnector(executionContext);
+                    const initialRequest = await dataConnector.execute('');
+                    const finalResponse = await this.handleRequestResponse(dataConnector, pluginManager, initialRequest);
+                    const transformedData = await this.transformData(dataConnector, finalResponse);
+                    transformationData.push(transformedData);
+                }
+                catch (e) {
+                    const transformData = await this.executeV2Bundle(dataConnector, vaultConfig);
+                    transformationData.push(transformData);
+                }
+            }
+        }
+        return transformationData;
+    }
+    async executeV2Bundle(dataConnector, vaultConfig) {
+        const executionContext = await this.getExecutionContext(dataConnector, vaultConfig);
+        dataConnector.setExecutionContextDataConnector(executionContext);
+        await dataConnector.execute('');
+        const result = await dataConnector.transform();
+        return JSON.parse(result);
+    }
+    async executeDynamicJob(_vaultConfig) {
+        const vaultConfig = JSON.parse(_vaultConfig);
+        const transformationData = [];
+        const pluginManager = new PluginManager();
+        await pluginManager.registerFromPublicConfig();
+        for (const dataConnector of this.dataConnectors) {
+            if (!dataConnector.module) {
+                await dataConnector.load();
             }
+            const executionContext = await this.getExecutionContext(dataConnector, vaultConfig);
+            dataConnector.setExecutionContextDataConnector(executionContext);
+            await dataConnector.execute('');
+            const result = await dataConnector.transform();
+            transformationData.push(JSON.parse(result));
         }
         return transformationData;
     }
@@ -42,6 +78,12 @@ export class DataConnectorExecution extends ExecutionBase {
                 }
                 else {
                     const parsedRequest = await pluginManager.process(typeof request == 'string' ? JSON.parse(request) : request);
+                    const url = changeUrlIfOld(parsedRequest.url, dataConnector.configObj.subgraphStudioKey);
+                    parsedRequest.url = url;
+                    parsedRequest.headers = {
+                        'Content-Type': url && !url.includes('subgraph-proxy-server') ? 'application/json' : 'text/plain;charset=UTF-8',
+                        ...(url?.includes('sentio') ? { 'api-key': dataConnector.executionAppConfig.apiKeys.sentioApiKey } : {}),
+                    };
                     await this.delay(1000);
                     response = await fetchData(parsedRequest, 0);
                 }
@@ -57,19 +99,8 @@ export class DataConnectorExecution extends ExecutionBase {
         }
         return dataConnector.getResults();
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async transformData(dataConnector, rawData) {
         let transformedData = typeof rawData === 'string' ? JSON.parse(rawData) : rawData;
-        if (transformedData == null || transformedData.length == 0) {
-            const results = dataConnector.getResults();
-            const parsedResults = JSON.parse(results);
-            if (parsedResults.length == null) {
-                transformedData = results;
-            }
-            else {
-                transformedData = parsedResults;
-            }
-        }
         const version = await this.getDataConnectorVersion(dataConnector);
         if (version == 1 && transformedData.length > 0) {
             const keys = Object.keys(transformedData[0]);

package/lib/esm/index.d.ts

@@ -1,5 +1,7 @@
-import { DataConnector } from './bundle/bundleDataConnector';
-import { DataConnectorExecution } from './execution/executionDataConnector';
-import { ExecutionApp } from './execution/executionApp';
-export * from './types';
+import { DataConnector } from './bundle/bundleDataConnector.js';
+import { ExecutionApp, type ExecutionAppConfig } from './execution/executionApp.js';
+import { DataConnectorExecution } from './execution/executionDataConnector.js';
+import type { VaultConfigPayload } from './types.js';
+export type * from './types.js';
 export { DataConnector, DataConnectorExecution, ExecutionApp };
+export type { ExecutionAppConfig, VaultConfigPayload };

package/lib/esm/index.js

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

package/lib/esm/types.d.ts

@@ -1,4 +1,4 @@
-import { InterfaceAbi } from 'ethers';
+import type { InterfaceAbi } from 'ethers';
 export type VaultInput = {
     _id?: string;
     tokenId: string;
@@ -23,7 +23,7 @@ export type VaultInput = {
 export interface VaultConfigPayload {
     strategyConfigData: StrategyConfigData;
     vaultPayload: VaultPayload;
-    dataConnectorsData: DataConnectorsDaum[];
+    dataConnectorsData: Array<DataConnectorsDaum>;
     vaultAddress: string;
     epochTimestamp: number;
     anchorBlockNumber?: number;
@@ -63,12 +63,16 @@ export interface Position {
     weight: number;
 }
 export interface SmartPoolExecutionContext extends ExecutionContext {
-    positions: Position[];
+    positions: Array<Position>;
     currentTick: number;
     lastExecutionTime: number;
+    totalAmount0: string;
+    totalAmount1: string;
+    tickSpacing: number;
 }
 export type RpcConfig = {
     url: string;
+    urls?: ReadonlyArray<string>;
     network?: string;
 };
 export type EtherRpcConfig = {
@@ -78,7 +82,7 @@ export interface ViewConfig {
     address: string;
     abi: InterfaceAbi;
     method: string;
-    arguments: unknown[];
+    arguments: Array<unknown>;
 }
 export interface Slot0 {
     sqrtPriceX96?: bigint;
@@ -102,3 +106,12 @@ export type ViewContractConfig = {
     method: string;
     rpcUrl?: string;
 };
+export type JobDetails = {
+    id: string;
+    name: string;
+    timestamp: string;
+    jobInfo: ReadonlyArray<unknown>;
+    targetAddresses: ReadonlyArray<string>;
+    ipfsHash: string;
+    status: string;
+};

package/lib/esm/utils/blockFinder.d.ts

@@ -1,4 +1,4 @@
-import { ethers } from 'ethers';
+import type { ethers } from 'ethers';
 /**
  * Iterates down from current block to find the block previous or equal to the given timestamp
  * Not the most efficient for far past timestamps, a binary search could be used for better performance

package/lib/esm/utils/consts.js

@@ -1,4 +1,46 @@
 export const API_BASE_URL = 'https://cvrlulno2m.execute-api.ap-southeast-1.amazonaws.com/dev/contract-view-call';
+// export const API_BASE_URL = "http://localhost:3000/dev/contract-view-call";
 export const API_MAX_RETRIES = 3;
 export const API_INITIAL_DELAY = 1000;
-export const CENTRALIZE_CONTRACT_INTERACTION_CHAINS = ['2222', '42161', '9001', '137', '56'];
+export const CENTRALIZE_CONTRACT_INTERACTION_CHAINS = [
+    '999',
+    '43114',
+    '6900',
+    '5464',
+    '2020',
+    '747474',
+    '1116',
+    '43111',
+    '80094',
+    '129399',
+    '130',
+    '146',
+    '1868',
+    '1',
+    '80084',
+    '2222',
+    '1329',
+    '1284',
+    '42161',
+    '9001',
+    '137',
+    '56',
+    '5000',
+    '250',
+    '3776',
+    '81457',
+    '592',
+    '1088',
+    '34443',
+    // "8453",
+    '30',
+    // "8453",
+    '167000',
+    '196',
+    '810180',
+    '137',
+    '314',
+    '33139',
+    '7000',
+    '3338',
+];

package/lib/esm/utils/pluginManager.d.ts

@@ -1,4 +1,4 @@
-import { AxiosRequestConfig } from 'axios';
+import type { AxiosRequestConfig } from 'axios';
 export declare class PluginManager {
     private registeredPluginConfigs;
     constructor();

package/lib/esm/utils/replace-old-subgraphs.d.ts

@@ -0,0 +1,23 @@
+export interface SubgraphUrlConfig {
+    chain: string;
+    protocol: string;
+    newUrl: string;
+    oldUrl: string;
+}
+export interface SubgraphReplacerConfig {
+    subgraphStudioKey?: string;
+    customConfigs?: Array<SubgraphUrlConfig>;
+}
+export declare class SubgraphUrlReplacer {
+    private readonly subgraphStudioKey;
+    private readonly subgraphUrlConfigs;
+    constructor(config?: SubgraphReplacerConfig);
+    changeUrlIfOld(url?: string): string | undefined;
+    private getArbitrumSubgraphUrl;
+    private getDefaultConfigs;
+}
+/**
+ * Convenience function that uses the default SubgraphUrlReplacer instance
+ * For custom configuration, create a new SubgraphUrlReplacer instance
+ */
+export declare const changeUrlIfOld: (url?: string, subgraphStudioKey?: string) => string | undefined;

package/lib/esm/utils/replace-old-subgraphs.js

@@ -0,0 +1,123 @@
+export class SubgraphUrlReplacer {
+    constructor(config) {
+        this.subgraphStudioKey = config?.subgraphStudioKey ?? '';
+        this.subgraphUrlConfigs = config?.customConfigs || this.getDefaultConfigs();
+    }
+    changeUrlIfOld(url) {
+        const subgraphUrl = this.subgraphUrlConfigs.find(({ oldUrl }) => url === oldUrl);
+        if (subgraphUrl) {
+            return subgraphUrl.newUrl;
+        }
+        return url;
+    }
+    getArbitrumSubgraphUrl(subgraphId, isDeploymentId) {
+        return `https://gateway-arbitrum.network.thegraph.com/api/${this.subgraphStudioKey}/${isDeploymentId ? 'deployments' : 'subgraphs'}/id/${subgraphId}`;
+    }
+    getDefaultConfigs() {
+        return [
+            {
+                chain: 'polygon',
+                protocol: 'quickswap',
+                newUrl: this.getArbitrumSubgraphUrl(`FqsRcH1XqSjqVx9GRTvEJe959aCbKrcyGgDWBrUkG24g`, false),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/sameepsi/quickswap-v3',
+            },
+            {
+                chain: 'polygon',
+                protocol: 'uniswap',
+                newUrl: this.getArbitrumSubgraphUrl(`3hCPRGf4z88VC5rsBKU5AA9FBBq5nF3jbKJG7VZCbhjm`, false),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/ianlapham/uniswap-v3-polygon',
+            },
+            {
+                chain: 'optimism',
+                protocol: 'uniswap',
+                newUrl: this.getArbitrumSubgraphUrl(`Cghf4LfVqPiFw6fp6Y5X5Ubc8UpmUhSfJL82zwiBFLaj`, false),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/ianlapham/optimism-post-regenesis',
+            },
+            {
+                chain: 'arbitrum',
+                protocol: 'uniswap',
+                newUrl: this.getArbitrumSubgraphUrl(`FbCGRftH4a3yZugY7TnbYgPJVEv2LvMT6oF1fxPe9aJM`, false),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/ianlapham/arbitrum-dev',
+            },
+            {
+                chain: 'celo',
+                protocol: 'uniswap',
+                newUrl: this.getArbitrumSubgraphUrl(`ESdrTJ3twMwWVoQ1hUE2u7PugEHX3QkenudD6aXCkDQ4`, false),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/jesse-sawa/uniswap-celo',
+            },
+            {
+                chain: 'base',
+                protocol: 'baseswap',
+                newUrl: 'https://api.goldsky.com/api/public/project_cltceeuudv1ij01x7ekxhfl46/subgraphs/v3-base/prod/gn',
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/harleen-m/basex',
+            },
+            {
+                chain: 'arbitrum',
+                protocol: 'sushi',
+                newUrl: this.getArbitrumSubgraphUrl('QmevuQAmgiou1UX7Z2BQf6RKdX1WunQjH8VtawhkzSLj4V', true),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-arbitrum',
+            },
+            {
+                chain: 'avalanche',
+                protocol: 'sushi',
+                newUrl: this.getArbitrumSubgraphUrl('Qmcdd4SGVwG9VY4itrXBnBPWBVsQvsxfzaib9bVny9C8jT', true),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-avalanche',
+            },
+            {
+                chain: 'bsc',
+                protocol: 'sushi',
+                newUrl: this.getArbitrumSubgraphUrl('QmXsPN4TD4PUhT1ZWd5d1mdQPePFNMdJwUr6guSh1z9ZzA', true),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-bsc',
+            },
+            {
+                chain: 'base',
+                protocol: 'sushi',
+                newUrl: this.getArbitrumSubgraphUrl('QmZ2R9ABG9ienaZdGyPLcDWDNDkG187RhXmh6fFuEtUaaS', true),
+                oldUrl: 'https://api.studio.thegraph.com/query/32073/v3-base/v0.0.1',
+            },
+            {
+                chain: 'optimism',
+                protocol: 'sushi',
+                newUrl: this.getArbitrumSubgraphUrl('QmbT6ZsxJEZKUrbzLrAWV5EnQfSKZeYtZ265mQUaB552vK', true),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-optimism',
+            },
+            {
+                chain: 'polygon',
+                protocol: 'sushi',
+                newUrl: this.getArbitrumSubgraphUrl('QmPbbjK9vtY69kSxMJRVLVz1dRzUBNwYbWTRYMiFzp9Tzm', true),
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/sushi-v3/v3-polygon',
+            },
+            {
+                chain: 'zkevm',
+                protocol: 'sushi',
+                newUrl: this.getArbitrumSubgraphUrl('QmWH5ChjmF4Yp5Yhiaxczh5QwbG6HFSEi8bRwbKaUrJA6C', true),
+                oldUrl: 'https://api.studio.thegraph.com/query/32073/v3-polygon-zkevm/v0.0.2',
+            },
+            {
+                chain: 'arbitrum',
+                protocol: 'camelot',
+                newUrl: 'https://subgraph-proxy-server-xf2uthetka-as.a.run.app/gateway-arbitrum/3utanEBA9nqMjPnuQP1vMCCys6enSM3EawBpKTVwnUw2',
+                oldUrl: 'https://api.thegraph.com/subgraphs/name/camelotlabs/camelot-amm-v3',
+            },
+            {
+                chain: 'mode',
+                protocol: 'swapmode',
+                newUrl: 'https://api.goldsky.com/api/public/project_cltceeuudv1ij01x7ekxhfl46/subgraphs/swapmode-v3/prod/gn',
+                oldUrl: 'https://api.goldsky.com/api/public/project_cltceeuudv1ij01x7ekxhfl46/subgraphs/swapmode-v3/1.0.0/gn',
+            },
+            {
+                chain: 'linea',
+                protocol: 'lynex',
+                newUrl: 'https://api.goldsky.com/api/public/project_cltyhthusbmxp01s95k9l8a1u/subgraphs/lynex-cl/v1.0.2/gn',
+                oldUrl: 'https://graph-query.linea.build/subgraphs/name/cryptoalgebra/analytics',
+            },
+        ];
+    }
+}
+/**
+ * Convenience function that uses the default SubgraphUrlReplacer instance
+ * For custom configuration, create a new SubgraphUrlReplacer instance
+ */
+export const changeUrlIfOld = (url, subgraphStudioKey) => {
+    return new SubgraphUrlReplacer({ subgraphStudioKey }).changeUrlIfOld(url);
+};

package/lib/esm/utils/utils.d.ts

@@ -1,16 +1,17 @@
-import { Candle } from '@steerprotocol/app-loader';
-import { AxiosRequestConfig } from 'axios';
-import { ExecutionContext, ViewContractConfig } from '../types';
-import { Provider } from 'ethers';
-export declare const extendOHLCV: (rawData: Candle[], period: number, endTimestamp: number) => Candle[];
+import type { Candle } from '@steerprotocol/app-loader';
+import type { AxiosRequestConfig } from 'axios';
+import { type Provider } from 'ethers';
+import type { ExecutionContext, ViewContractConfig } from '../types.js';
+export declare const extendOHLCV: (rawData: Array<Candle>, period: number, endTimestamp: number) => Array<Candle>;
 export declare function fetchData(request: AxiosRequestConfig, attempts: number): Promise<any>;
-export declare function readSlot0Contract({ address, abi, currentExecutionContext, functionName, provider, rpc, chainId, }: {
+export declare function readContract({ abi, address, chainId, contractArguments, currentExecutionContext, functionName, provider, rpc, }: {
     address: string;
     abi: any;
     currentExecutionContext: ExecutionContext;
     functionName: string;
     provider: Provider;
     rpc: string;
+    contractArguments?: Array<any>;
     chainId: number;
 }): Promise<any>;
 export declare function callWithRetry(config: ViewContractConfig): Promise<any>;

package/lib/esm/utils/utils.js

@@ -1,6 +1,6 @@
 import axios from 'axios';
 import { Contract } from 'ethers';
-import { API_BASE_URL, API_INITIAL_DELAY, API_MAX_RETRIES, CENTRALIZE_CONTRACT_INTERACTION_CHAINS } from './consts';
+import { API_BASE_URL, API_INITIAL_DELAY, API_MAX_RETRIES, CENTRALIZE_CONTRACT_INTERACTION_CHAINS } from './consts.js';
 // The purpose of this function is to look at the end timestamp and extend the current candle array so that it backfills any missing candles up to the end timestamp
 export const extendOHLCV = (rawData, period, endTimestamp) => {
     // Sort rawData by timestamp
@@ -61,14 +61,13 @@ export async function fetchData(request, attempts) {
         }
     }
 }
-export async function readSlot0Contract({ address, abi, currentExecutionContext, functionName, provider, rpc, chainId, }) {
+export async function readContract({ abi, address, chainId, contractArguments = [], currentExecutionContext, functionName, provider, rpc, }) {
     // Create a new contract instance
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     if (!provider)
         throw new Error('Provider not initialized');
     const contract = new Contract(address, abi, provider);
     // For formatting the parameters if needed
-    const paramsArray = [];
+    const paramsArray = contractArguments || [];
     // Calculate block number for determinism
     // Best way to handle contextually non-null values?
     // const syncedBlock = await getBlockFromTimestamp(this.executionContext!.epochTimestamp, this.providerIdentity!) //@note uncomment for deterministic blocks
@@ -78,13 +77,14 @@ export async function readSlot0Contract({ address, abi, currentExecutionContext,
     if (CENTRALIZE_CONTRACT_INTERACTION_CHAINS.indexOf(chainId.toString()) === -1) {
         result = await contract[functionName](...paramsArray, {
             blockTag: currentExecutionContext?.blockNumber,
-        }); //@note uncomment for deterministic blocks
+        }); // @note uncomment for deterministic blocks
     }
     else {
+        console.log('Calling the centralized view');
         const viewContractConfig = {
             epochTimestamp: currentExecutionContext.epochTimestamp,
-            address: address,
-            abi: abi,
+            address,
+            abi,
             arguments: paramsArray,
             method: functionName,
             rpcUrl: rpc,
@@ -103,7 +103,7 @@ export async function callWithRetry(config) {
             return JSON.parse(response.data); // Return the data if the call was successful
         }
         catch (error) {
-            console.error(`Attempt ${retries + 1} failed. Retrying in to fetch the contract method ${config.method} ${delay / 1000} seconds...`);
+            console.error(`Attempt ${retries + 1} failed. Retrying in to fetch the contract method ${config.method} ${delay / 1000} seconds...`, error);
             await new Promise((resolve) => setTimeout(resolve, delay));
             delay *= 2; // Double the delay for the next retry
             retries++;
@@ -111,7 +111,6 @@ export async function callWithRetry(config) {
     }
     throw new Error(`Failed after ${API_MAX_RETRIES} attempts. to call method ${config.method}`);
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function log(...args) {
     if (process.env.DEBUG === 'true') {
         console.log(...args);

package/lib/execution/executionApp.d.ts

@@ -1,17 +1,62 @@
-import { ethers } from 'ethers';
-import { EtherRpcConfig } from '../types';
-import { ExecutionBase } from './executionBase';
-export declare class ExecutionApp extends ExecutionBase {
+import type { ethers } from 'ethers';
+import type { EtherRpcConfig, JobDetails } 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: {
+        /** Set true when the pool uses Algebra v1 semantics. */
+        isAlgebraPool: boolean;
+        /** Set true when the pool uses Algebra Integral semantics. */
+        isAlgebraIntegralPool: boolean;
+        /** Set true when the pool uses directional pool semantics. */
+        isDirectionalPool: boolean;
+        /** Set true when the pool uses PoolShark semantics. */
+        isPoolSharkPool: boolean;
+        /** Set true when the pool uses Aerodrome semantics. */
+        isAerodromePool: boolean;
+    };
+    apiKeys: {
+        /** API key for The Graph Studio / gateway endpoints. */
+        subgraphStudioKey: string;
+        /** API key for Sentio endpoints, if applicable. */
+        sentioApiKey: string;
+    };
+    /** Maximum number of retries for execution operations. */
+    maxRetries?: number;
+}
+export declare class ExecutionApp extends ExecutionBase {
     vault: string;
+    steerSubgraph: string;
+    chainId: number;
     isAlgebraPool: boolean;
+    isAlgebraIntegralPool: boolean;
     isDirectionalPool: boolean;
-    chainId: number;
-    constructor(vault: string, steerSubgraph: string, isAlgebraPool: boolean, isDirectionalPool: boolean, chainId: number, maxRetries?: number);
-    execute<T>(_wasmFile: string | ArrayBuffer, _vaultConfig: string, _data: Array<any>, _identity?: ethers.Provider, _etherRpcConfig?: EtherRpcConfig): Promise<Array<T>>;
+    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>>;
+    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>>;
     private getSmartPoolExecutionContext;
     private getPoolCurrentTick;
+    private getTickSpacing;
+    /**
+     * Converts a value to string, handling both native bigint and serialized bigint objects
+     * from the centralized API
+     */
+    private convertToString;
+    private getTotalAmounts;
     private getVaultPoolAddress;
     private getSlot0;
+    private getSlot0Aerodrome;
+    private getGlobalStateAbi;
     private getGlobalState;
 }