@steerprotocol/data-connector-loader 2.1.1 → 3.0.1

package/lib/{base → esm/bundle}/bundleBase.d.ts

@@ -1,11 +1,11 @@
 import { WasmModule } from '@steerprotocol/app-loader';
-import { EtherRpcConfig, ExecutionContext } from '../types';
 import { providers } from 'ethers';
+import { EtherRpcConfig, ExecutionContext } from '../types';
 export declare class BundleBase {
-    protected module?: WasmModule;
+    module?: WasmModule;
     protected wasmFile: ArrayBuffer | string;
     protected config: string;
-    protected configObj: {
+    configObj: {
         [key: string]: any;
     };
     protected etherRpcConfig?: EtherRpcConfig;
@@ -13,12 +13,14 @@ export declare class BundleBase {
     executionContext?: ExecutionContext & {
         epochTimestamp: number;
     };
+    protected scheduleEpochTimestamp: number | undefined;
     constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: providers.Provider, etherRpcConfig?: EtherRpcConfig);
     load(): Promise<WasmModule>;
     loadSync(): WasmModule;
     execute(response: string): Promise<string>;
-    reset(): void;
-    setExecutionContext(executionContext: ExecutionContext): void;
+    executeBundle(data: Array<any>): Promise<string>;
+    setExecutionContextStrategyExecution(executionContext: ExecutionContext): void;
+    setExecutionContextDataConnector(executionContext: ExecutionContext): void;
     protected executeModule(response: string): Promise<string>;
     getProvider(config: any): providers.Provider | undefined;
     getResults(): string;

package/lib/esm/bundle/bundleBase.js

@@ -0,0 +1,127 @@
+import { loadWasm, loadWasmSync } from '@steerprotocol/app-loader';
+import { providers } from 'ethers';
+export class BundleBase {
+    constructor(wasmFile, _config, identity, etherRpcConfig) {
+        this.wasmFile = wasmFile;
+        this.config = _config;
+        this.configObj = JSON.parse(_config);
+        this.providerIdentity = identity;
+        this.etherRpcConfig = etherRpcConfig;
+    }
+    async load() {
+        const instance = await loadWasm(this.wasmFile, {});
+        this.module = instance;
+        this.module.initialize(this.config);
+        return this.module;
+    }
+    loadSync() {
+        if (typeof this.wasmFile === 'string')
+            throw new Error('Cannot load module synchronously unless wasmFile is of type ArrayBuffer');
+        this.module = loadWasmSync(this.wasmFile, {});
+        return this.module;
+    }
+    async execute(response) {
+        if (!this.executionContext) {
+            throw new Error('Execution context missing');
+        }
+        // If the module is not initialized, try to load it
+        if (!this.module) {
+            try {
+                await this.load();
+            }
+            catch {
+                throw new Error('Module not initialized');
+            }
+        }
+        // If the module is still not initialized, throw an error
+        if (!this.module)
+            throw new Error('Module not initialized');
+        // Call the main function with the response
+        return await this.module.execute(response);
+    }
+    async executeBundle(data) {
+        if (!this.executionContext) {
+            throw new Error('Execution context missing');
+        }
+        // If the module is not initialized, try to load it
+        if (!this.module) {
+            try {
+                await this.load();
+            }
+            catch {
+                throw new Error('Module not initialized');
+            }
+        }
+        // If the module is still not initialized, throw an error
+        if (!this.module)
+            throw new Error('Module not initialized');
+        // Call the main function with the response
+        return this.module.execute(...data);
+    }
+    setExecutionContextStrategyExecution(executionContext) {
+        // Determine the timestamp for epoch
+        const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
+        // Divide milliseconds data to seconds for transformation bundle
+        const timestampInSecs = Math.floor(timestamp / 1000);
+        this.executionContext = { ...executionContext, epochTimestamp: timestampInSecs };
+        const completeConfig = { ...JSON.parse(this.config), ...this.executionContext };
+        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
+        console.log('Complete execution config : ', completeConfig);
+        this.module?.initialize(JSON.stringify(completeConfig));
+    }
+    setExecutionContextDataConnector(executionContext) {
+        // Determine the timestamp for epoch
+        const timestamp = this.subtractDate(executionContext.executionTimestamp, Number(executionContext.epochLength)).getTime();
+        // Divide milliseconds data to seconds for transformation bundle
+        const timestampInSecs = Math.floor(timestamp / 1000);
+        this.executionContext = { ...executionContext, epochTimestamp: timestampInSecs };
+        const completeConfig = { ...JSON.parse(this.config), executionContext: this.executionContext };
+        this.scheduleEpochTimestamp = executionContext.epochTimestamp;
+        console.log('Complete execution config : ', completeConfig);
+        this.module?.initialize(JSON.stringify(completeConfig));
+    }
+    async executeModule(response) {
+        if (!this.module) {
+            throw new Error('Module not initialized');
+        }
+        return await this.module.execute(response);
+    }
+    // This function returns a provider based on the chainId of the request
+    // The chainId is first checked in the data connector config, and if not found
+    // it is checked in the request config. If the chainId is found in either of
+    // these places, the provider is returned from the etherRpcConfig object
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getProvider(config) {
+        let chainId;
+        // check if chainId is configured in data connector config
+        if (this.configObj.chainId) {
+            chainId = this.configObj.chainId;
+        }
+        else if (config && config.chainId) {
+            // if chainId is in the request config from dataconnector execution
+            chainId = config.chainId;
+        }
+        if (chainId && this.etherRpcConfig && this.etherRpcConfig[chainId]) {
+            const provider = new providers.JsonRpcProvider(this.etherRpcConfig[chainId].url);
+            return provider;
+        }
+        else {
+            return this.providerIdentity;
+        }
+    }
+    getResults() {
+        if (!this.module)
+            throw new Error('Module not initialized');
+        return this.module.transform();
+    }
+    version() {
+        if (!this.module)
+            throw new Error('Module not initialized');
+        return Number(this.module.version());
+    }
+    subtractDate(timestamp, epochLength) {
+        const date = new Date(timestamp);
+        date.setSeconds(date.getSeconds() - epochLength);
+        return date;
+    }
+}

package/lib/{bundle/bundleExecution.d.ts → esm/bundle/bundleDataConnector.d.ts}

@@ -1,7 +1,8 @@
 import { providers } from 'ethers';
-import { BundleBase } from './bundleBase';
 import { EtherRpcConfig, ViewConfig } from '../types';
+import { BundleBase } from './bundleBase';
 export declare class DataConnector extends BundleBase {
     constructor(wasmFile: string | ArrayBuffer, _config: string, identity?: providers.Provider, etherRpcConfig?: EtherRpcConfig);
+    getRpcUrl(config: any): string | undefined;
     view(config: ViewConfig): Promise<string>;
 }

package/lib/esm/bundle/bundleDataConnector.js

@@ -0,0 +1,57 @@
+import { Contract } from 'ethers';
+import { CENTRALIZE_CONTRACT_INTERACTION_CHAINS } from '../utils/consts';
+import { callWithRetry } from '../utils/utils';
+import { BundleBase } from './bundleBase';
+export class DataConnector extends BundleBase {
+    // Identity should come from the node's IdentityManager.wallet
+    constructor(wasmFile, _config, identity, etherRpcConfig) {
+        super(wasmFile, _config, identity, etherRpcConfig);
+    }
+    // get rpc url from configuration
+    getRpcUrl(config) {
+        let chainId;
+        // check if chainId is configured in data connector config
+        if (this.configObj.chainId) {
+            chainId = this.configObj.chainId;
+        }
+        else if (config && config.chainId) {
+            // if chainId is in the request config from dataconnector execution
+            chainId = config.chainId;
+        }
+        if (chainId && this.etherRpcConfig && this.etherRpcConfig[chainId]) {
+            return this.etherRpcConfig[chainId].url;
+        }
+        else {
+            return undefined;
+        }
+    }
+    // Makes contract instance and calls, returns stringified result
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async view(config) {
+        const provider = this.getProvider(config);
+        if (!provider)
+            throw new Error('Provider not initialized');
+        const contract = new Contract(config.address, config.abi, provider);
+        // For formatting the parameters if needed
+        const paramsArray = config.arguments;
+        let result;
+        if (CENTRALIZE_CONTRACT_INTERACTION_CHAINS.indexOf(this.configObj.chainId.toString()) === -1) {
+            result = await contract[config.method](...paramsArray, {
+                blockTag: this.executionContext?.blockNumber,
+            }); //@note uncomment for deterministic blocks
+        }
+        else {
+            const viewContractConfig = {
+                epochTimestamp: this.scheduleEpochTimestamp,
+                address: this.configObj.address || config.address,
+                abi: config.abi,
+                arguments: paramsArray,
+                method: config.method,
+                rpcUrl: this.getRpcUrl(config),
+            };
+            result = await callWithRetry(viewContractConfig);
+        }
+        // This gets stringified before calling main
+        return result;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { ethers } from 'ethers';
+import { EtherRpcConfig } from '../types';
+import { ExecutionBase } from './executionBase';
+export declare class ExecutionApp extends ExecutionBase {
+    steerSubgraph: string;
+    vault: string;
+    isAlgebraPool: 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.providers.Provider, _etherRpcConfig?: EtherRpcConfig): Promise<Array<T>>;
+    private getSmartPoolExecutionContext;
+    private getPoolCurrentTick;
+    private getVaultPoolAddress;
+    private getSlot0;
+    private getGlobalState;
+}

package/lib/esm/execution/executionApp.js

@@ -0,0 +1,304 @@
+import { DataConnector } from '../bundle/bundleDataConnector';
+import { fetchData, readSlot0Contract } from '../utils/utils';
+import { ExecutionBase } from './executionBase';
+export class ExecutionApp extends ExecutionBase {
+    constructor(vault, steerSubgraph, isAlgebraPool, isDirectionalPool, chainId, maxRetries = 3) {
+        super(maxRetries);
+        this.getSlot0 = async (pool, currentExecutionContext, provider, rpc) => {
+            const slot0Abi = [
+                {
+                    inputs: [],
+                    name: 'slot0',
+                    outputs: [
+                        { 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: 'observationCardinalityNext',
+                            type: 'uint16',
+                        },
+                        { internalType: 'uint8', name: 'feeProtocol', type: 'uint8' },
+                        { internalType: 'bool', name: 'unlocked', type: 'bool' },
+                    ],
+                    stateMutability: 'view',
+                    type: 'function',
+                },
+            ];
+            const slot0 = await readSlot0Contract({
+                address: pool,
+                abi: slot0Abi,
+                currentExecutionContext,
+                functionName: 'slot0',
+                provider: provider,
+                rpc,
+                chainId: this.chainId,
+            });
+            return {
+                sqrtPriceX96: slot0[0],
+                tick: slot0[1],
+                observationIndex: slot0[2],
+                observationCardinality: slot0[3],
+                observationCardinalityNext: slot0[4],
+                feeProtocol: slot0[5],
+                unlocked: slot0[6],
+            };
+        };
+        this.getGlobalState = async (pool, currentExecutionContext, provider, rpc) => {
+            const slot0Abi = [
+                !this.isDirectionalPool
+                    ? {
+                        inputs: [],
+                        name: 'globalState',
+                        outputs: [
+                            {
+                                internalType: 'uint160',
+                                name: 'price',
+                                type: 'uint160',
+                            },
+                            {
+                                internalType: 'int24',
+                                name: 'tick',
+                                type: 'int24',
+                            },
+                            {
+                                internalType: 'int24',
+                                name: 'prevInitializedTick',
+                                type: 'int24',
+                            },
+                            {
+                                internalType: 'uint16',
+                                name: 'fee',
+                                type: 'uint16',
+                            },
+                            {
+                                internalType: 'uint16',
+                                name: 'timepointIndex',
+                                type: 'uint16',
+                            },
+                            {
+                                internalType: 'uint8',
+                                name: 'communityFee',
+                                type: 'uint8',
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'unlocked',
+                                type: 'bool',
+                            },
+                        ],
+                        stateMutability: 'view',
+                        type: 'function',
+                    }
+                    : {
+                        inputs: [],
+                        name: 'globalState',
+                        outputs: [
+                            {
+                                internalType: 'uint160',
+                                name: 'price',
+                                type: 'uint160',
+                            },
+                            {
+                                internalType: 'int24',
+                                name: 'tick',
+                                type: 'int24',
+                            },
+                            {
+                                internalType: 'uint16',
+                                name: 'feeZto',
+                                type: 'uint16',
+                            },
+                            {
+                                internalType: 'uint16',
+                                name: 'feeOtz',
+                                type: 'uint16',
+                            },
+                            {
+                                internalType: 'uint16',
+                                name: 'timepointIndex',
+                                type: 'uint16',
+                            },
+                            {
+                                internalType: 'uint8',
+                                name: 'communityFeeToken0',
+                                type: 'uint8',
+                            },
+                            {
+                                internalType: 'uint8',
+                                name: 'communityFeeToken1',
+                                type: 'uint8',
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'unlocked',
+                                type: 'bool',
+                            },
+                        ],
+                        stateMutability: 'view',
+                        type: 'function',
+                    },
+            ];
+            const slot0 = await readSlot0Contract({
+                address: pool,
+                abi: slot0Abi,
+                currentExecutionContext,
+                functionName: 'globalState',
+                provider: provider,
+                rpc,
+                chainId: this.chainId,
+            });
+            return this.isDirectionalPool
+                ? {
+                    price: slot0[0],
+                    tick: slot0[1],
+                    observationIndex: slot0[2],
+                    observationCardinality: slot0[3],
+                    observationCardinalityNext: slot0[4],
+                    feeProtocol: slot0[5],
+                    unlocked: slot0[6],
+                }
+                : {
+                    price: slot0[0],
+                    tick: slot0[1],
+                    feeProtocol: slot0[2],
+                    observationIndex: slot0[2],
+                    observationCardinality: slot0[3],
+                    observationCardinalityNext: slot0[4],
+                    unlocked: slot0[6],
+                };
+        };
+        this.steerSubgraph = steerSubgraph;
+        this.vault = vault;
+        this.isAlgebraPool = isAlgebraPool;
+        this.isDirectionalPool = isDirectionalPool;
+        this.chainId = chainId;
+    }
+    async execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig) {
+        const dataConnector = new DataConnector(_wasmFile, _vaultConfig, _identity, _etherRpcConfig);
+        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);
+        dataConnector.setExecutionContextStrategyExecution({
+            ...executionContext,
+            ...smartPoolExecutionContext,
+        });
+        _data = _data.map((element) => JSON.stringify(element));
+        const result = await dataConnector.executeBundle(_data);
+        return JSON.parse(result);
+    }
+    async getSmartPoolExecutionContext(currentExecutionContext, dataConnector, vaultConfig, rpc) {
+        const smartPoolExecutionContext = {};
+        const request = {
+            method: 'POST',
+            url: this.steerSubgraph,
+            data: {
+                query: `
+                  {
+                      vaultPositions(where:{
+                          vault: "${this.vault}",
+                          timestamp_lt: "${currentExecutionContext.epochTimestamp}"
+                      }, orderDirection: desc, orderBy: timestamp, first: 1){
+                          id
+                          timestamp
+                          upperTick
+                          lowerTick
+                          relativeWeight
+                      }
+                  }
+              `,
+            },
+        };
+        const response = await fetchData(request, 4);
+        this.log('Subgraph response vault positions :', response);
+        const requestSnapshot = {
+            method: 'POST',
+            url: this.steerSubgraph,
+            data: {
+                query: `
+                  {
+                    vaultSnapshots(where:{
+                        vaultAddress: "${this.vault}",
+                        timestamp_lt: "${currentExecutionContext.epochTimestamp}"
+                    }, orderDirection: desc, orderBy: timestamp, first: 1){
+                        id
+                        timestamp
+                    }
+                }
+              `,
+            },
+        };
+        const responseSnapshot = await fetchData(requestSnapshot, 4);
+        this.log('Subgraph response current snapshot', responseSnapshot);
+        const positions = [];
+        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;
+                positions.push({
+                    startTick: Number(position.lowerTick[i]),
+                    endTick: Number(position.upperTick[i]),
+                    weight: Number(position.relativeWeight[i]),
+                });
+            }
+        }
+        let lastSnapshot;
+        if (responseSnapshot?.data?.vaultSnapshots && responseSnapshot?.data?.vaultSnapshots.length > 0) {
+            lastSnapshot = responseSnapshot?.data?.vaultSnapshots[0];
+        }
+        this.log('Subgraph response vault positions', positions);
+        smartPoolExecutionContext.positions = positions;
+        if (lastSnapshot) {
+            smartPoolExecutionContext.lastExecutionTime = (Date.now() - Number(lastSnapshot.timestamp) * 1000) / 1000;
+        }
+        else {
+            smartPoolExecutionContext.lastExecutionTime = currentExecutionContext.epochTimestamp;
+        }
+        const provider = dataConnector.getProvider(vaultConfig);
+        if (!provider) {
+            throw new Error('Provider configuration issue, unable to process Smart Pool execution context.');
+        }
+        const poolAddress = await this.getVaultPoolAddress();
+        const currentTick = await this.getPoolCurrentTick(poolAddress, provider, currentExecutionContext, rpc);
+        smartPoolExecutionContext.currentTick = currentTick;
+        // "currentTick": 10,
+        return smartPoolExecutionContext;
+    }
+    async getPoolCurrentTick(poolAddress, provider, currentExecutionContext, rpc) {
+        if (!this.isAlgebraPool) {
+            const slot0 = await this.getSlot0(poolAddress, currentExecutionContext, provider, rpc);
+            return slot0.tick;
+        }
+        else {
+            const slot0 = await this.getGlobalState(poolAddress, currentExecutionContext, provider, rpc);
+            return slot0.tick;
+        }
+    }
+    async getVaultPoolAddress() {
+        const requestSnapshot = {
+            method: 'POST',
+            url: this.steerSubgraph,
+            data: {
+                query: `
+            {
+                vault(id: "${this.vault}"){
+                    id
+                    pool
+                }
+            }
+              `,
+            },
+        };
+        const response = await fetchData(requestSnapshot, 4);
+        return response.data.vault.pool;
+    }
+}

package/lib/{loader/loaderBase.d.ts → esm/execution/executionBase.d.ts}

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

package/lib/esm/execution/executionBase.js

@@ -0,0 +1,95 @@
+export class ExecutionBase {
+    constructor(maxRetries = 3) {
+        this.maxRetries = 0;
+        this.maxRetries = maxRetries;
+    }
+    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);
+        }
+    }
+    async getExecutionContext(dataConnector, vaultConfig) {
+        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);
+            }
+        }
+        if (anchorProvided) {
+            blockNumber = anchorBlockNumber;
+        }
+        const context = {
+            executionTimestamp: new Date().getTime(),
+            epochTimestamp: vaultConfig.epochTimestamp,
+            epochLength: Number(vaultConfig.strategyConfigData.epochLength),
+            vaultAddress: vaultConfig.vaultAddress,
+            blockTime: blockTime,
+            blockNumber: blockNumber,
+        };
+        return context;
+    }
+    async execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig) {
+        throw new Error('Not implemented');
+    }
+    async getDataConnectorVersion(dataConnector) {
+        let version = 1;
+        try {
+            version = await dataConnector.version();
+        }
+        catch (e) {
+            // Data connector is missing version function, fallback to v1 logic
+        }
+        return version;
+    }
+    async getAverageBlockTime(provider, blockCount = 5) {
+        const latestBlock = await provider.getBlock('latest');
+        if (latestBlock) {
+            const startBlockNumber = Math.max(0, latestBlock.number - blockCount + 1);
+            let totalTimeDiff = 0;
+            let previousBlock = await provider.getBlock(startBlockNumber);
+            if (!previousBlock) {
+                return 0;
+            }
+            for (let i = startBlockNumber + 1; i <= latestBlock.number; i++) {
+                const currentBlock = await provider.getBlock(i);
+                if (!currentBlock || !previousBlock || !currentBlock.timestamp || !previousBlock.timestamp) {
+                    continue;
+                }
+                const timeDiff = currentBlock.timestamp - previousBlock.timestamp;
+                totalTimeDiff += timeDiff;
+                previousBlock = currentBlock;
+            }
+            const averageBlockTime = totalTimeDiff / (blockCount - 1);
+            return averageBlockTime;
+        }
+        else {
+            return 0;
+        }
+    }
+    async getBlockNumberFromAvgBlockTime(provider, targetTimestamp, avgBlockTime) {
+        const latestBlock = await provider.getBlock('latest');
+        const currentTime = Math.floor(Date.now() / 1000);
+        const timeDifference = currentTime - targetTimestamp;
+        if (!latestBlock) {
+            return 0;
+        }
+        if (avgBlockTime === 0) {
+            return latestBlock.number;
+        }
+        // Calculate the estimated number of blocks based on the average block time
+        const estimatedBlockCount = Math.floor(timeDifference / avgBlockTime);
+        // Calculate the estimated block number
+        const estimatedBlockNumber = latestBlock.number - estimatedBlockCount;
+        return Math.max(0, estimatedBlockNumber);
+    }
+}

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

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