@steerprotocol/data-connector-loader 0.1.5 → 1.0.0

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/esm/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/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;
+}

package/lib/esm/execution/executionDataConnector.js

@@ -0,0 +1,90 @@
+import { ExecutionBase } from './executionBase';
+import { PluginManager } from '../utils/pluginManager';
+import { extendOHLCV, fetchData } from '../utils/utils';
+export class DataConnectorExecution extends ExecutionBase {
+    constructor(dataConnectors, maxRetries = 3) {
+        super(maxRetries);
+        this.dataConnectors = dataConnectors;
+    }
+    async execute(_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);
+            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);
+            }
+            else {
+                const finalResponse = await dataConnector.execute('');
+                const transformedData = await this.transformData(dataConnector, finalResponse);
+                transformationData.push(transformedData);
+            }
+        }
+        return transformationData;
+    }
+    async handleRequestResponse(dataConnector, pluginManager, initialRequest) {
+        let request = initialRequest;
+        let response;
+        try {
+            while (request !== 'true') {
+                if (dataConnector.configObj.isChainRead == true) {
+                    response = await dataConnector.view(JSON.parse(request));
+                }
+                else {
+                    const parsedRequest = await pluginManager.process(typeof request == 'string' ? JSON.parse(request) : request);
+                    await this.delay(1000);
+                    response = await fetchData(parsedRequest, 0);
+                }
+                request = await dataConnector.execute(JSON.stringify(response));
+            }
+        }
+        catch (e) {
+            // process.env.SILENT_ERRORS
+            if (process.env.DATA_LOADER_SILENT_ERRORS !== 'true') {
+                console.error('Data connector failed to process.', e);
+            }
+            throw e;
+        }
+        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]);
+            const requiredKeys = ['timestamp', 'open', 'high', 'low', 'close'];
+            const hasAllKeys = requiredKeys.every((key) => keys.includes(key));
+            // has the 'lookback' key
+            const lookback = dataConnector?.configObj?.lookback;
+            if (hasAllKeys && !!lookback) {
+                // Now that we have identified a v1 data connector, we need to transform the data so that the data is up to the current execution epoch timestamp
+                if (dataConnector?.executionContext?.epochTimestamp) {
+                    const extended = extendOHLCV(transformedData, lookback, dataConnector?.executionContext?.epochTimestamp * 1000);
+                    transformedData = extended;
+                }
+            }
+        }
+        return transformedData;
+    }
+}

package/lib/esm/index.d.ts

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

package/lib/esm/index.js

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

package/lib/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/lib/esm/types.d.ts

@@ -0,0 +1,104 @@
+import { ContractInterface } from 'ethers';
+export type VaultInput = {
+    _id?: string;
+    tokenId: string;
+    vaultAddress: string;
+    state: string;
+    token0: string;
+    token1: string;
+    name: string;
+    symbol: string;
+    beaconName: string;
+    token0Name: string;
+    token1Name: string;
+    token0Symbol: string;
+    token1Symbol: string;
+    decimals: string;
+    token0Decimals: string;
+    token1Decimals: string;
+    payloadIpfs: string;
+    timestamp: number;
+    vaultConfigPayload: VaultConfigPayload;
+};
+export interface VaultConfigPayload {
+    strategyConfigData: StrategyConfigData;
+    vaultPayload: VaultPayload;
+    dataConnectorsData: DataConnectorsDaum[];
+    vaultAddress: string;
+    epochTimestamp: number;
+    anchorBlockNumber?: number;
+}
+export interface StrategyConfigData {
+    [key: string]: string | number;
+    epochStart: number;
+    epochLength: string;
+}
+export interface ConcentratedLiquidityManagerPayload {
+    maxTotalSupply: string;
+    ratioErrorTolerance: number;
+    maxTickChange: number;
+    twapInterval: number;
+    fee: number;
+    slippage: number;
+}
+export type VaultPayload = ConcentratedLiquidityManagerPayload;
+export interface DataConnectorsDaum {
+    bundleHash: string;
+    configData: ConfigData;
+}
+export interface ConfigData {
+    [key: string]: string | number;
+}
+export interface ExecutionContext {
+    executionTimestamp: number;
+    epochLength: number;
+    vaultAddress: string;
+    blockTime: number;
+    blockNumber: number;
+    epochTimestamp: number;
+}
+export interface Position {
+    startTick: number;
+    endTick: number;
+    weight: number;
+}
+export interface SmartPoolExecutionContext extends ExecutionContext {
+    positions: Position[];
+    currentTick: number;
+    lastExecutionTime: number;
+}
+export type RpcConfig = {
+    url: string;
+    network?: string;
+};
+export type EtherRpcConfig = {
+    [key: string]: RpcConfig;
+};
+export interface ViewConfig {
+    address: string;
+    abi: ContractInterface;
+    method: string;
+    arguments: unknown[];
+}
+export interface Slot0 {
+    sqrtPriceX96?: bigint;
+    tick: number;
+    observationIndex?: number;
+    observationCardinality?: number;
+    observationCardinalityNext?: number;
+    feeProtocol?: number;
+    unlocked: boolean;
+    price?: bigint;
+    prevInitializedTick?: number;
+    fee?: number;
+    timepointIndex?: number;
+    communityFee?: number;
+}
+export type ViewContractConfig = {
+    epochTimestamp?: number;
+    address: string;
+    abi: any;
+    arguments: Array<any>;
+    method: string;
+    rpcUrl?: string;
+};

package/lib/esm/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/utils/blockFinder.js

@@ -0,0 +1,20 @@
+// import { providers,  } 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
+ * @param timestamp
+ * @param Idenity
+ */
+export async function getBlockFromTimestamp(timestamp, provider) {
+    let currentBlock = (await provider.getBlockNumber()) - 1;
+    let runningTimestamp = (await provider.getBlock(currentBlock))?.timestamp;
+    if (!runningTimestamp)
+        return currentBlock;
+    while (runningTimestamp > timestamp) {
+        currentBlock -= 1;
+        runningTimestamp = (await provider.getBlock(currentBlock))?.timestamp;
+        if (!runningTimestamp)
+            return currentBlock;
+    }
+    return currentBlock;
+}

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

@@ -0,0 +1,4 @@
+export declare const API_BASE_URL = "https://cvrlulno2m.execute-api.ap-southeast-1.amazonaws.com/dev/contract-view-call";
+export declare const API_MAX_RETRIES = 3;
+export declare const API_INITIAL_DELAY = 1000;
+export declare const CENTRALIZE_CONTRACT_INTERACTION_CHAINS: string[];

package/lib/esm/utils/consts.js

@@ -0,0 +1,4 @@
+export const API_BASE_URL = 'https://cvrlulno2m.execute-api.ap-southeast-1.amazonaws.com/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'];