@lodestar/beacon-node 1.43.0-dev.a6d8600051 → 1.43.0-dev.ac258a8def

package/src/network/reqresp/types.ts

@@ -42,6 +42,7 @@ export enum ReqRespMethod {
   Metadata = "metadata",
   BeaconBlocksByRange = "beacon_blocks_by_range",
   BeaconBlocksByRoot = "beacon_blocks_by_root",
+  BeaconBlocksByHead = "beacon_blocks_by_head",
   BlobSidecarsByRange = "blob_sidecars_by_range",
   BlobSidecarsByRoot = "blob_sidecars_by_root",
   DataColumnSidecarsByRange = "data_column_sidecars_by_range",
@@ -62,6 +63,7 @@ export type RequestBodyByMethod = {
   [ReqRespMethod.Metadata]: null;
   [ReqRespMethod.BeaconBlocksByRange]: phase0.BeaconBlocksByRangeRequest;
   [ReqRespMethod.BeaconBlocksByRoot]: BeaconBlocksByRootRequest;
+  [ReqRespMethod.BeaconBlocksByHead]: fulu.BeaconBlocksByHeadRequest;
   [ReqRespMethod.BlobSidecarsByRange]: deneb.BlobSidecarsByRangeRequest;
   [ReqRespMethod.BlobSidecarsByRoot]: BlobSidecarsByRootRequest;
   [ReqRespMethod.DataColumnSidecarsByRange]: fulu.DataColumnSidecarsByRangeRequest;
@@ -82,6 +84,7 @@ type ResponseBodyByMethod = {
   // Do not matter
   [ReqRespMethod.BeaconBlocksByRange]: SignedBeaconBlock;
   [ReqRespMethod.BeaconBlocksByRoot]: SignedBeaconBlock;
+  [ReqRespMethod.BeaconBlocksByHead]: SignedBeaconBlock;
   [ReqRespMethod.BlobSidecarsByRange]: deneb.BlobSidecar;
   [ReqRespMethod.BlobSidecarsByRoot]: deneb.BlobSidecar;
   [ReqRespMethod.DataColumnSidecarsByRange]: DataColumnSidecar;
@@ -111,6 +114,7 @@ export const requestSszTypeByMethod: (
 
   [ReqRespMethod.BeaconBlocksByRange]: ssz.phase0.BeaconBlocksByRangeRequest,
   [ReqRespMethod.BeaconBlocksByRoot]: BeaconBlocksByRootRequestType(fork, config),
+  [ReqRespMethod.BeaconBlocksByHead]: ssz.fulu.BeaconBlocksByHeadRequest,
   [ReqRespMethod.BlobSidecarsByRange]: ssz.deneb.BlobSidecarsByRangeRequest,
   [ReqRespMethod.BlobSidecarsByRoot]: BlobSidecarsByRootRequestType(fork, config),
   [ReqRespMethod.DataColumnSidecarsByRange]: ssz.fulu.DataColumnSidecarsByRangeRequest,
@@ -142,6 +146,7 @@ export const responseSszTypeByMethod: {[K in ReqRespMethod]: ResponseTypeGetter<
     version === Version.V1 ? ssz.phase0.Metadata : version === Version.V2 ? ssz.altair.Metadata : ssz.fulu.Metadata,
   [ReqRespMethod.BeaconBlocksByRange]: blocksResponseType,
   [ReqRespMethod.BeaconBlocksByRoot]: blocksResponseType,
+  [ReqRespMethod.BeaconBlocksByHead]: (fork) => ssz[fork].SignedBeaconBlock,
   [ReqRespMethod.BlobSidecarsByRange]: () => ssz.deneb.BlobSidecar,
   [ReqRespMethod.BlobSidecarsByRoot]: () => ssz.deneb.BlobSidecar,
   [ReqRespMethod.LightClientBootstrap]: (fork) => sszTypesFor(onlyPostAltairFork(fork)).LightClientBootstrap,

package/src/node/nodejs.ts

@@ -221,7 +221,7 @@ export class BeaconNode {
 
     let executionEngineOpts = opts.executionEngine;
     if (opts.executionEngine.mode === "mock") {
-      const eth1BlockHash =
+      const latestEth1BlockHash =
         isStatePostBellatrix(anchorState) && anchorState.isExecutionStateType
           ? isStatePostGloas(anchorState)
             ? toRootHex(anchorState.latestBlockHash)
@@ -230,7 +230,7 @@ export class BeaconNode {
       executionEngineOpts = {
         ...opts.executionEngine,
         genesisBlockHash: ZERO_HASH_HEX,
-        eth1BlockHash,
+        eth1BlockHash: opts.executionEngine.eth1BlockHash ?? latestEth1BlockHash,
         genesisTime: anchorState.genesisTime,
         config,
       };

package/src/node/notifier.ts

@@ -167,14 +167,7 @@ function getHeadExecutionInfo(
     return [];
   }
 
-  // A PayloadSeparated head is a gloas beacon block imported before its payload envelope
-  // arrives, in that case the exec-block row surfaces the inherited parent anchor (from the
-  // bid), which is already validated. Normalize to "valid" to avoid leaking internal
-  // fork-choice bookkeeping into the log. Once the payload envelope arrives and the FULL
-  // variant becomes head, executionStatus is Valid/Syncing naturally.
-  // TODO GLOAS: revisit once optimistic sync is implemented
-  const executionStatusStr =
-    headInfo.executionStatus === ExecutionStatus.PayloadSeparated ? "valid" : headInfo.executionStatus.toLowerCase();
+  const executionStatusStr = headInfo.executionStatus.toLowerCase();
 
   // Add execution status to notifier only if head is on/post bellatrix
   if (isStatePostBellatrix(headState) && headState.isExecutionStateType) {

package/src/sync/constants.ts

@@ -5,10 +5,14 @@ export const PARALLEL_HEAD_CHAINS = 2;
 export const MIN_FINALIZED_CHAIN_VALIDATED_EPOCHS = 10;
 
 /** The number of times to retry a batch before it is considered failed. */
-// export const MAX_BATCH_DOWNLOAD_ATTEMPTS = 5;
-// this constant is increased a lot for peerDAS because we may have many failed download due to rate limit not implemented yet
-// TODO: change it back to 5 when this issue is implemented https://github.com/ChainSafe/lodestar/issues/8033
-export const MAX_BATCH_DOWNLOAD_ATTEMPTS = 20;
+export const MAX_BATCH_DOWNLOAD_ATTEMPTS = 5;
+
+/**
+ * Backoff before assigning more range-sync batches to a peer that rate-limited us.
+ *
+ * Note: this is used when rate limited due to MAX_CONCURRENT_REQUESTS
+ */
+export const RATE_LIMITED_PEER_BACKOFF_MS = 5_000;
 
 /**
  * Consider batch faulty after downloading and processing this number of times

package/src/sync/range/batch.ts

@@ -1,18 +1,19 @@
 import {ChainForkConfig} from "@lodestar/config";
 import {ForkName, isForkPostDeneb, isForkPostFulu, isForkPostGloas} from "@lodestar/params";
-import {Epoch, RootHex, Slot, phase0} from "@lodestar/types";
-import {LodestarError} from "@lodestar/utils";
+import {Epoch, RootHex, SignedBeaconBlock, Slot, gloas, phase0} from "@lodestar/types";
+import {LodestarError, byteArrayEquals, prettyPrintIndices, toRootHex} from "@lodestar/utils";
 import {isBlockInputColumns} from "../../chain/blocks/blockInput/blockInput.js";
 import {IBlockInput} from "../../chain/blocks/blockInput/types.js";
 import {isDaOutOfRange} from "../../chain/blocks/blockInput/utils.js";
 import {PayloadEnvelopeInput} from "../../chain/blocks/payloadEnvelopeInput/payloadEnvelopeInput.js";
 import {BlockError, BlockErrorCode} from "../../chain/errors/index.js";
+import {ZERO_HASH} from "../../constants/constants.js";
 import {PeerSyncMeta} from "../../network/peers/peersData.js";
 import {IClock} from "../../util/clock.js";
 import {CustodyConfig} from "../../util/dataColumns.js";
 import {PeerIdStr} from "../../util/peerId.js";
 import {MAX_BATCH_DOWNLOAD_ATTEMPTS, MAX_BATCH_PROCESSING_ATTEMPTS} from "../constants.js";
-import {DownloadByRangeRequests} from "../utils/downloadByRange.js";
+import {DownloadByRangeRequests, ParentPayloadCommitments} from "../utils/downloadByRange.js";
 import {getBatchSlotRange, hashBlocks} from "./utils/index.js";
 
 /**
@@ -79,10 +80,36 @@ export type BatchState =
     };
 
 export type BatchMetadata = {
+  // Batch-level slot window (always present)
   startEpoch: Epoch;
+  startSlot: Slot;
+  count: number;
   status: BatchStatus;
+
+  // Per-type outstanding request shapes; only present when that sub-request exists.
+  // Format: "startSlot=<n>,count=<n>" (plus ",cols=<indices>" for columns).
+  blocksReq?: string;
+  blobsReq?: string;
+  columnsReq?: string;
+  envelopesReq?: string;
+
+  // Retry counters
+  downloadAttempts: number;
+  processingAttempts: number;
+
+  // Cumulative peer attribution for failed attempts (only present when non-empty)
+  failedDownloadPeers?: string;
+  failedProcessingPeers?: string;
 };
 
+function formatRangeReq(req: {startSlot: Slot; count: number}): string {
+  return `startSlot=${req.startSlot},count=${req.count}`;
+}
+
+function formatColumnsReq(req: {startSlot: Slot; count: number; columns: number[]}): string {
+  return `startSlot=${req.startSlot},count=${req.count},cols=${prettyPrintIndices(req.columns)}`;
+}
+
 /**
  * Batches are downloaded at the first block of the epoch.
  *
@@ -115,8 +142,18 @@ export class Batch {
   private readonly config: ChainForkConfig;
   private readonly clock: IClock;
   private readonly custodyConfig: CustodyConfig;
-
-  constructor(startEpoch: Epoch, config: ChainForkConfig, clock: IClock, custodyConfig: CustodyConfig) {
+  private readonly isFirstBatchInChain: boolean;
+  private readonly latestBid: gloas.ExecutionPayloadBid | undefined;
+
+  constructor(
+    startEpoch: Epoch,
+    config: ChainForkConfig,
+    clock: IClock,
+    custodyConfig: CustodyConfig,
+    isFirstBatchInChain: boolean,
+    latestBid: gloas.ExecutionPayloadBid | undefined,
+    targetSlot: Slot
+  ) {
     this.config = config;
     this.clock = clock;
     this.custodyConfig = custodyConfig;
@@ -125,10 +162,40 @@ export class Batch {
     this.forkName = this.config.getForkName(startSlot);
     this.startEpoch = startEpoch;
     this.startSlot = startSlot;
-    this.count = count;
+    this.count = Math.min(count, targetSlot - startSlot + 1);
+    this.isFirstBatchInChain = isFirstBatchInChain;
+    this.latestBid = latestBid;
     this.requests = this.getRequests([]);
   }
 
+  private shouldDownloadParentEnvelope(firstBlock?: SignedBeaconBlock): boolean {
+    if (!this.isFirstBatchInChain) return false;
+
+    if (this.startSlot === 0 || !isForkPostGloas(this.config.getForkName(this.startSlot - 1))) {
+      return false;
+    }
+
+    // we only know if we should download parent envelope if firstBlock is downloaded
+    if (firstBlock === undefined) return false;
+    if (this.latestBid === undefined) return false;
+    const firstBlockBidParentHash = (firstBlock.message.body as gloas.BeaconBlockBody).signedExecutionPayloadBid.message
+      .parentBlockHash;
+    return byteArrayEquals(firstBlockBidParentHash, this.latestBid.blockHash);
+  }
+
+  getParentPayloadCommitments(parentBlockRoot: Uint8Array): ParentPayloadCommitments {
+    if (this.latestBid === undefined) {
+      throw new Error(
+        `Coding error: getParentPayloadCommitments called without latestBid for parentBlockRoot=${toRootHex(parentBlockRoot)}`
+      );
+    }
+    return {
+      blockRoot: parentBlockRoot,
+      blockRootHex: toRootHex(parentBlockRoot),
+      kzgCommitments: this.latestBid.blobKzgCommitments,
+    };
+  }
+
   /**
    * Builds ByRange requests for block, blobs and columns
    */
@@ -176,6 +243,7 @@ export class Batch {
     const envelopesBySlot = this.state.payloadEnvelopes ?? new Map<Slot, PayloadEnvelopeInput>();
 
     // ensure blocks are in slot-wise order
+    const isPostGloas = isForkPostGloas(this.forkName);
     for (const blockInput of blocks) {
       const blockSlot = blockInput.slot;
       // check if block/data is present (hasBlock/hasAllData). If present then check if startSlot is the same as
@@ -191,21 +259,36 @@ export class Batch {
       if (blockInput.hasBlock() && blockStartSlot === blockSlot) {
         blockStartSlot = blockSlot + 1;
       }
-      if (
-        blockInput.hasBlock() &&
-        envelopeStartSlot === blockSlot &&
-        envelopesBySlot.get(blockSlot)?.hasPayloadEnvelope()
-      ) {
-        envelopeStartSlot = blockSlot + 1;
-      }
-      if (!blockInput.hasAllData()) {
-        if (isBlockInputColumns(blockInput)) {
-          for (const index of blockInput.getMissingSampledColumnMeta().missing) {
+
+      // Range sync uses hasComputedAllData (all sampled columns physically present), not hasAllData
+      // which flips at the reconstruction threshold. Sync never triggers reconstruction, so accepting
+      // a half-downloaded block here makes writeBlockInputToDb later block on waitForComputedAllData.
+      if (isPostGloas) {
+        // Post-Gloas: column data lives on PayloadEnvelopeInput, not on BlockInputNoData.
+        const payloadInput = envelopesBySlot.get(blockSlot);
+        if (blockInput.hasBlock() && envelopeStartSlot === blockSlot && payloadInput?.hasPayloadEnvelope()) {
+          envelopeStartSlot = blockSlot + 1;
+        }
+        if (payloadInput && !payloadInput.hasComputedAllData()) {
+          for (const index of payloadInput.getMissingSampledColumnMeta().missing) {
             neededColumns.add(index);
           }
+        } else if (payloadInput?.hasComputedAllData() && dataStartSlot === blockSlot) {
+          // Only advance dataStartSlot when we know columns for this slot are complete. If
+          // payloadInput is missing entirely we cannot tell, so stop here so the next round
+          // re-requests columns (and envelopes) starting at this slot.
+          dataStartSlot = blockSlot + 1;
+        }
+      } else {
+        if (isBlockInputColumns(blockInput) ? !blockInput.hasComputedAllData() : !blockInput.hasAllData()) {
+          if (isBlockInputColumns(blockInput)) {
+            for (const index of blockInput.getMissingSampledColumnMeta().missing) {
+              neededColumns.add(index);
+            }
+          }
+        } else if (dataStartSlot === blockSlot) {
+          dataStartSlot = blockSlot + 1;
         }
-      } else if (dataStartSlot === blockSlot) {
-        dataStartSlot = blockSlot + 1;
       }
     }
 
@@ -225,11 +308,15 @@ export class Batch {
       // range of 40 - 63, startSlot will be inclusive but subtraction will exclusive so need to + 1
       const count = endSlot - dataStartSlot + 1;
       if (isForkPostFulu(this.forkName) && withinValidRequestWindow) {
-        requests.columnsRequest = {
-          count,
-          startSlot: dataStartSlot,
-          columns: Array.from(neededColumns),
-        };
+        // Skip the column re-request when we have no specific column indices outstanding.
+        // Peer rejects an empty `columns` list
+        if (neededColumns.size > 0) {
+          requests.columnsRequest = {
+            count,
+            startSlot: dataStartSlot,
+            columns: Array.from(neededColumns),
+          };
+        }
       } else if (isForkPostDeneb(this.forkName) && withinValidRequestWindow) {
         requests.blobsRequest = {
           count,
@@ -246,6 +333,36 @@ export class Batch {
       };
     }
 
+    // Only the first batch of a SyncChain may need the dangling-parent payload by-root.
+    if (blocks.length > 0 && this.shouldDownloadParentEnvelope(blocks[0].getBlock())) {
+      // shouldDownloadParentEnvelope() = true means there are at least 1 block
+      const parentRoot = blocks[0].getBlock().message.parentRoot;
+      if (!byteArrayEquals(parentRoot, ZERO_HASH)) {
+        const parentRootHex = toRootHex(parentRoot);
+        let parentPayloadInput: PayloadEnvelopeInput | undefined;
+        if (this.state.payloadEnvelopes) {
+          for (const pi of this.state.payloadEnvelopes.values()) {
+            if (pi.blockRootHex === parentRootHex) {
+              parentPayloadInput = pi;
+              break;
+            }
+          }
+        }
+
+        const needsEnvelope = !parentPayloadInput?.hasPayloadEnvelope();
+        const missingColumns = parentPayloadInput
+          ? parentPayloadInput.getMissingSampledColumnMeta().missing
+          : this.custodyConfig.sampledColumns;
+
+        if (needsEnvelope || missingColumns.length > 0) {
+          requests.parentPayloadRequest = {
+            ...(needsEnvelope ? {envelopeBlockRoot: parentRoot} : {}),
+            ...(missingColumns.length > 0 ? {blockRoot: parentRoot, columns: missingColumns} : {}),
+          };
+        }
+      }
+    }
+
     return requests;
   }
 
@@ -257,24 +374,28 @@ export class Batch {
       return this.requests;
     }
 
-    // post-fulu we need to ensure that we only request columns that the peer has advertised
-    const {columnsRequest} = this.requests;
-    if (columnsRequest == null) {
-      return this.requests;
-    }
+    // post-fulu we need to ensure that we only request columns that the peer has advertised.
+    const {columnsRequest, parentPayloadRequest} = this.requests;
 
     const peerColumns = new Set(peer.custodyColumns ?? []);
-    const requestedColumns = columnsRequest.columns.filter((c) => peerColumns.has(c));
-    if (requestedColumns.length === columnsRequest.columns.length) {
-      return this.requests;
-    }
+    const filteredColumnsRequest =
+      columnsRequest != null ? columnsRequest.columns.filter((c) => peerColumns.has(c)) : null;
+    const parentColumns = parentPayloadRequest?.columns;
+    const filteredParentColumns = parentColumns != null ? parentColumns.filter((c) => peerColumns.has(c)) : null;
+
+    const updatedColumnRequest =
+      columnsRequest != null && filteredColumnsRequest != null
+        ? {columnsRequest: {...columnsRequest, columns: filteredColumnsRequest}}
+        : {};
+    const updatedParentPayloadRequest =
+      parentPayloadRequest != null && filteredParentColumns != null
+        ? {parentPayloadRequest: {...parentPayloadRequest, columns: filteredParentColumns}}
+        : {};
 
     return {
       ...this.requests,
-      columnsRequest: {
-        ...columnsRequest,
-        columns: requestedColumns,
-      },
+      ...updatedColumnRequest,
+      ...updatedParentPayloadRequest,
     };
   }
 
@@ -286,7 +407,26 @@ export class Batch {
   }
 
   getMetadata(): BatchMetadata {
-    return {startEpoch: this.startEpoch, status: this.state.status};
+    const {blocksRequest, blobsRequest, columnsRequest, envelopesRequest} = this.requests;
+    const failedProcessingPeerList = this.failedProcessingAttempts.flatMap((a) => a.peers);
+    return {
+      startEpoch: this.startEpoch,
+      startSlot: this.startSlot,
+      count: this.count,
+      status: this.state.status,
+      ...(blocksRequest && {blocksReq: formatRangeReq(blocksRequest)}),
+      ...(blobsRequest && {blobsReq: formatRangeReq(blobsRequest)}),
+      ...(columnsRequest && {columnsReq: formatColumnsReq(columnsRequest)}),
+      ...(envelopesRequest && {envelopesReq: formatRangeReq(envelopesRequest)}),
+      downloadAttempts: this.failedDownloadAttempts.length,
+      processingAttempts: this.failedProcessingAttempts.length,
+      ...(this.failedDownloadAttempts.length > 0 && {
+        failedDownloadPeers: this.failedDownloadAttempts.join(","),
+      }),
+      ...(failedProcessingPeerList.length > 0 && {
+        failedProcessingPeers: failedProcessingPeerList.join(","),
+      }),
+    };
   }
 
   getBlocks(): IBlockInput[] {
@@ -334,7 +474,11 @@ export class Batch {
     const slots = new Set<number>();
     for (const block of blocks) {
       slots.add(block.slot);
-      if (!block.hasBlockAndAllData()) {
+      const dataComplete = isBlockInputColumns(block)
+        ? // by_range needs to download all columns
+          block.hasBlock() && block.hasComputedAllData()
+        : block.hasBlockAndAllData();
+      if (!dataComplete) {
         allComplete = false;
       }
     }
@@ -350,11 +494,45 @@ export class Batch {
     }
     const newPayloadEnvelopes = payloadEnvelopes ?? this.state.payloadEnvelopes;
 
+    if (allComplete && isForkPostGloas(this.forkName)) {
+      for (const block of blocks) {
+        const payloadInput = newPayloadEnvelopes?.get(block.slot);
+        // by_range needs every block's envelope and all sampled columns.
+        if (!payloadInput?.hasPayloadEnvelope() || !payloadInput.hasComputedAllData()) {
+          allComplete = false;
+          break;
+        }
+      }
+    }
+
+    // First batch of a sync chain must additionally have the dangling-parent payload fully
+    // present, otherwise `processBlocks` will throw PARENT_PAYLOAD_UNKNOWN. The parent's
+    // `PayloadEnvelopeInput` is identified by `blockRootHex` matching `blocks[0].parentRoot`.
+    if (allComplete && blocks.length > 0 && this.shouldDownloadParentEnvelope(blocks[0].getBlock())) {
+      const parentRoot = blocks[0].getBlock().message.parentRoot;
+      // Genesis has no parent payload — nothing to wait for.
+      if (!byteArrayEquals(parentRoot, ZERO_HASH)) {
+        const parentRootHex = toRootHex(parentRoot);
+        let parentPayloadComplete = false;
+        if (newPayloadEnvelopes) {
+          for (const payloadInput of newPayloadEnvelopes.values()) {
+            if (payloadInput.blockRootHex === parentRootHex) {
+              parentPayloadComplete = payloadInput.hasPayloadEnvelope() && payloadInput.hasComputedAllData();
+              break;
+            }
+          }
+        }
+        if (!parentPayloadComplete) {
+          allComplete = false;
+        }
+      }
+    }
+
     if (allComplete) {
       this.state = {status: BatchStatus.AwaitingProcessing, blocks, payloadEnvelopes: newPayloadEnvelopes};
     } else {
-      this.requests = this.getRequests(blocks);
       this.state = {status: BatchStatus.AwaitingDownload, blocks, payloadEnvelopes: newPayloadEnvelopes};
+      this.requests = this.getRequests(blocks);
     }
 
     return this.state as DownloadSuccessState;
@@ -380,10 +558,30 @@ export class Batch {
     };
   }
 
+  /**
+   * Downloading -> AwaitingDownload (without counting as a failed attempt).
+   * Used when the peer rate-limited us — the request was never actually served.
+   */
+  downloadingRateLimited(): void {
+    if (this.state.status !== BatchStatus.Downloading) {
+      throw new BatchError(this.wrongStatusErrorType(BatchStatus.Downloading));
+    }
+
+    this.state = {
+      status: BatchStatus.AwaitingDownload,
+      blocks: this.state.blocks,
+      payloadEnvelopes: this.state.payloadEnvelopes,
+    };
+  }
+
   /**
    * AwaitingProcessing -> Processing
    */
-  startProcessing(): {blocks: IBlockInput[]; payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null} {
+  startProcessing(): {
+    blocks: IBlockInput[];
+    payloadEnvelopes: Map<Slot, PayloadEnvelopeInput> | null;
+    peers: PeerIdStr[];
+  } {
     if (this.state.status !== BatchStatus.AwaitingProcessing) {
       throw new BatchError(this.wrongStatusErrorType(BatchStatus.AwaitingProcessing));
     }
@@ -396,7 +594,7 @@ export class Batch {
     const peers = this.goodPeers;
     this.goodPeers = [];
     this.state = {status: BatchStatus.Processing, blocks, payloadEnvelopes, attempt: {peers, hash}};
-    return {blocks, payloadEnvelopes};
+    return {blocks, payloadEnvelopes, peers};
   }
 
   /**
@@ -479,7 +677,7 @@ export class Batch {
 
   /** Helper to construct typed BatchError. Stack traces are correct as the error is thrown above */
   private errorType(type: BatchErrorType): BatchErrorType & BatchErrorMetadata {
-    return {...type, ...this.getMetadata()};
+    return {...type, startEpoch: this.startEpoch, status: this.state.status};
   }
 
   private wrongStatusErrorType(expectedStatus: BatchStatus): BatchErrorType & BatchErrorMetadata {