@steerprotocol/data-connector-loader 3.1.1 → 3.2.2

package/lib/execution/executionApp.js

@@ -10,12 +10,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 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);
+const bundleDataConnector_js_1 = require("../bundle/bundleDataConnector.js");
+const utils_js_1 = require("../utils/utils.js");
+const executionBase_js_1 = require("./executionBase.js");
+class ExecutionApp extends executionBase_js_1.ExecutionBase {
+    constructor(config) {
+        var _a;
+        super((_a = config.maxRetries) !== null && _a !== void 0 ? _a : 3);
         this.getSlot0 = (pool, currentExecutionContext, provider, rpc) => __awaiter(this, void 0, void 0, function* () {
             const slot0Abi = [
                 {
@@ -42,12 +43,12 @@ class ExecutionApp extends executionBase_1.ExecutionBase {
                     type: 'function',
                 },
             ];
-            const slot0 = yield (0, utils_1.readSlot0Contract)({
+            const slot0 = yield (0, utils_js_1.readContract)({
                 address: pool,
                 abi: slot0Abi,
                 currentExecutionContext,
                 functionName: 'slot0',
-                provider: provider,
+                provider,
                 rpc,
                 chainId: this.chainId,
             });
@@ -61,110 +62,392 @@ class ExecutionApp extends executionBase_1.ExecutionBase {
                 unlocked: slot0[6],
             };
         });
-        this.getGlobalState = (pool, currentExecutionContext, provider, rpc) => __awaiter(this, void 0, void 0, function* () {
+        this.getSlot0Aerodrome = (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',
-                    },
+                {
+                    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 = yield (0, utils_1.readSlot0Contract)({
+            const slot0 = yield (0, utils_js_1.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 = (pool, currentExecutionContext, provider, rpc) => __awaiter(this, void 0, void 0, function* () {
+            const slot0Abi = [this.getGlobalStateAbi()];
+            const slot0 = yield (0, utils_js_1.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],
@@ -185,15 +468,21 @@ class ExecutionApp extends executionBase_1.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;
     }
-    execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig) {
+    execute(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig, forceDeposit) {
         return __awaiter(this, void 0, void 0, function* () {
-            const dataConnector = new bundleDataConnector_1.DataConnector(_wasmFile, _vaultConfig, _identity, _etherRpcConfig);
+            const dataConnector = new bundleDataConnector_js_1.DataConnector(_wasmFile, _vaultConfig, this.config, _identity, _etherRpcConfig);
             yield dataConnector.loadSync();
             const executionContext = yield this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
             let rpc = '';
@@ -201,12 +490,42 @@ class ExecutionApp extends executionBase_1.ExecutionBase {
                 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));
+            dataConnector.setExecutionContextStrategyExecution(Object.assign(Object.assign({}, executionContext), smartPoolExecutionContext), forceDeposit);
             _data = _data.map((element) => JSON.stringify(element));
             const result = yield dataConnector.executeBundle(_data);
             return JSON.parse(result);
         });
     }
+    executeStabilityVault(_wasmFile, _vaultConfig, _data, _identity, _etherRpcConfig, forceDeposit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataConnector = new bundleDataConnector_js_1.DataConnector(_wasmFile, _vaultConfig, this.config, _identity, _etherRpcConfig);
+            yield dataConnector.loadSync();
+            const executionContext = yield this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
+            const dynamicJobExecutionContext = {};
+            dataConnector.setExecutionContextStrategyExecution(Object.assign(Object.assign({}, executionContext), dynamicJobExecutionContext), forceDeposit);
+            _data = _data.map((element) => JSON.stringify(element));
+            const result = yield dataConnector.executeDynamicJobBundle(_data);
+            return JSON.parse(result);
+        });
+    }
+    executeDynamicJobs(_wasmFile, _vaultConfig, _data, _job, _identity, _etherRpcConfig, forceDeposit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataConnector = new bundleDataConnector_js_1.DataConnector(_wasmFile, _vaultConfig, this.config, _identity, _etherRpcConfig);
+            yield dataConnector.loadSync();
+            const executionContext = yield this.getExecutionContext(dataConnector, JSON.parse(_vaultConfig));
+            const smartRewardsContractAddress = _job.targetAddresses[0];
+            if (!smartRewardsContractAddress) {
+                throw new Error('Dynamic job must include at least one target address');
+            }
+            const dynamicJobExecutionContext = {
+                smartRewardsContractAddress,
+            };
+            dataConnector.setExecutionContextStrategyExecution(Object.assign(Object.assign({}, executionContext), dynamicJobExecutionContext), forceDeposit);
+            _data = _data.map((element) => JSON.stringify(element));
+            const result = yield dataConnector.executeDynamicJobBundle(_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* () {
@@ -214,6 +533,9 @@ class ExecutionApp extends executionBase_1.ExecutionBase {
             const request = {
                 method: 'POST',
                 url: this.steerSubgraph,
+                headers: Object.assign({ '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: `
                   {
@@ -231,11 +553,14 @@ class ExecutionApp extends executionBase_1.ExecutionBase {
               `,
                 },
             };
-            const response = yield (0, utils_1.fetchData)(request, 4);
+            const response = yield (0, utils_js_1.fetchData)(request, 4);
             this.log('Subgraph response vault positions :', response);
             const requestSnapshot = {
                 method: 'POST',
                 url: this.steerSubgraph,
+                headers: Object.assign({ '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: `
                   {
@@ -250,7 +575,7 @@ class ExecutionApp extends executionBase_1.ExecutionBase {
               `,
                 },
             };
-            const responseSnapshot = yield (0, utils_1.fetchData)(requestSnapshot, 4);
+            const responseSnapshot = yield (0, utils_js_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) {
@@ -282,23 +607,137 @@ class ExecutionApp extends executionBase_1.ExecutionBase {
             }
             const poolAddress = yield this.getVaultPoolAddress();
             const currentTick = yield this.getPoolCurrentTick(poolAddress, provider, currentExecutionContext, rpc);
+            const tickSpacing = yield this.getTickSpacing(poolAddress, provider, rpc, currentExecutionContext);
+            const totalAmounts = yield 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;
         });
     }
     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);
+            if (this.isAlgebraPool || this.isPoolSharkPool) {
+                const slot0 = yield this.getGlobalState(poolAddress, currentExecutionContext, provider, rpc);
+                return slot0.tick;
+            }
+            else if (this.isAerodromePool) {
+                const slot0 = yield this.getSlot0Aerodrome(poolAddress, currentExecutionContext, provider, rpc);
                 return slot0.tick;
             }
             else {
-                const slot0 = yield this.getGlobalState(poolAddress, currentExecutionContext, provider, rpc);
+                const slot0 = yield this.getSlot0(poolAddress, currentExecutionContext, provider, rpc);
                 return slot0.tick;
             }
         });
     }
+    getTickSpacing(poolAddress, provider, rpc, currentExecutionContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield (0, utils_js_1.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);
+    }
+    getTotalAmounts(vaultAddress, currentExecutionContext, provider, rpc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getTotalAmountsABI = [
+                {
+                    inputs: [],
+                    name: 'getTotalAmounts',
+                    outputs: [
+                        { internalType: 'uint256', name: 'total0', type: 'uint256' },
+                        { internalType: 'uint256', name: 'total1', type: 'uint256' },
+                    ],
+                    stateMutability: 'view',
+                    type: 'function',
+                },
+            ];
+            const totalAmounts = yield (0, utils_js_1.readContract)({
+                address: vaultAddress,
+                abi: getTotalAmountsABI,
+                currentExecutionContext,
+                functionName: 'getTotalAmounts',
+                provider,
+                rpc,
+                chainId: this.chainId,
+            });
+            return {
+                total0: totalAmounts[0],
+                total1: totalAmounts[1],
+            };
+        });
+    }
     getVaultPoolAddress() {
         return __awaiter(this, void 0, void 0, function* () {
             const requestSnapshot = {
@@ -314,8 +753,11 @@ class ExecutionApp extends executionBase_1.ExecutionBase {
             }
               `,
                 },
+                headers: Object.assign({ '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 = yield (0, utils_1.fetchData)(requestSnapshot, 4);
+            const response = yield (0, utils_js_1.fetchData)(requestSnapshot, 4);
             return response.data.vault.pool;
         });
     }