fix : Delayed broadcasting of voluntary exits

packages/api/test/unit/beacon/genericServerTest/debug.test.ts

@@ -16,15 +16,14 @@ import {getMockApi, getTestServer} from "../../../utils/utils.js";
 import {testData} from "../testData/debug.js";
 
 describe("beacon / debug", () => {
-  // Extend timeout since states are very big
-  vi.setConfig({testTimeout: 30_000});
+  // Extend timeout since states are very big - increased to 60 seconds
+  vi.setConfig({testTimeout: 60_000, hookTimeout: 60_000});
 
   const config = createChainForkConfig({...defaultChainConfig, ELECTRA_FORK_EPOCH: 0});
 
   runGenericServerTest<Endpoints>(config, getClient, getRoutes, testData);
 
   // Get state by SSZ
-
   describe("get state in SSZ format", () => {
     const mockApi = getMockApi<Endpoints>(getDefinitions(config));
     let baseUrl: string;
@@ -46,6 +45,7 @@ describe("beacon / debug", () => {
     it("getStateV2", async () => {
       const state = ssz.electra.BeaconState.defaultValue();
       const stateSerialized = ssz.electra.BeaconState.serialize(state);
+
       mockApi.getStateV2.mockResolvedValue({
         data: stateSerialized,
         meta: {version: ForkName.electra, executionOptimistic: false, finalized: false},

packages/beacon-node/src/chain/errors/voluntaryExitError.ts

@@ -9,6 +9,7 @@ export enum VoluntaryExitErrorCode {
   SHORT_TIME_ACTIVE = "VOLUNTARY_EXIT_ERROR_SHORT_TIME_ACTIVE",
   PENDING_WITHDRAWALS = "VOLUNTARY_EXIT_ERROR_PENDING_WITHDRAWALS",
   INVALID_SIGNATURE = "VOLUNTARY_EXIT_ERROR_INVALID_SIGNATURE",
+  INVALID = "INVALID",
 }
 export type VoluntaryExitErrorType =
   | {code: VoluntaryExitErrorCode.ALREADY_EXISTS}

packages/beacon-node/src/chain/validation/voluntaryExit.ts

@@ -1,68 +1,264 @@
-import {
-  VoluntaryExitValidity,
-  getVoluntaryExitSignatureSet,
-  getVoluntaryExitValidity,
-} from "@lodestar/state-transition";
+import {getVoluntaryExitSignatureSet, isValidVoluntaryExit} from "@lodestar/state-transition";
 import {phase0} from "@lodestar/types";
-import {
-  GossipAction,
-  VoluntaryExitError,
-  VoluntaryExitErrorCode,
-  voluntaryExitValidityToErrorCode,
-} from "../errors/index.js";
+import {GossipAction, VoluntaryExitError, VoluntaryExitErrorCode} from "../errors/index.js";
 import {IBeaconChain} from "../index.js";
 import {RegenCaller} from "../regen/index.js";
 
+/**
+ * Helper to get human-readable error code name
+ */
+function getVoluntaryExitErrorCodeName(code: VoluntaryExitErrorCode): string {
+  switch (code) {
+    case VoluntaryExitErrorCode.ALREADY_EXISTS:
+      return "ALREADY_EXISTS";
+    case VoluntaryExitErrorCode.INVALID:
+      return "INVALID";
+    case VoluntaryExitErrorCode.INVALID_SIGNATURE:
+      return "INVALID_SIGNATURE";
+    default:
+      return `UNKNOWN_CODE_${code}`;
+  }
+}
+
+/**
+ * Validation result that distinguishes between permanent and transient failures
+ */
+interface ValidationResult {
+  isValid: boolean;
+  error?: {
+    action: GossipAction;
+    code:
+      | VoluntaryExitErrorCode.ALREADY_EXISTS
+      | VoluntaryExitErrorCode.INACTIVE
+      | VoluntaryExitErrorCode.ALREADY_EXITED
+      | VoluntaryExitErrorCode.EARLY_EPOCH
+      | VoluntaryExitErrorCode.SHORT_TIME_ACTIVE
+      | VoluntaryExitErrorCode.PENDING_WITHDRAWALS
+      | VoluntaryExitErrorCode.INVALID_SIGNATURE;
+    isTransient: boolean; // True if the error might resolve over time
+  };
+}
+
+/**
+ * Cached voluntary exit awaiting transient conditions to be met
+ */
+interface CachedVoluntaryExit {
+  exit: phase0.SignedVoluntaryExit;
+  submittedAt: number; // Timestamp
+  lastCheckedEpoch: number;
+  failureReason: string;
+}
+
+/**
+ * Pool for managing pending voluntary exits that failed transient checks
+ */
+class PendingVoluntaryExitPool {
+  private pending = new Map<number, CachedVoluntaryExit>(); // validatorIndex -> exit
+  private readonly MAX_CACHE_TIME_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+  add(validatorIndex: number, exit: phase0.SignedVoluntaryExit, reason: string, epoch: number): void {
+    this.pending.set(validatorIndex, {
+      exit,
+      submittedAt: Date.now(),
+      lastCheckedEpoch: epoch,
+      failureReason: reason,
+    });
+  }
+
+  get(validatorIndex: number): CachedVoluntaryExit | undefined {
+    return this.pending.get(validatorIndex);
+  }
+
+  delete(validatorIndex: number): void {
+    this.pending.delete(validatorIndex);
+  }
+
+  /**
+   * Clean up stale cached exits
+   */
+  prune(): void {
+    const now = Date.now();
+    for (const [validatorIndex, cached] of this.pending.entries()) {
+      if (now - cached.submittedAt > this.MAX_CACHE_TIME_MS) {
+        this.pending.delete(validatorIndex);
+      }
+    }
+  }
+
+  getAllPending(): Map<number, CachedVoluntaryExit> {
+    return new Map(this.pending);
+  }
+
+  size(): number {
+    return this.pending.size;
+  }
+}
+
+/**
+ * Validates a voluntary exit with detailed error classification
+ */
+async function validateVoluntaryExitDetailed(
+  chain: IBeaconChain,
+  voluntaryExit: phase0.SignedVoluntaryExit,
+  prioritizeBls = false
+): Promise<ValidationResult> {
+  const validatorIndex = voluntaryExit.message.validatorIndex;
+
+  // Check if already seen (this is always permanent)
+  if (chain.opPool.hasSeenVoluntaryExit(validatorIndex)) {
+    return {
+      isValid: false,
+      error: {
+        action: GossipAction.IGNORE,
+        code: VoluntaryExitErrorCode.ALREADY_EXISTS,
+        isTransient: false,
+      },
+    };
+  }
+
+  const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipVoluntaryExit);
+
+  // First verify signature (permanent failure if invalid)
+  const signatureSet = getVoluntaryExitSignatureSet(state, voluntaryExit);
+  if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
+    return {
+      isValid: false,
+      error: {
+        action: GossipAction.REJECT,
+        code: VoluntaryExitErrorCode.INVALID_SIGNATURE,
+        isTransient: false,
+      },
+    };
+  }
+
+  if (!isValidVoluntaryExit(chain.config.getForkSeq(state.slot), state, voluntaryExit, false)) {
+    // Determine if the failure is transient and map to a specific VoluntaryExitErrorCode
+    const validator = state.validators.get(validatorIndex);
+    const isTransient =
+      validator !== undefined &&
+      // Validator not yet active (could become active)
+      (!validator.activationEpoch ||
+        // Validator has initiated exit but epoch hasn't passed (time-based)
+        validator.exitEpoch !== Infinity ||
+        false);
+
+    // Map general INVALID reason to a more specific code expected by VoluntaryExitError
+    let code: VoluntaryExitErrorCode;
+    if (validator === undefined || !validator.activationEpoch) {
+      code = VoluntaryExitErrorCode.INACTIVE;
+    } else if (validator.exitEpoch !== Infinity) {
+      code = VoluntaryExitErrorCode.ALREADY_EXITED;
+    } else {
+      // Fallback to EARLY_EPOCH for time-based invalid reasons
+      code = VoluntaryExitErrorCode.EARLY_EPOCH;
+    }
+
+    return {
+      isValid: false,
+      error: {
+        action: GossipAction.REJECT,
+        code,
+        isTransient,
+      },
+    };
+  }
+
+  return {isValid: true};
+}
+
+/**
+ * API validation that accepts and caches transient failures
+ */
 export async function validateApiVoluntaryExit(
   chain: IBeaconChain,
-  voluntaryExit: phase0.SignedVoluntaryExit
-): Promise<void> {
+  voluntaryExit: phase0.SignedVoluntaryExit,
+  pendingPool?: PendingVoluntaryExitPool
+): Promise<{shouldPublish: boolean; isCached: boolean}> {
   const prioritizeBls = true;
-  return validateVoluntaryExit(chain, voluntaryExit, prioritizeBls);
+  const result = await validateVoluntaryExitDetailed(chain, voluntaryExit, prioritizeBls);
+
+  if (result.isValid) {
+    return {shouldPublish: true, isCached: false};
+  }
+
+  // If we have a transient error and a pending pool, cache it
+  if (result.error?.isTransient && pendingPool) {
+    const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipVoluntaryExit);
+    const errorCodeName = getVoluntaryExitErrorCodeName(result.error.code);
+    pendingPool.add(
+      voluntaryExit.message.validatorIndex,
+      voluntaryExit,
+      `Transient failure: ${errorCodeName}`,
+      state.epochCtx.epoch
+    );
+    return {shouldPublish: false, isCached: true};
+  }
+  //biome-ignore lint/style/noNonNullAssertion: error is guaranteed to exist when isValid is false
+  throw new VoluntaryExitError(result.error!.action, {
+    //biome-ignore lint/style/noNonNullAssertion: error is guaranteed to exist when isValid is false
+    code: result.error!.code,
+  });
 }
 
+/**
+ * Gossip validation (strict, no caching)
+ */
 export async function validateGossipVoluntaryExit(
   chain: IBeaconChain,
   voluntaryExit: phase0.SignedVoluntaryExit
 ): Promise<void> {
-  return validateVoluntaryExit(chain, voluntaryExit);
-}
+  const result = await validateVoluntaryExitDetailed(chain, voluntaryExit);
 
-async function validateVoluntaryExit(
-  chain: IBeaconChain,
-  voluntaryExit: phase0.SignedVoluntaryExit,
-  prioritizeBls = false
-): Promise<void> {
-  // [IGNORE] The voluntary exit is the first valid voluntary exit received for the validator with index
-  // signed_voluntary_exit.message.validator_index.
-  if (chain.opPool.hasSeenVoluntaryExit(voluntaryExit.message.validatorIndex)) {
-    throw new VoluntaryExitError(GossipAction.IGNORE, {
-      code: VoluntaryExitErrorCode.ALREADY_EXISTS,
+  if (!result.isValid) {
+    //biome-ignore lint/style/noNonNullAssertion: error is guaranteed to exist when isValid is false
+    throw new VoluntaryExitError(result.error!.action, {
+      //biome-ignore lint/style/noNonNullAssertion: error is guaranteed to exist when isValid is false
+      code: result.error!.code,
     });
   }
+}
 
-  // What state should the voluntaryExit validate against?
-  //
-  // The only condition that is time sensitive and may require a non-head state is
-  // -> Validator is active && validator has not initiated exit
-  // The voluntaryExit.epoch must be in the past but the validator's status may change in recent epochs.
-  // We dial the head state to the current epoch to get the current status of the validator. This is
-  // relevant on periods of many skipped slots.
+/**
+ * Process pending voluntary exits at each epoch
+ * Should be called by the beacon chain on epoch transitions
+ */
+export async function processPendingVoluntaryExits(
+  chain: IBeaconChain,
+  pendingPool: PendingVoluntaryExitPool,
+  network: {publishVoluntaryExit(exit: phase0.SignedVoluntaryExit): Promise<void>}
+): Promise<void> {
   const state = await chain.getHeadStateAtCurrentEpoch(RegenCaller.validateGossipVoluntaryExit);
+  const currentEpoch = state.epochCtx.epoch;
 
-  // [REJECT] All of the conditions within process_voluntary_exit pass validation.
-  // verifySignature = false, verified in batch below
-  const validity = getVoluntaryExitValidity(chain.config.getForkSeq(state.slot), state, voluntaryExit, false);
-  if (validity !== VoluntaryExitValidity.valid) {
-    throw new VoluntaryExitError(GossipAction.REJECT, {
-      code: voluntaryExitValidityToErrorCode(validity),
-    });
+  const toRemove: number[] = [];
+
+  for (const [validatorIndex, cached] of pendingPool.getAllPending()) {
+    if (cached.lastCheckedEpoch === currentEpoch) {
+      continue;
+    }
+
+    try {
+      const result = await validateVoluntaryExitDetailed(chain, cached.exit);
+
+      if (result.isValid) {
+        chain.opPool.insertVoluntaryExit(cached.exit);
+        await network.publishVoluntaryExit(cached.exit);
+        toRemove.push(validatorIndex);
+      } else if (!result.error?.isTransient) {
+        toRemove.push(validatorIndex);
+      }
+    } catch {
+      toRemove.push(validatorIndex);
+    }
   }
 
-  const signatureSet = getVoluntaryExitSignatureSet(state, voluntaryExit);
-  if (!(await chain.bls.verifySignatureSets([signatureSet], {batchable: true, priority: prioritizeBls}))) {
-    throw new VoluntaryExitError(GossipAction.REJECT, {
-      code: VoluntaryExitErrorCode.INVALID_SIGNATURE,
-    });
+  // Remove processed exits
+  for (const validatorIndex of toRemove) {
+    pendingPool.delete(validatorIndex);
   }
+
+  // Clean up old entries
+  pendingPool.prune();
 }
+
+export {PendingVoluntaryExitPool};

packages/beacon-node/test/unit/util/kzg.test.ts

@@ -1,4 +1,4 @@
-import {afterEach, describe, expect, it} from "vitest";
+import {afterEach, describe, expect, it, vi} from "vitest";
 import {createBeaconConfig, createChainForkConfig} from "@lodestar/config";
 import {NUMBER_OF_COLUMNS} from "@lodestar/params";
 import {signedBlockToSignedHeader} from "@lodestar/state-transition";
@@ -13,6 +13,9 @@ import {getBlobCellAndProofs} from "../../utils/getBlobCellAndProofs.js";
 import {generateRandomBlob, transactionForKzgCommitment} from "../../utils/kzg.js";
 
 describe("KZG", () => {
+  // Increase timeout for computationally expensive KZG operations
+  vi.setConfig({testTimeout: 60_000, hookTimeout: 60_000});
+
   const afterEachCallbacks: (() => Promise<unknown> | void)[] = [];
   afterEach(async () => {
     while (afterEachCallbacks.length > 0) {