feat: add integration test to check report simulation while bad debt

Author: rkolpakov

test/integration/vaults/bad-debt.integration.ts

@@ -1,16 +1,20 @@
 import { expect } from "chai";
+import { ContractTransactionReceipt, ZeroAddress } from "ethers";
 import { ethers } from "hardhat";
 
 import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
+import { setBalance } from "@nomicfoundation/hardhat-network-helpers";
 
 import { Dashboard, StakingVault } from "typechain-types";
 
-import { MAX_UINT256 } from "lib";
+import { MAX_UINT256, ONE_GWEI } from "lib";
 import {
   changeTier,
   createVaultWithDashboard,
   DEFAULT_TIER_PARAMS,
+  finalizeWQViaElVault,
   getProtocolContext,
+  getReportTimeElapsed,
   ProtocolContext,
   report,
   reportVaultDataWithProof,
@@ -36,9 +40,13 @@ describe("Integration: Vault with bad debt", () => {
 
   before(async () => {
     ctx = await getProtocolContext();
-    const { lido, stakingVaultFactory, vaultHub } = ctx.contracts;
+    const { lido, stakingVaultFactory, vaultHub, elRewardsVault } = ctx.contracts;
     originalSnapshot = await Snapshot.take();
 
+    await waitNextAvailableReportTime(ctx);
+    await finalizeWQViaElVault(ctx);
+    await setBalance(elRewardsVault.address, 0);
+
     [, owner, nodeOperator, otherOwner, daoAgent] = await ethers.getSigners();
     await setupLidoForVaults(ctx);
 
@@ -74,6 +82,12 @@ describe("Integration: Vault with bad debt", () => {
     await vaultHub.connect(await ctx.getSigner("agent")).grantRole(await vaultHub.BAD_DEBT_MASTER_ROLE(), daoAgent);
   });
 
+  const getFirstEvent = (receipt: ContractTransactionReceipt, eventName: string) => {
+    const events = ctx.getEvents(receipt, eventName);
+    expect(events.length).to.be.greaterThan(0);
+    return events[0];
+  };
+
   beforeEach(async () => (snapshot = await Snapshot.take()));
   afterEach(async () => await Snapshot.restore(snapshot));
   after(async () => await Snapshot.restore(originalSnapshot));
@@ -233,4 +247,95 @@ describe("Integration: Vault with bad debt", () => {
       expect(await vaultHub.badDebtToInternalize()).to.be.equal(0n);
     });
   });
+
+  describe("Report simulation (accounting)", () => {
+    it("simulateOracleReport result matches handleOracleReport while bad debt", async () => {
+      const { lido, hashConsensus, accounting, elRewardsVault, withdrawalVault, withdrawalQueue, vaultHub } =
+        ctx.contracts;
+
+      const clRebase = ether("50");
+      const elRewards = ether("100");
+      const withdrawalVaultBalance = ether("100");
+      const withdrawalRequestAmount = ether("20");
+
+      await lido.connect(otherOwner).submit(ZeroAddress, { value: withdrawalRequestAmount });
+      await lido.connect(otherOwner).approve(withdrawalQueue.address, withdrawalRequestAmount);
+      await withdrawalQueue.connect(otherOwner).requestWithdrawals([withdrawalRequestAmount], otherOwner.address);
+      const withdrawalRequestId = await withdrawalQueue.getLastRequestId();
+
+      await setBalance(elRewardsVault.address, elRewards);
+      await setBalance(withdrawalVault.address, withdrawalVaultBalance);
+
+      const badDebtShares =
+        (await dashboard.liabilityShares()) - (await lido.getSharesByPooledEth(await dashboard.totalValue()));
+      await vaultHub.connect(daoAgent).internalizeBadDebt(stakingVault, badDebtShares);
+
+      const refSlot = (await hashConsensus.getCurrentFrame()).refSlot;
+      const { genesisTime, secondsPerSlot } = await hashConsensus.getChainConfig();
+      const reportTimestamp = genesisTime + refSlot * secondsPerSlot;
+      const { timeElapsed } = await getReportTimeElapsed(ctx);
+
+      const params = { clDiff: clRebase, reportElVault: true, reportWithdrawalsVault: true, dryRun: true };
+      const { data: reportData } = await report(ctx, params);
+
+      const externalSharesBefore = await lido.getExternalShares();
+      const totalSharesBefore = await lido.getTotalShares();
+      const internalSharesBefore = totalSharesBefore - externalSharesBefore;
+
+      const elRewardsBalanceBefore = await ethers.provider.getBalance(elRewardsVault);
+      const withdrawalVaultBalanceBefore = await ethers.provider.getBalance(withdrawalVault);
+
+      const simulated = await accounting.simulateOracleReport({
+        timestamp: reportTimestamp,
+        timeElapsed,
+        clValidators: reportData.numValidators,
+        clBalance: BigInt(reportData.clBalanceGwei) * ONE_GWEI,
+        withdrawalVaultBalance: reportData.withdrawalVaultBalance,
+        elRewardsVaultBalance: reportData.elRewardsVaultBalance,
+        sharesRequestedToBurn: reportData.sharesRequestedToBurn,
+        withdrawalFinalizationBatches: reportData.withdrawalFinalizationBatches,
+        simulatedShareRate: reportData.simulatedShareRate,
+      });
+
+      const { reportTx } = await report(ctx, { ...params, dryRun: false });
+
+      const reportTxReceipt = await reportTx!.wait();
+      const tokenRebasedEvent = getFirstEvent(reportTxReceipt!, "TokenRebased");
+
+      expect(simulated.preTotalShares).to.equal(tokenRebasedEvent.args.preTotalShares);
+      expect(simulated.preTotalPooledEther).to.equal(tokenRebasedEvent.args.preTotalEther);
+      expect(simulated.postTotalShares).to.equal(tokenRebasedEvent.args.postTotalShares);
+      expect(simulated.postTotalPooledEther).to.equal(tokenRebasedEvent.args.postTotalEther);
+
+      const externalSharesAfter = await lido.getExternalShares();
+      const totalSharesAfter = await lido.getTotalShares();
+      const totalPooledEtherAfter = await lido.getTotalPooledEther();
+
+      const elRewardsBalanceAfter = await ethers.provider.getBalance(elRewardsVault);
+      const withdrawalVaultBalanceAfter = await ethers.provider.getBalance(withdrawalVault);
+
+      expect(elRewardsBalanceBefore - simulated.elRewardsVaultTransfer).to.equal(elRewardsBalanceAfter);
+      expect(withdrawalVaultBalanceBefore - simulated.withdrawalsVaultTransfer).to.equal(withdrawalVaultBalanceAfter);
+
+      const [withdrawalRequestData] = await withdrawalQueue.getWithdrawalStatus([withdrawalRequestId]);
+      const actualBadDebtInternalized = externalSharesBefore - externalSharesAfter;
+
+      expect(simulated.etherToFinalizeWQ).to.equal(withdrawalRequestAmount);
+      expect(simulated.etherToFinalizeWQ).to.equal(withdrawalRequestData.amountOfStETH);
+      expect(simulated.sharesToFinalizeWQ).to.equal(withdrawalRequestData.amountOfShares);
+      expect(simulated.sharesToBurnForWithdrawals).to.equal(withdrawalRequestData.amountOfShares);
+      expect(simulated.totalSharesToBurn).to.equal(totalSharesBefore - totalSharesAfter + simulated.sharesToMintAsFees);
+
+      expect(simulated.postInternalShares).to.equal(totalSharesAfter - externalSharesAfter);
+      expect(simulated.postInternalShares).to.equal(
+        internalSharesBefore - simulated.totalSharesToBurn + simulated.sharesToMintAsFees + actualBadDebtInternalized,
+      );
+
+      expect(simulated.postInternalEther).to.equal(totalPooledEtherAfter - (await lido.getExternalEther()));
+      expect(simulated.sharesToMintAsFees).to.equal(tokenRebasedEvent.args.sharesMintedAsFees);
+
+      const elRewardsReceived = ctx.getEvents(reportTxReceipt!, "ELRewardsReceived");
+      expect(simulated.elRewardsVaultTransfer).to.equal(elRewardsReceived[0].args.amount);
+    });
+  });
 });