feat: update metrcis calc to take it into account settledGrowth for NOrewards

Author: DiRaiks

features/index.ts

@@ -11,3 +11,4 @@ export * from './deposits/index.js';
 export * from './lazy-oracle.js';
 export * from './defi-wrapper/index.js';
 export * from './dev-tools/index.js';
+export * from './metrics.js';

features/metrics.ts

@@ -0,0 +1,51 @@
+import { callReadMethodSilent, cache } from 'utils';
+import { DashboardContract } from 'contracts';
+
+export const getNodeOperatorFeeRatesByBlockNumbers = async (
+  vaultAddress: string,
+  blockNumbers: number[],
+  dashboardContract: DashboardContract,
+) => {
+  // Get nodeOperatorFeeBP for each report block with caching
+  const nodeOperatorFeeBPs: bigint[] = [];
+  for (const blockNumber of blockNumbers) {
+    let fee = await cache.getNodeOperatorFeeRate(vaultAddress, blockNumber);
+    if (fee === null) {
+      const feeRate = await callReadMethodSilent(dashboardContract, 'feeRate', {
+        blockNumber: BigInt(blockNumber),
+      });
+      fee = BigInt(feeRate);
+      await cache.setNodeOperatorFeeRate(vaultAddress, blockNumber, fee);
+    }
+
+    nodeOperatorFeeBPs.push(fee);
+  }
+
+  return nodeOperatorFeeBPs;
+};
+
+export const getSettledGrowthsByBlockNumbers = async (
+  vaultAddress: string,
+  blockNumbers: number[],
+  dashboardContract: DashboardContract,
+) => {
+  // Get settled growth for each report block with caching
+  const settledGrowths: bigint[] = [];
+  for (const blockNumber of blockNumbers) {
+    let settledGrowth = await cache.getSettledGrowth(vaultAddress, blockNumber);
+    if (settledGrowth === null) {
+      settledGrowth = await callReadMethodSilent(
+        dashboardContract,
+        'settledGrowth',
+        {
+          blockNumber: BigInt(blockNumber),
+        },
+      );
+      await cache.setSettledGrowth(vaultAddress, blockNumber, settledGrowth);
+    }
+
+    settledGrowths.push(settledGrowth);
+  }
+
+  return settledGrowths;
+};

programs/use-cases/metrics/read.ts

@@ -22,16 +22,19 @@ import {
   prepareGrossStakingRewards,
   prepareNodeOperatorRewards,
   prepareNetStakingRewards,
-  callReadMethodSilent,
-  cache,
   prepareGrossStakingAPR,
   prepareNetStakingAPR,
   prepareCarrySpread,
   prepareBottomLine,
   prepareDailyLidoFees,
   formatTimestamp,
 } from 'utils';
-import { checkQuarantine, chooseVaultAndGetDashboard } from 'features';
+import {
+  checkQuarantine,
+  chooseVaultAndGetDashboard,
+  getNodeOperatorFeeRatesByBlockNumbers,
+  getSettledGrowthsByBlockNumbers,
+} from 'features';
 
 import { metrics } from './main.js';
 
@@ -150,23 +153,16 @@ metricsRead
       cacheUse,
     );
 
-    // Get nodeOperatorFeeBP for each report block with caching
-    const nodeOperatorFeeBPs: bigint[] = [];
-    for (const r of history) {
-      let fee = await cache.getNodeOperatorFeeRate(vault, r.blockNumber);
-      if (fee === null) {
-        const feeRate = await callReadMethodSilent(
-          dashboardContract,
-          'feeRate',
-          {
-            blockNumber: BigInt(r.blockNumber),
-          },
-        );
-        fee = BigInt(feeRate);
-        await cache.setNodeOperatorFeeRate(vault, r.blockNumber, fee);
-      }
-      nodeOperatorFeeBPs.push(fee);
-    }
+    const blockNumbers = history.map((r) => r.blockNumber);
+    const [nodeOperatorFeeBPs, settledGrowths] = await Promise.all([
+      getNodeOperatorFeeRatesByBlockNumbers(
+        vault,
+        blockNumbers,
+        dashboardContract,
+      ),
+      getSettledGrowthsByBlockNumbers(vault, blockNumbers, dashboardContract),
+    ]);
+
     const [
       grossStakingRewards,
       nodeOperatorRewards,
@@ -178,12 +174,22 @@ metricsRead
       dailyLidoFees,
     ] = await Promise.all([
       prepareGrossStakingRewards(history),
-      prepareNodeOperatorRewards(history, nodeOperatorFeeBPs),
-      prepareNetStakingRewards(history, nodeOperatorFeeBPs),
+      prepareNodeOperatorRewards(history, nodeOperatorFeeBPs, settledGrowths),
+      prepareNetStakingRewards(history, nodeOperatorFeeBPs, settledGrowths),
       prepareGrossStakingAPR(history),
-      prepareNetStakingAPR(history, nodeOperatorFeeBPs),
-      prepareCarrySpread(history, nodeOperatorFeeBPs, vaultAddress),
-      prepareBottomLine(history, nodeOperatorFeeBPs, vaultAddress),
+      prepareNetStakingAPR(history, nodeOperatorFeeBPs, settledGrowths),
+      prepareCarrySpread(
+        history,
+        nodeOperatorFeeBPs,
+        vaultAddress,
+        settledGrowths,
+      ),
+      prepareBottomLine(
+        history,
+        nodeOperatorFeeBPs,
+        vaultAddress,
+        settledGrowths,
+      ),
       prepareDailyLidoFees(history),
     ]);
 

tests/utils/bigInt.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, test } from '@jest/globals';
+
+import { bigIntMax, bigIntMin } from '../../utils/bigInt.js';
+
+describe('bigIntMax', () => {
+  test('returns maximum value from multiple positive bigints', () => {
+    expect(bigIntMax(1n, 5n, 3n, 9n, 2n)).toBe(9n);
+  });
+
+  test('returns maximum value from multiple negative bigints', () => {
+    expect(bigIntMax(-10n, -5n, -20n, -1n)).toBe(-1n);
+  });
+
+  test('returns maximum value from mixed positive and negative bigints', () => {
+    expect(bigIntMax(-5n, 10n, -20n, 3n, -1n)).toBe(10n);
+  });
+
+  test('returns the single value when only one argument is provided', () => {
+    expect(bigIntMax(42n)).toBe(42n);
+  });
+
+  test('returns correct value when all values are equal', () => {
+    expect(bigIntMax(5n, 5n, 5n)).toBe(5n);
+  });
+
+  test('handles very large bigint values', () => {
+    const largeValue = 999999999999999999999999999999n;
+    const smallerValue = 999999999999999999999999999998n;
+    expect(bigIntMax(smallerValue, largeValue)).toBe(largeValue);
+  });
+
+  test('returns zero when comparing zero with negative values', () => {
+    expect(bigIntMax(0n, -5n, -10n)).toBe(0n);
+  });
+
+  test('handles two values correctly', () => {
+    expect(bigIntMax(100n, 200n)).toBe(200n);
+    expect(bigIntMax(200n, 100n)).toBe(200n);
+  });
+});
+
+describe('bigIntMin', () => {
+  test('returns minimum value from multiple positive bigints', () => {
+    expect(bigIntMin(1n, 5n, 3n, 9n, 2n)).toBe(1n);
+  });
+
+  test('returns minimum value from multiple negative bigints', () => {
+    expect(bigIntMin(-10n, -5n, -20n, -1n)).toBe(-20n);
+  });
+
+  test('returns minimum value from mixed positive and negative bigints', () => {
+    expect(bigIntMin(-5n, 10n, -20n, 3n, -1n)).toBe(-20n);
+  });
+
+  test('returns the single value when only one argument is provided', () => {
+    expect(bigIntMin(42n)).toBe(42n);
+  });
+
+  test('returns correct value when all values are equal', () => {
+    expect(bigIntMin(5n, 5n, 5n)).toBe(5n);
+  });
+
+  test('handles very large bigint values', () => {
+    const largeValue = 999999999999999999999999999999n;
+    const smallerValue = 999999999999999999999999999998n;
+    expect(bigIntMin(smallerValue, largeValue)).toBe(smallerValue);
+  });
+
+  test('returns negative value when comparing zero with negative values', () => {
+    expect(bigIntMin(0n, -5n, -10n)).toBe(-10n);
+  });
+
+  test('handles two values correctly', () => {
+    expect(bigIntMin(100n, 200n)).toBe(100n);
+    expect(bigIntMin(200n, 100n)).toBe(100n);
+  });
+});

utils/bigInt.ts

@@ -0,0 +1,4 @@
+export const bigIntMax = (...args: bigint[]) =>
+  args.reduce((a, b) => (a > b ? a : b));
+export const bigIntMin = (...args: bigint[]) =>
+  args.reduce((a, b) => (a < b ? a : b));

utils/cache.ts

@@ -30,6 +30,8 @@ const getRebaseRewardCacheFile = (vaultAddress: string) =>
   path.resolve('cache', `rebase-rewards-cache-${vaultAddress}.json`);
 const getNodeOperatorFeeRateCacheFile = (vaultAddress: string) =>
   path.resolve('cache', `node-operator-fee-rate-cache-${vaultAddress}.json`);
+const getSettledGrowthCacheFile = (vaultAddress: string) =>
+  path.resolve('cache', `settled-growth-cache-${vaultAddress}.json`);
 const getIndexedEventsCacheFile = (poolAddress: string) =>
   path.resolve('cache', `indexed-events-cache-${poolAddress}.json`);
 
@@ -45,6 +47,7 @@ export const cache = {
     }
     return null;
   },
+
   async setShareRate(blockNumber: number, value: bigint) {
     let data: Record<string, string> = {};
     try {
@@ -58,6 +61,7 @@ export const cache = {
     });
     await fs.writeFile(getShareRateCacheFile(), JSON.stringify(data), 'utf-8');
   },
+
   async getRebaseReward(
     vaultAddress: string,
     cacheKey: string,
@@ -72,6 +76,7 @@ export const cache = {
     }
     return null;
   },
+
   async setRebaseReward(vaultAddress: string, cacheKey: string, value: bigint) {
     let data: Record<string, string> = {};
     try {
@@ -91,6 +96,7 @@ export const cache = {
       'utf-8',
     );
   },
+
   async getNodeOperatorFeeRate(
     vaultAddress: string,
     blockNumber: number,
@@ -108,6 +114,7 @@ export const cache = {
     }
     return null;
   },
+
   async setNodeOperatorFeeRate(
     vaultAddress: string,
     blockNumber: number,
@@ -137,6 +144,46 @@ export const cache = {
       'utf-8',
     );
   },
+
+  async getSettledGrowth(
+    vaultAddress: string,
+    blockNumber: number,
+  ): Promise<bigint | null> {
+    try {
+      const data = JSON.parse(
+        await fs.readFile(getSettledGrowthCacheFile(vaultAddress), 'utf-8'),
+      );
+      if (data[blockNumber] !== undefined) return BigInt(data[blockNumber]);
+    } catch {
+      /* ignore */
+    }
+    return null;
+  },
+
+  async setSettledGrowth(
+    vaultAddress: string,
+    blockNumber: number,
+    value: bigint,
+  ) {
+    let data: Record<string, string> = {};
+    try {
+      data = JSON.parse(
+        await fs.readFile(getSettledGrowthCacheFile(vaultAddress), 'utf-8'),
+      );
+    } catch {
+      /* ignore */
+    }
+    data[blockNumber] = value.toString();
+    await fs.mkdir(path.dirname(getSettledGrowthCacheFile(vaultAddress)), {
+      recursive: true,
+    });
+    await fs.writeFile(
+      getSettledGrowthCacheFile(vaultAddress),
+      JSON.stringify(data),
+      'utf-8',
+    );
+  },
+
   async getIndexedEventsByBlock(
     poolAddress: string,
     blockNumber: bigint,
@@ -152,6 +199,7 @@ export const cache = {
     }
     return null;
   },
+
   async getAllIndexedEvents(
     poolAddress: string,
   ): Promise<Record<string, CachedEvents>> {
@@ -165,6 +213,7 @@ export const cache = {
     }
     return {};
   },
+
   async setIndexedEventsForBlocks(
     poolAddress: string,
     eventsMap: Map<bigint, CachedEvents>,

utils/calculate-overview-v2.ts

@@ -1,4 +1,5 @@
 import { calculateHealth } from './health/calculate-health.js';
+import { bigIntMax, bigIntMin } from './bigInt.js';
 
 type OverviewArgs = {
   totalValue: bigint;
@@ -17,9 +18,6 @@ type OverviewArgs = {
 
 const BASIS_POINTS = 10_000n;
 
-const bigIntMax = (...args: bigint[]) => args.reduce((a, b) => (a > b ? a : b));
-const bigIntMin = (...args: bigint[]) => args.reduce((a, b) => (a < b ? a : b));
-
 /**
  * Performs division with rounding up (ceiling division) for bigint values
  * @param numerator - The dividend

utils/calculate-overview.ts

@@ -1,6 +1,7 @@
 import { parseEther } from 'viem';
 
 import { calculateHealth } from './health/calculate-health.js';
+import { bigIntMax, bigIntMin } from './bigInt.js';
 import { BASIS_POINTS_DENOMINATOR, SCALING_FACTOR } from './consts.js';
 
 type OverviewArgs = {
@@ -15,8 +16,6 @@ type OverviewArgs = {
   totalMintingCapacityStethWei: bigint;
 };
 
-const bigIntMax = (...args: bigint[]) => args.reduce((a, b) => (a > b ? a : b));
-const bigIntMin = (...args: bigint[]) => args.reduce((a, b) => (a < b ? a : b));
 // Percent helper (basis points → percentage)
 export const formatBP = (bp: number | bigint) =>
   `${((Number(bp) / Number(BASIS_POINTS_DENOMINATOR)) * 100).toFixed(2)}%`;