@steerprotocol/data-connector-loader 0.1.5 → 2.0.0

package/lib/bundleExecution.d.ts

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

package/lib/bundleExecution.js

@@ -0,0 +1,42 @@
+"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.DataConnector = void 0;
+const ethers_1 = require("ethers");
+const bundleBase_1 = require("./base/bundleBase");
+class DataConnector extends bundleBase_1.BundleBase {
+    // Identity should come from the node's IdentityManager.wallet
+    constructor(wasmFile, _config, identity, etherRpcConfig) {
+        super(wasmFile, _config, identity, etherRpcConfig);
+    }
+    // Makes contract instance and calls, returns stringified result
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    view(config) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider(config);
+            if (!provider)
+                throw new Error('Provider not initialized');
+            const contract = new ethers_1.Contract(config.address, config.abi, provider);
+            // For formatting the parameters if needed
+            const paramsArray = config.arguments;
+            // 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}
+            const result = yield contract[config.method](...paramsArray, { blockTag: (_a = this.executionContext) === null || _a === void 0 ? void 0 : _a.blockNumber }); //@note uncomment for deterministic blocks
+            // This gets stringified before calling main
+            return result;
+        });
+    }
+}
+exports.DataConnector = DataConnector;

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,325 @@
+"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,111 @@
+"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;
+            if (provider) {
+                blockTime = yield this.getAverageBlockTime(provider);
+                blockNumber = yield 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,
+            };
+            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;

package/lib/execution/executionBundle.d.ts

@@ -0,0 +1,5 @@
+import { ExecutionBase } from "../loader/loaderBase";
+export declare class ExecutionBundle extends ExecutionBase {
+    constructor(maxRetries?: number);
+    execute<T>(_vaultConfig: string): Promise<Array<T>>;
+}

package/lib/execution/executionBundle.js

@@ -0,0 +1,29 @@
+"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.ExecutionBundle = void 0;
+const bundleDataConnector_1 = require("../bundle/bundleDataConnector");
+const loaderBase_1 = require("../loader/loaderBase");
+class ExecutionBundle extends loaderBase_1.ExecutionBase {
+    constructor(maxRetries = 3) {
+        super(maxRetries);
+    }
+    execute(_vaultConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataConnector = new bundleDataConnector_1.DataConnector(_vaultConfig, _vaultConfig);
+            const executionContext = yield this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
+            dataConnector.setExecutionContext(executionContext);
+            const result = yield dataConnector.execute(_vaultConfig);
+            return [JSON.parse(result)];
+        });
+    }
+}
+exports.ExecutionBundle = ExecutionBundle;

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