@steerprotocol/data-connector-loader 3.1.1 → 3.2.1

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/providerUtils.d.ts

@@ -0,0 +1,4 @@
+import { ethers } from 'ethers';
+export declare const prioritizeRpcUrls: (urls: ReadonlyArray<string>) => Array<string>;
+export declare const getPrimaryRpcUrl: (urls: ReadonlyArray<string>) => string;
+export declare const createFallbackRpcProvider: (urls: ReadonlyArray<string>) => ethers.Provider;

package/lib/esm/utils/providerUtils.js

@@ -0,0 +1,37 @@
+import { ethers } from 'ethers';
+const UNSTABLE_RPC_PATTERNS = [/drpc\.org/i];
+const uniqueUrls = (urls) => {
+    const seen = new Set();
+    const normalized = [];
+    for (const url of urls) {
+        const trimmed = url.trim();
+        if (trimmed.length === 0 || seen.has(trimmed)) {
+            continue;
+        }
+        seen.add(trimmed);
+        normalized.push(trimmed);
+    }
+    return normalized;
+};
+const isDeprioritizedRpcUrl = (url) => UNSTABLE_RPC_PATTERNS.some((pattern) => pattern.test(url));
+export const prioritizeRpcUrls = (urls) => {
+    const normalized = uniqueUrls(urls);
+    const preferred = normalized.filter((url) => !isDeprioritizedRpcUrl(url));
+    const deprioritized = normalized.filter((url) => isDeprioritizedRpcUrl(url));
+    return preferred.length > 0 ? [...preferred, ...deprioritized] : normalized;
+};
+export const getPrimaryRpcUrl = (urls) => {
+    const prioritized = prioritizeRpcUrls(urls);
+    if (prioritized.length === 0) {
+        throw new Error('No RPC URLs configured');
+    }
+    return prioritized[0];
+};
+export const createFallbackRpcProvider = (urls) => {
+    const prioritized = prioritizeRpcUrls(urls);
+    if (prioritized.length === 0) {
+        throw new Error('No RPC URLs configured');
+    }
+    const providers = prioritized.map((url) => new ethers.JsonRpcProvider(url));
+    return providers.length === 1 ? providers[0] : new ethers.FallbackProvider(providers);
+};

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);