fuzz: CAT-3-4 max EB (2048 ETH/validator) high burn rate accrual

test/ssv-fuzz-engine/core/assertions.ts

@@ -375,7 +375,7 @@ export async function assertOperatorEarningsWithEB<S extends { cluster: ClusterR
 
       for (const op of operators) {
         const packedFee = op.fee / ETH_DEDUCTED_DIGITS;
-        const expectedDelta = ((packedFee * prev.vUnits) / BPS_DENOMINATOR) * ETH_DEDUCTED_DIGITS * blocks;
+        const expectedDelta = ((blocks * packedFee * prev.vUnits) / BPS_DENOMINATOR) * ETH_DEDUCTED_DIGITS;
         expect(currentEarnings.get(op.id)).to.equal(prev.earnings.get(op.id)! + expectedDelta);
       }
     }
@@ -384,6 +384,46 @@ export async function assertOperatorEarningsWithEB<S extends { cluster: ClusterR
   ctx.state.lastEBOperatorEarnings = { block, earnings: currentEarnings, vUnits: currentVUnits };
 }
 
+export interface EBNetworkEarningsSnapshot {
+  block: bigint;
+  earnings: bigint;
+  vUnits: bigint;
+}
+
+export async function assertNetworkEarningsWithEB<S extends {
+  cluster: ClusterRecord;
+  operators: OperatorRecord[];
+  lastEBNetworkEarnings?: EBNetworkEarningsSnapshot;
+}>(ctx: FuzzContext<S>): Promise<void> {
+  const block = BigInt(await ctx.provider.getBlockNumber());
+  const { cluster } = ctx.state;
+  const currentEarnings = BigInt(await ctx.views.getNetworkEarnings());
+  const networkFee = BigInt(await ctx.views.getNetworkFee());
+
+  let currentVUnits: bigint;
+  if (cluster.cluster.active && BigInt(cluster.cluster.validatorCount) > 0n) {
+    const eb = BigInt(await ctx.views.getEffectiveBalance(
+      cluster.owner.address, cluster.operatorIds, cluster.cluster,
+    ));
+    currentVUnits = ebToVUnits(eb);
+  } else {
+    currentVUnits = 0n;
+  }
+
+  if (ctx.state.lastEBNetworkEarnings !== undefined) {
+    const prev = ctx.state.lastEBNetworkEarnings;
+    if (prev.vUnits === currentVUnits) {
+      const blocks = block - prev.block;
+      const packedNetFee = networkFee / ETH_DEDUCTED_DIGITS;
+      const expectedDelta =
+        ((blocks * packedNetFee * prev.vUnits) / BPS_DENOMINATOR) * ETH_DEDUCTED_DIGITS;
+      expect(currentEarnings).to.equal(prev.earnings + expectedDelta);
+    }
+  }
+
+  ctx.state.lastEBNetworkEarnings = { block, earnings: currentEarnings, vUnits: currentVUnits };
+}
+
 export async function assertDaoVUnitsMatchCluster<S extends { cluster: ClusterRecord; operators: OperatorRecord[] }>(
   ctx: FuzzContext<S>,
 ): Promise<void> {

test/ssv-fuzz-engine/core/runner.ts

@@ -88,4 +88,17 @@ export async function fuzz<S>(config: FuzzConfig<S>, seed: bigint): Promise<void
       );
     }
   }
+
+  if (config.after) {
+    try {
+      await config.after(ctx);
+    } catch (err: any) {
+      const msg = err?.message ?? String(err);
+      throw new Error(
+        `after() hook failed:\n` +
+        `  Reproduce: FUZZ_SEED=${seed} npx hardhat test <testfile>\n` +
+        `  ${msg}`,
+      );
+    }
+  }
 }

test/ssv-fuzz-engine/core/types.ts

@@ -30,6 +30,7 @@ export interface FuzzConfig<S> {
   setup: SetupFn<S>;
   steps: (StepFn<S> | NamedStep<S>)[];
   expectedPhase?: string;
+  after?: (ctx: FuzzContext<S>) => Promise<void>;
 }
 
 export interface OperatorRecord {