@steerprotocol/data-connector-loader 0.1.5 → 1.0.0

package/lib/esm/utils/pluginManager.js

@@ -0,0 +1,67 @@
+import axios from 'axios';
+export class PluginManager {
+    constructor() {
+        this.registeredPluginConfigs = [];
+    }
+    async registerFromPublicConfig() {
+        const { data: dataConnectorPlugins } = await axios.get('https://ro81h8hq6b.execute-api.us-east-1.amazonaws.com/data-connector-plugins');
+        for (const plugin of dataConnectorPlugins) {
+            this.registerPluginConfig(plugin.name, plugin.domain, plugin.headers);
+        }
+    }
+    registerPluginConfig(name, domain, headers) {
+        this.registeredPluginConfigs.push({ name, domain, headers });
+    }
+    findMatchingPluginConfigs(url) {
+        const matchingHeaders = {};
+        for (const pluginConfig of this.registeredPluginConfigs) {
+            if (url.includes(pluginConfig.domain)) {
+                Object.assign(matchingHeaders, pluginConfig.headers);
+            }
+        }
+        return matchingHeaders;
+    }
+    interpolateEnvVars(str) {
+        return str.replace(/\{\{(\w+)\}\}/g, (_match, envVar) => {
+            const envValue = process.env[envVar];
+            if (envValue === undefined) {
+                console.log(`Environment variable '${envVar}' not found.`);
+                return '';
+            }
+            return envValue;
+        });
+    }
+    interpolateHeaders(headers) {
+        const interpolatedHeaders = {};
+        for (const [key, value] of Object.entries(headers)) {
+            interpolatedHeaders[key] = typeof value === 'string' ? this.interpolateEnvVars(value) : value;
+        }
+        return interpolatedHeaders;
+    }
+    async process(config) {
+        if (!config.url) {
+            throw new Error('Request URL is not provided');
+        }
+        const matchingHeaders = this.findMatchingPluginConfigs(config.url);
+        const interpolatedHeaders = this.interpolateHeaders(matchingHeaders);
+        const updatedHeaders = { ...config.headers, ...interpolatedHeaders };
+        const updatedConfig = {
+            ...config,
+            headers: updatedHeaders,
+        };
+        return updatedConfig;
+    }
+}
+// // Usage example:
+// (async () => {
+//   const headerMerger = new PluginManager();
+//   headerMerger.registerPluginConfig('Example API', 'example.com', { 'X-Custom-Header': '{{MY_ENV_VAR}}' });
+//   process.env['MY_ENV_VAR'] = 'ExampleValue';
+//   const requestConfig: AxiosRequestConfig = {
+//     url: 'https://example.com/api/some-resource',
+//     method: 'GET',
+//   };
+//   const updatedRequestConfig = await headerMerger.process(requestConfig);
+//   const response = await axios(updatedRequestConfig);
+//   console.log(response.data);
+// })();

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

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

package/lib/esm/utils/utils.js

@@ -0,0 +1,119 @@
+import axios from 'axios';
+import { Contract } from 'ethers';
+import { API_BASE_URL, API_INITIAL_DELAY, API_MAX_RETRIES, CENTRALIZE_CONTRACT_INTERACTION_CHAINS } from './consts';
+// 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
+    const sortedData = rawData.sort((a, b) => a.timestamp - b.timestamp);
+    const lastCandle = sortedData[sortedData.length - 1];
+    const startTimestamp = lastCandle ? lastCandle.timestamp : endTimestamp;
+    // Calculate the number of periods to backfill
+    const periodsToBackfill = Math.floor((endTimestamp - startTimestamp) / 1000 / period);
+    // Backfill the candles
+    for (let i = 0; i < periodsToBackfill; i++) {
+        const candleWidth = period * (i + 1);
+        const newCandle = {
+            timestamp: startTimestamp + candleWidth,
+            open: lastCandle.open,
+            high: lastCandle.open,
+            low: lastCandle.open,
+            close: lastCandle.open,
+            volume: 0, // You may need to replace these with appropriate logic
+        };
+        sortedData.push(newCandle);
+    }
+    // Return the converted data
+    return sortedData;
+};
+async function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function exponentialBackoffDelay(attempts) {
+    const baseDelay = 1000; // 1 second
+    const maxDelay = 30000; // 30 seconds
+    const delay = Math.min(baseDelay * Math.pow(2, attempts - 1), maxDelay);
+    return delay;
+}
+export async function fetchData(request, attempts) {
+    log('Request payload: =============', request);
+    attempts = attempts + 1;
+    try {
+        const response = (await axios(request)).data;
+        // this.log('API Response: =============', response);
+        if ('errors' in response && response['errors'].length > 0) {
+            if (attempts < 3) {
+                await delay(exponentialBackoffDelay(attempts));
+                return await fetchData(request, attempts);
+            }
+            else {
+                throw new Error('Maximum retry attempts reached');
+            }
+        }
+        return response;
+    }
+    catch (error) {
+        if (attempts < 3) {
+            await delay(exponentialBackoffDelay(attempts));
+            return await fetchData(request, attempts);
+        }
+        else {
+            throw error;
+        }
+    }
+}
+export async function readSlot0Contract({ address, abi, currentExecutionContext, functionName, provider, rpc, chainId, }) {
+    // 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 = [];
+    // 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
+    // Call the desired method with the specified arguments at synced block
+    // , {blockTag: syncedBlock}
+    let result;
+    if (CENTRALIZE_CONTRACT_INTERACTION_CHAINS.indexOf(chainId.toString()) === -1) {
+        result = await contract[functionName](...paramsArray, {
+            blockTag: currentExecutionContext?.blockNumber,
+        }); //@note uncomment for deterministic blocks
+    }
+    else {
+        const viewContractConfig = {
+            epochTimestamp: currentExecutionContext.epochTimestamp,
+            address: address,
+            abi: abi,
+            arguments: paramsArray,
+            method: functionName,
+            rpcUrl: rpc,
+        };
+        result = await callWithRetry(viewContractConfig);
+    }
+    // This gets stringified before calling main
+    return result;
+}
+export async function callWithRetry(config) {
+    let retries = 0;
+    let delay = API_INITIAL_DELAY;
+    while (retries < API_MAX_RETRIES) {
+        try {
+            const response = await axios.post(API_BASE_URL, 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...`);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay *= 2; // Double the delay for the next retry
+            retries++;
+        }
+    }
+    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

@@ -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/execution/executionApp.js

@@ -0,0 +1,323 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionApp = void 0;
+const bundleDataConnector_1 = require("../bundle/bundleDataConnector");
+const utils_1 = require("../utils/utils");
+const executionBase_1 = require("./executionBase");
+class ExecutionApp extends executionBase_1.ExecutionBase {
+    constructor(vault, steerSubgraph, isAlgebraPool, isDirectionalPool, chainId, maxRetries = 3) {
+        super(maxRetries);
+        this.getSlot0 = (pool, currentExecutionContext, provider, rpc) => __awaiter(this, void 0, void 0, function* () {
+            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 = yield (0, utils_1.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 = (pool, currentExecutionContext, provider, rpc) => __awaiter(this, void 0, void 0, function* () {
+            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 = yield (0, utils_1.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;
+    }
+    execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataConnector = new bundleDataConnector_1.DataConnector(_wasmFile, _vaultConfig, _identity, _etherRpcConfig);
+            yield dataConnector.loadSync();
+            const executionContext = yield this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
+            let rpc = '';
+            if (_etherRpcConfig) {
+                rpc = _etherRpcConfig[this.chainId.toString()].url;
+            }
+            const smartPoolExecutionContext = yield this.getSmartPoolExecutionContext(executionContext, dataConnector, JSON.parse(_vaultConfig), rpc);
+            dataConnector.setExecutionContextStrategyExecution(Object.assign(Object.assign({}, executionContext), smartPoolExecutionContext));
+            _data = _data.map((element) => JSON.stringify(element));
+            const result = yield dataConnector.executeBundle(_data);
+            return JSON.parse(result);
+        });
+    }
+    getSmartPoolExecutionContext(currentExecutionContext, dataConnector, vaultConfig, rpc) {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield (0, utils_1.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 = yield (0, utils_1.fetchData)(requestSnapshot, 4);
+            this.log('Subgraph response current snapshot', responseSnapshot);
+            const positions = [];
+            if (((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.vaultPositions) && ((_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.vaultPositions.length) > 0) {
+                const positionResponse = (_c = response === null || response === void 0 ? void 0 : response.data) === null || _c === void 0 ? void 0 : _c.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 (((_d = responseSnapshot === null || responseSnapshot === void 0 ? void 0 : responseSnapshot.data) === null || _d === void 0 ? void 0 : _d.vaultSnapshots) && ((_e = responseSnapshot === null || responseSnapshot === void 0 ? void 0 : responseSnapshot.data) === null || _e === void 0 ? void 0 : _e.vaultSnapshots.length) > 0) {
+                lastSnapshot = (_f = responseSnapshot === null || responseSnapshot === void 0 ? void 0 : responseSnapshot.data) === null || _f === void 0 ? void 0 : _f.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 = yield this.getVaultPoolAddress();
+            const currentTick = yield this.getPoolCurrentTick(poolAddress, provider, currentExecutionContext, rpc);
+            smartPoolExecutionContext.currentTick = currentTick;
+            // "currentTick": 10,
+            return smartPoolExecutionContext;
+        });
+    }
+    getPoolCurrentTick(poolAddress, provider, currentExecutionContext, rpc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isAlgebraPool) {
+                const slot0 = yield this.getSlot0(poolAddress, currentExecutionContext, provider, rpc);
+                return slot0.tick;
+            }
+            else {
+                const slot0 = yield this.getGlobalState(poolAddress, currentExecutionContext, provider, rpc);
+                return slot0.tick;
+            }
+        });
+    }
+    getVaultPoolAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestSnapshot = {
+                method: 'POST',
+                url: this.steerSubgraph,
+                data: {
+                    query: `
+            {
+                vault(id: "${this.vault}"){
+                    id
+                    pool
+                }
+            }
+              `,
+                },
+            };
+            const response = yield (0, utils_1.fetchData)(requestSnapshot, 4);
+            return response.data.vault.pool;
+        });
+    }
+}
+exports.ExecutionApp = ExecutionApp;

package/lib/execution/executionBase.d.ts

@@ -0,0 +1,14 @@
+import { ethers } from 'ethers';
+import { DataConnector } from '../bundle/bundleDataConnector';
+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>(_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/execution/executionBase.js

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionBase = void 0;
+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);
+        }
+    }
+    getExecutionContext(dataConnector, vaultConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = dataConnector.getProvider({});
+            let blockTime = 0;
+            let blockNumber = 9;
+            const anchorBlockNumber = vaultConfig.anchorBlockNumber;
+            const anchorProvided = typeof anchorBlockNumber === 'number' && anchorBlockNumber >= 0;
+            if (provider) {
+                blockTime = yield this.getAverageBlockTime(provider);
+                if (!anchorProvided) {
+                    blockNumber = yield 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;
+        });
+    }
+    execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Not implemented');
+        });
+    }
+    getDataConnectorVersion(dataConnector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let version = 1;
+            try {
+                version = yield dataConnector.version();
+            }
+            catch (e) {
+                // Data connector is missing version function, fallback to v1 logic
+            }
+            return version;
+        });
+    }
+    getAverageBlockTime(provider, blockCount = 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latestBlock = yield provider.getBlock('latest');
+            if (latestBlock) {
+                const startBlockNumber = Math.max(0, latestBlock.number - blockCount + 1);
+                let totalTimeDiff = 0;
+                let previousBlock = yield provider.getBlock(startBlockNumber);
+                if (!previousBlock) {
+                    return 0;
+                }
+                for (let i = startBlockNumber + 1; i <= latestBlock.number; i++) {
+                    const currentBlock = yield 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;
+            }
+        });
+    }
+    getBlockNumberFromAvgBlockTime(provider, targetTimestamp, avgBlockTime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latestBlock = yield 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);
+        });
+    }
+}
+exports.ExecutionBase = ExecutionBase;