Merge pull request #1490 from lidofinance/feat/view-vault-info

Author: tamtamchik

contracts/0.8.25/vaults/LazyOracle.sol

@@ -226,29 +226,40 @@ contract LazyOracle is ILazyOracle, AccessControlEnumerableUpgradeable {
         VaultInfo[] memory batch = new VaultInfo[](batchSize);
         for (uint256 i = 0; i < batchSize; i++) {
             address vaultAddress = vaultHub.vaultByIndex(_offset + i + 1);
-            IStakingVault vault = IStakingVault(vaultAddress);
-            VaultHub.VaultConnection memory connection = vaultHub.vaultConnection(vaultAddress);
-            VaultHub.VaultRecord memory record = vaultHub.vaultRecord(vaultAddress);
-            batch[i] = VaultInfo(
-                vaultAddress,
-                vault.availableBalance() + vault.stagedBalance(),
-                record.inOutDelta.currentValue(),
-                vault.withdrawalCredentials(),
-                record.liabilityShares,
-                record.maxLiabilityShares,
-                _mintableStETH(vaultAddress),
-                connection.shareLimit,
-                connection.reserveRatioBP,
-                connection.forcedRebalanceThresholdBP,
-                connection.infraFeeBP,
-                connection.liquidityFeeBP,
-                connection.reservationFeeBP,
-                vaultHub.isPendingDisconnect(vaultAddress)
-            );
+            batch[i] = _vaultInfo(vaultAddress, vaultHub);
         }
         return batch;
     }
 
+    /// @notice returns the vault data info
+    /// @param _vault the address of the vault
+    /// @return the vault data info
+    function vaultInfo(address _vault) external view returns (VaultInfo memory) {
+        return _vaultInfo(_vault, _vaultHub());
+    }
+
+    function _vaultInfo(address _vault, VaultHub _vaultHub) internal view returns (VaultInfo memory) {
+        IStakingVault vault = IStakingVault(_vault);
+        VaultHub.VaultConnection memory connection = _vaultHub.vaultConnection(_vault);
+        VaultHub.VaultRecord memory record = _vaultHub.vaultRecord(_vault);
+        return VaultInfo(
+            _vault,
+            vault.availableBalance() + vault.stagedBalance(),
+            record.inOutDelta.currentValue(),
+            vault.withdrawalCredentials(),
+            record.liabilityShares,
+            record.maxLiabilityShares,
+            _mintableStETH(_vault),
+            connection.shareLimit,
+            connection.reserveRatioBP,
+            connection.forcedRebalanceThresholdBP,
+            connection.infraFeeBP,
+            connection.liquidityFeeBP,
+            connection.reservationFeeBP,
+            _vaultHub.isPendingDisconnect(_vault)
+        );
+    }
+
     /**
      * @notice batch method to mass check the validator stages in PredepositGuarantee contract
      * @param _pubkeys the array of validator's pubkeys to check

contracts/0.8.25/vaults/OperatorGrid.sol

@@ -674,7 +674,7 @@ contract OperatorGrid is AccessControlEnumerableUpgradeable, Confirmable2Address
         emit VaultJailStatusUpdated(_vault, _isInJail);
     }
 
-    /// @notice Get vault limits
+    /// @notice Get vault's tier limits
     /// @param _vault address of the vault
     /// @return nodeOperator node operator of the vault
     /// @return tierId tier id of the vault
@@ -684,7 +684,7 @@ contract OperatorGrid is AccessControlEnumerableUpgradeable, Confirmable2Address
     /// @return infraFeeBP infra fee of the vault
     /// @return liquidityFeeBP liquidity fee of the vault
     /// @return reservationFeeBP reservation fee of the vault
-    function vaultInfo(address _vault)
+    function vaultTierInfo(address _vault)
         external
         view
         returns (

contracts/0.8.25/vaults/VaultHub.sol

@@ -367,7 +367,7 @@ contract VaultHub is PausableUntilWithRoles {
             uint256 infraFeeBP,
             uint256 liquidityFeeBP,
             uint256 reservationFeeBP
-        ) = _operatorGrid().vaultInfo(_vault);
+        ) = _operatorGrid().vaultTierInfo(_vault);
 
         _connectVault(_vault,
             shareLimit,

test/0.8.25/vaults/lazyOracle/contracts/VaultHub__MockForLazyOracle.sol

@@ -87,6 +87,10 @@ contract VaultHub__MockForLazyOracle {
         return false;
     }
 
+    function isVaultConnected(address _vault) external view returns (bool) {
+        return mock__vaultConnections[_vault].vaultIndex != 0;
+    }
+
     function totalMintingCapacityShares(address _vault, int256 _deltaValue) external view returns (uint256) {
         uint256 base = mock__vaultRecords[_vault].report.totalValue;
         uint256 maxLockableValue = _deltaValue >= 0 ? base + uint256(_deltaValue) : base - uint256(-_deltaValue);

test/0.8.25/vaults/lazyOracle/lazyOracle.test.ts

@@ -227,6 +227,76 @@ describe("LazyOracle.sol", () => {
     });
   });
 
+  context("vaultInfo", () => {
+    it("returns the vault info for a single vault", async () => {
+      const vault1 = await createVault();
+      await vaultHub.mock__addVault(vault1);
+
+      await vaultHub.mock__setVaultConnection(vault1, {
+        owner: randomAddress(),
+        shareLimit: 2000n,
+        vaultIndex: 1,
+        disconnectInitiatedTs: DISCONNECT_NOT_INITIATED,
+        reserveRatioBP: 5000,
+        forcedRebalanceThresholdBP: 8000,
+        infraFeeBP: 1500,
+        liquidityFeeBP: 2500,
+        reservationFeeBP: 3500,
+        isBeaconDepositsManuallyPaused: false,
+      });
+
+      await vaultHub.mock__setVaultRecord(vault1, {
+        report: {
+          totalValue: 0n, // Set to 0 to make mintableStETH calculation return 0
+          inOutDelta: 3000000000000000000n,
+          timestamp: 2000000000n,
+        },
+        maxLiabilityShares: 8n,
+        liabilityShares: 6n,
+        inOutDelta: [
+          {
+            value: 10n,
+            valueOnRefSlot: 12n,
+            refSlot: 9n,
+          },
+          {
+            value: 0n,
+            valueOnRefSlot: 0n,
+            refSlot: 0n,
+          },
+        ],
+        minimalReserve: 0n,
+        redemptionShares: 0n,
+        cumulativeLidoFees: 0n,
+        settledLidoFees: 0n,
+      });
+
+      const vaultInfo = await lazyOracle.vaultInfo(vault1);
+
+      expect(vaultInfo.vault).to.equal(vault1);
+      expect(vaultInfo.aggregatedBalance).to.equal(0n);
+      expect(vaultInfo.inOutDelta).to.equal(10n);
+      expect(vaultInfo.withdrawalCredentials).to.equal(ZERO_BYTES32);
+      expect(vaultInfo.liabilityShares).to.equal(6n);
+      expect(vaultInfo.maxLiabilityShares).to.equal(8n);
+      expect(vaultInfo.mintableStETH).to.equal(0n);
+      expect(vaultInfo.shareLimit).to.equal(2000n);
+      expect(vaultInfo.reserveRatioBP).to.equal(5000);
+      expect(vaultInfo.forcedRebalanceThresholdBP).to.equal(8000);
+      expect(vaultInfo.infraFeeBP).to.equal(1500);
+      expect(vaultInfo.liquidityFeeBP).to.equal(2500);
+      expect(vaultInfo.reservationFeeBP).to.equal(3500);
+      expect(vaultInfo.pendingDisconnect).to.equal(false);
+    });
+
+    it("reverts with VaultNotConnected for non-existent vault", async () => {
+      const nonExistentVault = randomAddress();
+
+      // The contract will revert with VaultNotConnected error for non-connected vaults
+      await expect(lazyOracle.vaultInfo(nonExistentVault)).to.be.reverted;
+    });
+  });
+
   context("getter functions", () => {
     it("return latest report data", async () => {
       const reportData = await lazyOracle.latestReportData();

test/0.8.25/vaults/operatorGrid/operatorGrid.test.ts

@@ -1078,7 +1078,7 @@ describe("OperatorGrid.sol", () => {
 
       const group = await operatorGrid.group(nodeOperator1);
 
-      const vaultTier = await operatorGrid.vaultInfo(vault_NO1_V1);
+      const vaultTier = await operatorGrid.vaultTierInfo(vault_NO1_V1);
       const tier = await operatorGrid.tier(vaultTier.tierId);
 
       expect(group.liabilityShares).to.equal(tierShareLimit);
@@ -1216,8 +1216,8 @@ describe("OperatorGrid.sol", () => {
       const group = await operatorGrid.group(nodeOperator1);
       const group2 = await operatorGrid.group(nodeOperator2);
 
-      const vaultTier = await operatorGrid.vaultInfo(vault_NO1_V1);
-      const vaultTier2 = await operatorGrid.vaultInfo(vault_NO2_V2);
+      const vaultTier = await operatorGrid.vaultTierInfo(vault_NO1_V1);
+      const vaultTier2 = await operatorGrid.vaultTierInfo(vault_NO2_V2);
 
       const tier = await operatorGrid.tier(vaultTier.tierId);
       const tier2 = await operatorGrid.tier(vaultTier2.tierId);
@@ -1729,8 +1729,8 @@ describe("OperatorGrid.sol", () => {
 
       const group = await operatorGrid.group(nodeOperator1);
 
-      const vaultTier = await operatorGrid.vaultInfo(vault_NO1_V1);
-      const vaultTier2 = await operatorGrid.vaultInfo(vault_NO1_V2);
+      const vaultTier = await operatorGrid.vaultTierInfo(vault_NO1_V1);
+      const vaultTier2 = await operatorGrid.vaultTierInfo(vault_NO1_V2);
 
       const tier = await operatorGrid.tier(vaultTier.tierId);
       const tier2 = await operatorGrid.tier(vaultTier2.tierId);
@@ -1800,7 +1800,7 @@ describe("OperatorGrid.sol", () => {
         retInfraFee,
         retLiquidityFee,
         retReservationFee,
-      ] = await operatorGrid.vaultInfo(vault_NO1_V1);
+      ] = await operatorGrid.vaultTierInfo(vault_NO1_V1);
 
       expect(retGroupOperator).to.equal(nodeOperator1);
       expect(retTierIndex).to.equal(tier_NO1_Id1);
@@ -1821,12 +1821,12 @@ describe("OperatorGrid.sol", () => {
     });
 
     it("does nothing if vault is already in default tier", async () => {
-      const vaultTierBefore = await operatorGrid.vaultInfo(vault_NO1_V1);
+      const vaultTierBefore = await operatorGrid.vaultTierInfo(vault_NO1_V1);
       expect(vaultTierBefore.tierId).to.equal(await operatorGrid.DEFAULT_TIER_ID());
 
       await operatorGrid.connect(vaultHubAsSigner).resetVaultTier(vault_NO1_V1);
 
-      const vaultTierAfter = await operatorGrid.vaultInfo(vault_NO1_V1);
+      const vaultTierAfter = await operatorGrid.vaultTierInfo(vault_NO1_V1);
       expect(vaultTierAfter.tierId).to.equal(await operatorGrid.DEFAULT_TIER_ID());
     });
 
@@ -1847,14 +1847,14 @@ describe("OperatorGrid.sol", () => {
       await operatorGrid.connect(vaultOwner).changeTier(vault_NO1_V1, 1, shareLimit);
       await operatorGrid.connect(nodeOperator1).changeTier(vault_NO1_V1, 1, shareLimit);
 
-      const vaultTierBefore = await operatorGrid.vaultInfo(vault_NO1_V1);
+      const vaultTierBefore = await operatorGrid.vaultTierInfo(vault_NO1_V1);
       expect(vaultTierBefore.tierId).to.equal(1);
 
       // Reset tier
       await operatorGrid.connect(vaultHubAsSigner).resetVaultTier(vault_NO1_V1);
 
       // Check final state
-      const vaultTierAfter = await operatorGrid.vaultInfo(vault_NO1_V1);
+      const vaultTierAfter = await operatorGrid.vaultTierInfo(vault_NO1_V1);
       expect(vaultTierAfter.tierId).to.equal(await operatorGrid.DEFAULT_TIER_ID());
     });
   });

test/0.8.25/vaults/vaulthub/contracts/OperatorGrid__MockForVaultHub.sol

@@ -36,13 +36,13 @@ contract OperatorGrid__MockForVaultHub {
         tierParams.reservationFeeBP = uint16(_tierParams.reservationFeeBP);
     }
 
-    function vaultInfo(
+    function vaultTierInfo(
         address _vault
     )
         external
         view
         returns (
-            uint256 groupId,
+            address nodeOperator,
             uint256 tierId,
             uint256 shareLimit,
             uint256 reserveRatioBP,
@@ -54,8 +54,8 @@ contract OperatorGrid__MockForVaultHub {
     {
         Tier memory tierParams = tiers[vaultTier[_vault]];
 
-        groupId = 0;
-        tierId = 0;
+        nodeOperator = tierParams.operator;
+        tierId = vaultTier[_vault];
         shareLimit = tierParams.shareLimit;
         reserveRatioBP = tierParams.reserveRatioBP;
         forcedRebalanceThresholdBP = tierParams.forcedRebalanceThresholdBP;

test/integration/vaults/operator.grid.integration.ts

@@ -95,7 +95,7 @@ describe("Integration: OperatorGrid", () => {
       ]);
 
       // Initially vault is in default tier (0)
-      const beforeInfo = await operatorGrid.vaultInfo(stakingVault);
+      const beforeInfo = await operatorGrid.vaultTierInfo(stakingVault);
       expect(beforeInfo.tierId).to.equal(0n);
 
       const requestedTierId = 1n;
@@ -110,7 +110,7 @@ describe("Integration: OperatorGrid", () => {
         operatorGrid.connect(nodeOperator).changeTier(stakingVault, requestedTierId, requestedShareLimit),
       ).to.emit(vaultHub, "VaultConnectionUpdated");
 
-      const afterInfo = await operatorGrid.vaultInfo(stakingVault);
+      const afterInfo = await operatorGrid.vaultTierInfo(stakingVault);
       expect(afterInfo.tierId).to.equal(requestedTierId);
 
       const connection = await vaultHub.vaultConnection(stakingVault);
@@ -258,7 +258,7 @@ describe("Integration: OperatorGrid", () => {
 
     it("reverts when requested share limit exceeds tier limit", async () => {
       // Default tier case
-      const info = await operatorGrid.vaultInfo(stakingVault);
+      const info = await operatorGrid.vaultTierInfo(stakingVault);
       const over = info.shareLimit + 1n;
       await expect(dashboard.updateShareLimit(over)).to.be.revertedWithCustomError(
         operatorGrid,
@@ -330,15 +330,15 @@ describe("Integration: OperatorGrid", () => {
       await expect(dashboard.mintShares(owner, 100n)).to.be.revertedWithCustomError(operatorGrid, "VaultInJail");
 
       // Get initial tier
-      const initialVaultInfo = await operatorGrid.vaultInfo(stakingVault);
+      const initialVaultInfo = await operatorGrid.vaultTierInfo(stakingVault);
       expect(initialVaultInfo.tierId).to.equal(0); // Should be default tier
 
       // Change tier from default (0) to tier 1
       await operatorGrid.connect(nodeOperator).changeTier(stakingVault, 1, ether("1000"));
       await dashboard.connect(owner).changeTier(1, ether("1000"));
 
       // Verify tier changed
-      const updatedVaultInfo = await operatorGrid.vaultInfo(stakingVault);
+      const updatedVaultInfo = await operatorGrid.vaultTierInfo(stakingVault);
       expect(updatedVaultInfo.tierId).to.equal(1);
 
       // Verify jail status is preserved after tier change

test/integration/vaults/vaulthub.disconnect.integration.ts

@@ -65,7 +65,7 @@ describe("Integration: VaultHub", () => {
           .to.emit(vaultHub, "VaultDisconnectInitiated")
           .withArgs(stakingVault);
 
-        expect((await operatorGrid.vaultInfo(stakingVault)).tierId).to.be.equal(tierId);
+        expect((await operatorGrid.vaultTierInfo(stakingVault)).tierId).to.be.equal(tierId);
         expect(await vaultHub.isPendingDisconnect(stakingVault)).to.be.true;
         expect(await vaultHub.isVaultConnected(stakingVault)).to.be.true;
         expect(await vaultHub.locked(stakingVault)).to.be.equal(ether("1"));
@@ -120,7 +120,7 @@ describe("Integration: VaultHub", () => {
         .to.emit(vaultHub, "VaultDisconnectCompleted")
         .withArgs(stakingVault);
 
-      expect((await operatorGrid.vaultInfo(stakingVault)).tierId).to.be.equal(0n);
+      expect((await operatorGrid.vaultTierInfo(stakingVault)).tierId).to.be.equal(0n);
       expect(await vaultHub.isPendingDisconnect(stakingVault)).to.be.false;
       expect(await vaultHub.isVaultConnected(stakingVault)).to.be.false;
       expect(await vaultHub.locked(stakingVault)).to.be.equal(0n);
@@ -154,7 +154,7 @@ describe("Integration: VaultHub", () => {
         .to.emit(vaultHub, "VaultDisconnectAborted")
         .withArgs(stakingVault, ether("1"));
 
-      expect((await operatorGrid.vaultInfo(stakingVault)).tierId).to.be.equal(tierId);
+      expect((await operatorGrid.vaultTierInfo(stakingVault)).tierId).to.be.equal(tierId);
       expect(await vaultHub.isPendingDisconnect(stakingVault)).to.be.false;
       expect(await vaultHub.isVaultConnected(stakingVault)).to.be.true;
       expect(await vaultHub.locked(stakingVault)).to.be.equal(ether("1"));