@steerprotocol/data-connector-loader 3.1.1 → 3.2.1

package/lib/esm/execution/executionApp.js

@@ -1,9 +1,9 @@
-import { DataConnector } from '../bundle/bundleDataConnector';
-import { fetchData, readSlot0Contract } from '../utils/utils';
-import { ExecutionBase } from './executionBase';
+import { DataConnector } from '../bundle/bundleDataConnector.js';
+import { fetchData, readContract } from '../utils/utils.js';
+import { ExecutionBase } from './executionBase.js';
 export class ExecutionApp extends ExecutionBase {
-    constructor(vault, steerSubgraph, isAlgebraPool, isDirectionalPool, chainId, maxRetries = 3) {
-        super(maxRetries);
+    constructor(config) {
+        super(config.maxRetries ?? 3);
         this.getSlot0 = async (pool, currentExecutionContext, provider, rpc) => {
             const slot0Abi = [
                 {
@@ -30,12 +30,12 @@ export class ExecutionApp extends ExecutionBase {
                     type: 'function',
                 },
             ];
-            const slot0 = await readSlot0Contract({
+            const slot0 = await readContract({
                 address: pool,
                 abi: slot0Abi,
                 currentExecutionContext,
                 functionName: 'slot0',
-                provider: provider,
+                provider,
                 rpc,
                 chainId: this.chainId,
             });
@@ -49,110 +49,392 @@ export class ExecutionApp extends ExecutionBase {
                 unlocked: slot0[6],
             };
         };
-        this.getGlobalState = async (pool, currentExecutionContext, provider, rpc) => {
+        this.getSlot0Aerodrome = 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',
-                    },
+                {
+                    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: 'bool',
+                            name: 'unlocked',
+                            type: 'bool',
+                        },
+                    ],
+                    stateMutability: 'view',
+                    type: 'function',
+                },
             ];
-            const slot0 = await readSlot0Contract({
+            const slot0 = await readContract({
+                address: pool,
+                abi: slot0Abi,
+                currentExecutionContext,
+                functionName: 'slot0',
+                provider,
+                rpc,
+                chainId: this.chainId,
+            });
+            return {
+                sqrtPriceX96: slot0[0],
+                tick: slot0[1],
+                observationIndex: slot0[2],
+                observationCardinality: slot0[3],
+                observationCardinalityNext: slot0[4],
+                unlocked: slot0[5],
+            };
+        };
+        this.getGlobalStateAbi = () => {
+            if (this.isAlgebraIntegralPool) {
+                return {
+                    inputs: [],
+                    name: 'globalState',
+                    outputs: [
+                        {
+                            internalType: 'uint160',
+                            name: 'price',
+                            type: 'uint160',
+                        },
+                        {
+                            internalType: 'int24',
+                            name: 'tick',
+                            type: 'int24',
+                        },
+                        {
+                            internalType: 'uint16',
+                            name: 'lastFee',
+                            type: 'uint16',
+                        },
+                        {
+                            internalType: 'uint8',
+                            name: 'pluginConfig',
+                            type: 'uint8',
+                        },
+                        {
+                            internalType: 'uint16',
+                            name: 'communityFee',
+                            type: 'uint16',
+                        },
+                        {
+                            internalType: 'bool',
+                            name: 'unlocked',
+                            type: 'bool',
+                        },
+                    ],
+                    stateMutability: 'view',
+                    type: 'function',
+                };
+            }
+            else if (this.isDirectionalPool) {
+                return {
+                    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',
+                };
+            }
+            else if (this.isPoolSharkPool) {
+                return {
+                    inputs: [],
+                    name: 'globalState',
+                    outputs: [
+                        {
+                            components: [
+                                {
+                                    components: [
+                                        {
+                                            internalType: 'uint16',
+                                            name: 'index',
+                                            type: 'uint16',
+                                        },
+                                        {
+                                            internalType: 'uint16',
+                                            name: 'count',
+                                            type: 'uint16',
+                                        },
+                                        {
+                                            internalType: 'uint16',
+                                            name: 'countMax',
+                                            type: 'uint16',
+                                        },
+                                    ],
+                                    internalType: 'struct PoolsharkStructs.SampleState',
+                                    name: 'samples',
+                                    type: 'tuple',
+                                },
+                                {
+                                    internalType: 'uint200',
+                                    name: 'feeGrowthGlobal0',
+                                    type: 'uint200',
+                                },
+                                {
+                                    internalType: 'uint200',
+                                    name: 'feeGrowthGlobal1',
+                                    type: 'uint200',
+                                },
+                                {
+                                    internalType: 'uint160',
+                                    name: 'secondsPerLiquidityAccum',
+                                    type: 'uint160',
+                                },
+                                {
+                                    internalType: 'uint160',
+                                    name: 'price',
+                                    type: 'uint160',
+                                },
+                                {
+                                    internalType: 'uint128',
+                                    name: 'liquidity',
+                                    type: 'uint128',
+                                },
+                                {
+                                    internalType: 'int56',
+                                    name: 'tickSecondsAccum',
+                                    type: 'int56',
+                                },
+                                {
+                                    internalType: 'int24',
+                                    name: 'tickAtPrice',
+                                    type: 'int24',
+                                },
+                                {
+                                    internalType: 'uint16',
+                                    name: 'protocolSwapFee0',
+                                    type: 'uint16',
+                                },
+                                {
+                                    internalType: 'uint16',
+                                    name: 'protocolSwapFee1',
+                                    type: 'uint16',
+                                },
+                            ],
+                            internalType: 'struct PoolsharkStructs.RangePoolState',
+                            name: 'pool',
+                            type: 'tuple',
+                        },
+                        {
+                            components: [
+                                {
+                                    internalType: 'uint160',
+                                    name: 'price',
+                                    type: 'uint160',
+                                },
+                                {
+                                    internalType: 'uint128',
+                                    name: 'liquidity',
+                                    type: 'uint128',
+                                },
+                                {
+                                    internalType: 'uint128',
+                                    name: 'protocolFees',
+                                    type: 'uint128',
+                                },
+                                {
+                                    internalType: 'uint16',
+                                    name: 'protocolFillFee',
+                                    type: 'uint16',
+                                },
+                                {
+                                    internalType: 'int24',
+                                    name: 'tickAtPrice',
+                                    type: 'int24',
+                                },
+                            ],
+                            internalType: 'struct PoolsharkStructs.LimitPoolState',
+                            name: 'pool0',
+                            type: 'tuple',
+                        },
+                        {
+                            components: [
+                                {
+                                    internalType: 'uint160',
+                                    name: 'price',
+                                    type: 'uint160',
+                                },
+                                {
+                                    internalType: 'uint128',
+                                    name: 'liquidity',
+                                    type: 'uint128',
+                                },
+                                {
+                                    internalType: 'uint128',
+                                    name: 'protocolFees',
+                                    type: 'uint128',
+                                },
+                                {
+                                    internalType: 'uint16',
+                                    name: 'protocolFillFee',
+                                    type: 'uint16',
+                                },
+                                {
+                                    internalType: 'int24',
+                                    name: 'tickAtPrice',
+                                    type: 'int24',
+                                },
+                            ],
+                            internalType: 'struct PoolsharkStructs.LimitPoolState',
+                            name: 'pool1',
+                            type: 'tuple',
+                        },
+                        {
+                            internalType: 'uint128',
+                            name: 'liquidityGlobal',
+                            type: 'uint128',
+                        },
+                        {
+                            internalType: 'uint32',
+                            name: 'positionIdNext',
+                            type: 'uint32',
+                        },
+                        {
+                            internalType: 'uint32',
+                            name: 'epoch',
+                            type: 'uint32',
+                        },
+                        {
+                            internalType: 'uint8',
+                            name: 'unlocked',
+                            type: 'uint8',
+                        },
+                    ],
+                    stateMutability: 'view',
+                    type: 'function',
+                };
+            }
+            else {
+                return {
+                    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',
+                };
+            }
+        };
+        this.getGlobalState = async (pool, currentExecutionContext, provider, rpc) => {
+            const slot0Abi = [this.getGlobalStateAbi()];
+            const slot0 = await readContract({
                 address: pool,
                 abi: slot0Abi,
                 currentExecutionContext,
                 functionName: 'globalState',
-                provider: provider,
+                provider,
                 rpc,
                 chainId: this.chainId,
             });
+            if (this.isPoolSharkPool) {
+                return {
+                    price: slot0[0][5],
+                    tick: slot0[0][7],
+                    observationIndex: slot0[2],
+                    observationCardinality: slot0[3],
+                    observationCardinalityNext: slot0[4],
+                    feeProtocol: slot0[5],
+                    unlocked: slot0[6],
+                };
+            }
             return this.isDirectionalPool
                 ? {
                     price: slot0[0],
@@ -173,14 +455,20 @@ export class ExecutionApp extends ExecutionBase {
                     unlocked: slot0[6],
                 };
         };
-        this.steerSubgraph = steerSubgraph;
-        this.vault = vault;
-        this.isAlgebraPool = isAlgebraPool;
-        this.isDirectionalPool = isDirectionalPool;
-        this.chainId = chainId;
+        this.vault = config.vault;
+        this.steerSubgraph = config.steerSubgraph;
+        this.chainId = config.chainId;
+        this.isAlgebraPool = config.poolType.isAlgebraPool;
+        this.isAlgebraIntegralPool = config.poolType.isAlgebraIntegralPool;
+        this.isDirectionalPool = config.poolType.isDirectionalPool;
+        this.isPoolSharkPool = config.poolType.isPoolSharkPool;
+        this.isAerodromePool = config.poolType.isAerodromePool;
+        this.subgraphStudioKey = config.apiKeys.subgraphStudioKey;
+        this.sentioApiKey = config.apiKeys.sentioApiKey;
+        this.config = config;
     }
-    async execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig) {
-        const dataConnector = new DataConnector(_wasmFile, _vaultConfig, _identity, _etherRpcConfig);
+    async execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig, forceDeposit) {
+        const dataConnector = new DataConnector(_wasmFile, _vaultConfig, this.config, _identity, _etherRpcConfig);
         await dataConnector.loadSync();
         const executionContext = await this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
         let rpc = '';
@@ -191,16 +479,50 @@ export class ExecutionApp extends ExecutionBase {
         dataConnector.setExecutionContextStrategyExecution({
             ...executionContext,
             ...smartPoolExecutionContext,
-        });
+        }, forceDeposit);
         _data = _data.map((element) => JSON.stringify(element));
         const result = await dataConnector.executeBundle(_data);
         return JSON.parse(result);
     }
+    async executeStabilityVault(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig, forceDeposit) {
+        const dataConnector = new DataConnector(_wasmFile, _vaultConfig, this.config, _identity, _etherRpcConfig);
+        await dataConnector.loadSync();
+        const executionContext = await this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
+        const dynamicJobExecutionContext = {};
+        dataConnector.setExecutionContextStrategyExecution({
+            ...executionContext,
+            ...dynamicJobExecutionContext,
+        }, forceDeposit);
+        _data = _data.map((element) => JSON.stringify(element));
+        const result = await dataConnector.executeDynamicJobBundle(_data);
+        return JSON.parse(result);
+    }
+    async executeDynamicJobs(_wasmFile, _vaultConfig, _data, _job, _identity, _etherRpcConfig, forceDeposit) {
+        const dataConnector = new DataConnector(_wasmFile, _vaultConfig, this.config, _identity, _etherRpcConfig);
+        await dataConnector.loadSync();
+        const executionContext = await this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
+        const dynamicJobExecutionContext = {
+            smartRewardsContractAddress: _job.targetAddresses?.[0],
+        };
+        dataConnector.setExecutionContextStrategyExecution({
+            ...executionContext,
+            ...dynamicJobExecutionContext,
+        }, forceDeposit);
+        _data = _data.map((element) => JSON.stringify(element));
+        const result = await dataConnector.executeDynamicJobBundle(_data);
+        return JSON.parse(result);
+    }
     async getSmartPoolExecutionContext(currentExecutionContext, dataConnector, vaultConfig, rpc) {
         const smartPoolExecutionContext = {};
         const request = {
             method: 'POST',
             url: this.steerSubgraph,
+            headers: {
+                'Content-Type': !this.steerSubgraph.includes('subgraph-proxy-server')
+                    ? 'application/json'
+                    : 'text/plain;charset=UTF-8',
+                ...(this.steerSubgraph.includes('sentio') ? { 'api-key': this.sentioApiKey } : {}),
+            },
             data: {
                 query: `
                   {
@@ -223,6 +545,12 @@ export class ExecutionApp extends ExecutionBase {
         const requestSnapshot = {
             method: 'POST',
             url: this.steerSubgraph,
+            headers: {
+                'Content-Type': !this.steerSubgraph.includes('subgraph-proxy-server')
+                    ? 'application/json'
+                    : 'text/plain;charset=UTF-8',
+                ...(this.steerSubgraph.includes('sentio') ? { 'api-key': this.sentioApiKey } : {}),
+            },
             data: {
                 query: `
                   {
@@ -269,20 +597,130 @@ export class ExecutionApp extends ExecutionBase {
         }
         const poolAddress = await this.getVaultPoolAddress();
         const currentTick = await this.getPoolCurrentTick(poolAddress, provider, currentExecutionContext, rpc);
+        const tickSpacing = await this.getTickSpacing(poolAddress, provider, rpc, currentExecutionContext);
+        const totalAmounts = await this.getTotalAmounts(this.vault, currentExecutionContext, provider, rpc);
+        // Handle both bigint and serialized bigint from centralized API
+        smartPoolExecutionContext.totalAmount0 = this.convertToString(totalAmounts.total0);
+        smartPoolExecutionContext.totalAmount1 = this.convertToString(totalAmounts.total1);
         smartPoolExecutionContext.currentTick = currentTick;
+        smartPoolExecutionContext.tickSpacing = tickSpacing;
         // "currentTick": 10,
         return smartPoolExecutionContext;
     }
     async getPoolCurrentTick(poolAddress, provider, currentExecutionContext, rpc) {
-        if (!this.isAlgebraPool) {
-            const slot0 = await this.getSlot0(poolAddress, currentExecutionContext, provider, rpc);
+        if (this.isAlgebraPool || this.isPoolSharkPool) {
+            const slot0 = await this.getGlobalState(poolAddress, currentExecutionContext, provider, rpc);
+            return slot0.tick;
+        }
+        else if (this.isAerodromePool) {
+            const slot0 = await this.getSlot0Aerodrome(poolAddress, currentExecutionContext, provider, rpc);
             return slot0.tick;
         }
         else {
-            const slot0 = await this.getGlobalState(poolAddress, currentExecutionContext, provider, rpc);
+            const slot0 = await this.getSlot0(poolAddress, currentExecutionContext, provider, rpc);
             return slot0.tick;
         }
     }
+    async getTickSpacing(poolAddress, provider, rpc, currentExecutionContext) {
+        const tickSpacingAbi = [
+            this.isPoolSharkPool
+                ? {
+                    inputs: [],
+                    name: 'tickSpacing',
+                    outputs: [
+                        {
+                            internalType: 'int24',
+                            name: '',
+                            type: 'int24',
+                        },
+                    ],
+                    stateMutability: 'view',
+                    type: 'function',
+                }
+                : {
+                    inputs: [],
+                    name: 'tickSpacing',
+                    outputs: [
+                        {
+                            internalType: 'int16',
+                            name: '',
+                            type: 'int16',
+                        },
+                    ],
+                    stateMutability: 'pure',
+                    type: 'function',
+                },
+        ];
+        const tickSpacing = await readContract({
+            address: poolAddress,
+            abi: tickSpacingAbi,
+            currentExecutionContext,
+            functionName: 'tickSpacing',
+            provider,
+            rpc,
+            chainId: this.chainId,
+        });
+        return tickSpacing;
+    }
+    /**
+     * Converts a value to string, handling both native bigint and serialized bigint objects
+     * from the centralized API
+     */
+    convertToString(value) {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value === 'number') {
+            return value.toString();
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        // Handle serialized bigint from centralized API (e.g., { type: 'BigNumber', hex: '0x...' })
+        if (value && typeof value === 'object') {
+            // If it's a BigNumber-like object with hex property
+            if (value.hex !== undefined) {
+                return BigInt(value.hex).toString();
+            }
+            // If it has a _hex property (ethers v5 BigNumber)
+            if (value._hex !== undefined) {
+                return BigInt(value._hex).toString();
+            }
+            // If it has toString method, try using it
+            if (typeof value.toString === 'function' && value.toString() !== '[object Object]') {
+                return value.toString();
+            }
+        }
+        // Fallback: convert to string (may result in '[object Object]' if not handled above)
+        return String(value);
+    }
+    async getTotalAmounts(vaultAddress, currentExecutionContext, provider, rpc) {
+        const getTotalAmountsABI = [
+            {
+                inputs: [],
+                name: 'getTotalAmounts',
+                outputs: [
+                    { internalType: 'uint256', name: 'total0', type: 'uint256' },
+                    { internalType: 'uint256', name: 'total1', type: 'uint256' },
+                ],
+                stateMutability: 'view',
+                type: 'function',
+            },
+        ];
+        const totalAmounts = await readContract({
+            address: vaultAddress,
+            abi: getTotalAmountsABI,
+            currentExecutionContext,
+            functionName: 'getTotalAmounts',
+            provider,
+            rpc,
+            chainId: this.chainId,
+        });
+        return {
+            total0: totalAmounts[0],
+            total1: totalAmounts[1],
+        };
+    }
     async getVaultPoolAddress() {
         const requestSnapshot = {
             method: 'POST',
@@ -297,6 +735,12 @@ export class ExecutionApp extends ExecutionBase {
             }
               `,
             },
+            headers: {
+                'Content-Type': !this.steerSubgraph.includes('subgraph-proxy-server')
+                    ? 'application/json'
+                    : 'text/plain;charset=UTF-8',
+                ...(this.steerSubgraph.includes('sentio') ? { 'api-key': this.sentioApiKey } : {}),
+            },
         };
         const response = await fetchData(requestSnapshot, 4);
         return response.data.vault.pool;