@lodestar/beacon-node 1.49.0-dev.ee7c2aa8ee → 1.49.0-dev.f1b14bce8f

package/src/util/execution.ts

@@ -2,12 +2,18 @@ import {routes} from "@lodestar/api";
 import {ChainForkConfig} from "@lodestar/config";
 import {ForkPostFulu, ForkPreFulu} from "@lodestar/params";
 import {signedBlockToSignedHeader} from "@lodestar/state-transition";
-import {DataColumnSidecar, SignedBeaconBlock, deneb, isGloasDataColumnSidecar} from "@lodestar/types";
-import {fromHex, toHex} from "@lodestar/utils";
+import {DataColumnSidecar, SignedBeaconBlock, Slot, deneb, gloas, isGloasDataColumnSidecar, ssz} from "@lodestar/types";
+import {Logger, fromHex, toHex, toRootHex} from "@lodestar/utils";
 import {isBlockInputBlobs, isBlockInputColumns} from "../chain/blocks/blockInput/blockInput.js";
 import {BlockInputSource, IBlockInput} from "../chain/blocks/blockInput/types.js";
 import {PayloadEnvelopeInput, PayloadEnvelopeInputSource} from "../chain/blocks/payloadEnvelopeInput/index.js";
 import {ChainEvent, ChainEventEmitter} from "../chain/emitter.js";
+import {
+  EnvelopeReconstructionError,
+  EnvelopeReconstructionErrorCode,
+} from "../chain/errors/envelopeReconstructionError.js";
+import {IBeaconDb} from "../db/index.js";
+import {ArchivedEnvelope, decodeArchivedEnvelope} from "../db/repositories/index.js";
 import {IExecutionEngine} from "../execution/index.js";
 import {Metrics} from "../metrics/index.js";
 import {computePreFuluKzgCommitmentsInclusionProof} from "./blobs.js";
@@ -17,6 +23,7 @@ import {
   getDataColumnSidecarsFromColumnSidecar,
   getGloasDataColumnSidecars,
 } from "./dataColumns.js";
+import {signedHeaderEnvelopeToFull} from "./headerEnvelope.js";
 
 export enum DataColumnEngineResult {
   PreFulu = "pre_fulu",
@@ -251,3 +258,169 @@ export async function getDataColumnSidecarsFromExecution(
   );
   return DataColumnEngineResult.SuccessResolved;
 }
+
+/** engine_getPayloadBodiesByHashV2: ELs MUST support at least 32 hashes per request. */
+const MAX_BODIES_REQUEST = 32;
+
+type SlotEnvelopeBytes = {slot: Slot; envelopeBytes: Uint8Array};
+
+type RangeEntry = ArchivedEnvelope & {slot: Slot};
+
+/** What a body root mismatch means on a given serving path */
+export type ReconstructMismatchPolicy = "throw" | "omit";
+
+export type RebuildMiss =
+  /** EL does not have the block, or has pruned its block access list */
+  | {slot: Slot; reason: "unavailable"}
+  /** An EL body does not hash to its stored root (local inconsistency) */
+  | {slot: Slot; reason: "mismatch"; error: EnvelopeReconstructionError};
+
+/**
+ * Stream finalized envelopes over [startSlot, endSlot) as serialized bytes, rebuilding header
+ * entries from EL bodies 32 per round-trip.
+ *
+ * Ends at the first entry that cannot be served by throwing RANGE_UNSERVABLE with that slot: the
+ * by-range spec inherits BeaconBlocksByRange v2 semantics (consecutive, MAY be short), and a hole
+ * looks like a lying peer to one that already holds the blocks. Entries are attempted regardless of
+ * age; the EL's block access list retention is the floor, not MIN_EPOCHS_FOR_BLOCK_REQUESTS.
+ *
+ * Throws ENGINE_UNAVAILABLE if the EL call fails. Either may surface after envelopes were yielded.
+ */
+export async function* reconstructExecutionPayloadEnvelopesByRange(
+  db: IBeaconDb,
+  executionEngine: IExecutionEngine,
+  logger: Logger,
+  metrics: Metrics | null,
+  startSlot: Slot,
+  endSlot: Slot
+): AsyncIterable<SlotEnvelopeBytes> {
+  const archive = db.executionPayloadEnvelopeArchive;
+  let batch: RangeEntry[] = [];
+
+  for await (const {key, value: bytes} of archive.binaryEntriesStream({gte: startSlot, lt: endSlot})) {
+    batch.push({slot: archive.decodeKey(key), ...decodeArchivedEnvelope(bytes)});
+    if (batch.length === MAX_BODIES_REQUEST) {
+      yield* reconstructBatch(executionEngine, logger, metrics, batch);
+      batch = [];
+    }
+  }
+  if (batch.length > 0) {
+    yield* reconstructBatch(executionEngine, logger, metrics, batch);
+  }
+}
+
+/**
+ * Rebuild a range batch, yielding what precedes the first unservable entry before throwing
+ * RANGE_UNSERVABLE for it
+ */
+async function* reconstructBatch(
+  executionEngine: IExecutionEngine,
+  logger: Logger,
+  metrics: Metrics | null,
+  batch: RangeEntry[]
+): AsyncIterable<SlotEnvelopeBytes> {
+  const headerEnvelopes: gloas.SignedExecutionPayloadHeaderEnvelope[] = [];
+  for (const entry of batch) {
+    if (entry.headerEnvelope !== undefined) headerEnvelopes.push(entry.headerEnvelope);
+  }
+  const rebuilt = await reconstructEnvelopesBatch(executionEngine, metrics, headerEnvelopes);
+
+  let rebuiltIdx = 0;
+  for (const entry of batch) {
+    if (entry.envelopeBytes !== undefined) {
+      yield {slot: entry.slot, envelopeBytes: entry.envelopeBytes};
+      continue;
+    }
+    const result = rebuilt[rebuiltIdx++];
+    if (isRebuildMiss(result)) {
+      // Peer-triggered, so debug: a persistent local mismatch would otherwise log on every request
+      if (result.reason === "mismatch") {
+        logger.debug("Archived envelope failed body root check against EL bodies", {slot: entry.slot}, result.error);
+      } else {
+        logger.debug("EL cannot serve bodies for archived envelope, ending range", {slot: entry.slot});
+      }
+      throw new EnvelopeReconstructionError(
+        {code: EnvelopeReconstructionErrorCode.RANGE_UNSERVABLE, slot: entry.slot},
+        `archived envelope range unservable from slot=${entry.slot}`
+      );
+    }
+    yield {slot: entry.slot, envelopeBytes: ssz.gloas.SignedExecutionPayloadEnvelope.serialize(result)};
+  }
+}
+
+/**
+ * Rebuild header envelopes from EL bodies, 32 per round-trip. Aligned with the input, with a
+ * {@link RebuildMiss} where the envelope could not be rebuilt; the caller decides what a miss means
+ * on its path. Throws ENGINE_UNAVAILABLE only.
+ */
+export async function reconstructExecutionPayloadEnvelopes(
+  executionEngine: IExecutionEngine,
+  metrics: Metrics | null,
+  headerEnvelopes: gloas.SignedExecutionPayloadHeaderEnvelope[]
+): Promise<(gloas.SignedExecutionPayloadEnvelope | RebuildMiss)[]> {
+  const out: (gloas.SignedExecutionPayloadEnvelope | RebuildMiss)[] = [];
+  for (let i = 0; i < headerEnvelopes.length; i += MAX_BODIES_REQUEST) {
+    out.push(
+      ...(await reconstructEnvelopesBatch(executionEngine, metrics, headerEnvelopes.slice(i, i + MAX_BODIES_REQUEST)))
+    );
+  }
+  return out;
+}
+
+export function isRebuildMiss(result: gloas.SignedExecutionPayloadEnvelope | RebuildMiss): result is RebuildMiss {
+  return "reason" in result;
+}
+
+/**
+ * One EL round-trip. Aligned with the input; never throws per envelope, only ENGINE_UNAVAILABLE.
+ * Every serving path (by-range, by-root, REST) comes through here, so the outcome metrics are
+ * incremented once, in this function.
+ */
+async function reconstructEnvelopesBatch(
+  executionEngine: IExecutionEngine,
+  metrics: Metrics | null,
+  headerEnvelopes: gloas.SignedExecutionPayloadHeaderEnvelope[]
+): Promise<(gloas.SignedExecutionPayloadEnvelope | RebuildMiss)[]> {
+  if (headerEnvelopes.length === 0) return [];
+  const hashes = headerEnvelopes.map((headerEnvelope) => toRootHex(headerEnvelope.message.payloadHeader.blockHash));
+
+  let bodies: Awaited<ReturnType<IExecutionEngine["getPayloadBodiesByHashV2"]>>;
+  try {
+    bodies = await executionEngine.getPayloadBodiesByHashV2(hashes);
+  } catch (e) {
+    metrics?.payloadEnvelopeReconstruction.engineErrors.inc();
+    throw new EnvelopeReconstructionError(
+      {code: EnvelopeReconstructionErrorCode.ENGINE_UNAVAILABLE},
+      `engine_getPayloadBodiesByHashV2 failed: ${(e as Error).message}`
+    );
+  }
+
+  return headerEnvelopes.map((headerEnvelope, i) => {
+    const slot = headerEnvelope.message.payloadHeader.slotNumber;
+    const body = bodies[i];
+    // A zero-length block access list cannot be valid, RLP encodes an empty list as 0xc0
+    if (body == null || body.withdrawals == null || body.blockAccessList == null || body.blockAccessList.length === 0) {
+      metrics?.payloadEnvelopeReconstruction.envelopes.inc({result: "unavailable"});
+      return {slot, reason: "unavailable"};
+    }
+    try {
+      const envelope = signedHeaderEnvelopeToFull(headerEnvelope, {
+        transactions: body.transactions,
+        withdrawals: body.withdrawals,
+        blockAccessList: body.blockAccessList,
+      });
+      metrics?.payloadEnvelopeReconstruction.envelopes.inc({result: "ok"});
+      return envelope;
+    } catch (e) {
+      if (
+        e instanceof EnvelopeReconstructionError &&
+        e.type.code === EnvelopeReconstructionErrorCode.BODY_ROOT_MISMATCH
+      ) {
+        metrics?.payloadEnvelopeReconstruction.envelopes.inc({result: "mismatch"});
+        metrics?.payloadEnvelopeReconstruction.mismatchByField.inc({field: e.type.field});
+        return {slot, reason: "mismatch", error: e};
+      }
+      throw e;
+    }
+  });
+}

package/src/util/headerEnvelope.ts

@@ -0,0 +1,76 @@
+import {ssz} from "@lodestar/types";
+import {
+  BlockAccessList,
+  ExecutionPayloadEnvelope,
+  ExecutionPayloadHeaderEnvelope,
+  SignedExecutionPayloadEnvelope,
+  SignedExecutionPayloadHeaderEnvelope,
+  Transactions,
+  Withdrawals,
+} from "@lodestar/types/gloas";
+import {toRootHex} from "@lodestar/utils";
+import {
+  EnvelopeReconstructionError,
+  EnvelopeReconstructionErrorCode,
+} from "../chain/errors/envelopeReconstructionError.js";
+
+/** The parts of an execution payload the EL serves back via engine_getPayloadBodiesByHashV2 */
+export type ExecutionPayloadBodies = {
+  transactions: Transactions;
+  withdrawals: Withdrawals;
+  blockAccessList: BlockAccessList;
+};
+
+export type ExecutionPayloadBodyField = keyof ExecutionPayloadBodies;
+
+const {transactions, withdrawals, blockAccessList} = ssz.gloas.ExecutionPayload.fields;
+
+/** Replace the three body lists by their roots; hashes to the same root as the full envelope */
+export function toHeaderEnvelope(envelope: ExecutionPayloadEnvelope): ExecutionPayloadHeaderEnvelope {
+  const {payload, ...envelopeFields} = envelope;
+  const {transactions: txs, withdrawals: wds, blockAccessList: bal, ...scalars} = payload;
+  return {
+    ...envelopeFields,
+    payloadHeader: {
+      ...scalars,
+      transactionsRoot: transactions.hashTreeRoot(txs),
+      withdrawalsRoot: withdrawals.hashTreeRoot(wds),
+      blockAccessListRoot: blockAccessList.hashTreeRoot(bal),
+    },
+  };
+}
+
+export function toSignedHeaderEnvelope(envelope: SignedExecutionPayloadEnvelope): SignedExecutionPayloadHeaderEnvelope {
+  return {message: toHeaderEnvelope(envelope.message), signature: envelope.signature};
+}
+
+/**
+ * Rebuild the full signed envelope from header envelope + EL bodies, each body verified against its stored
+ * root. Throws {@link EnvelopeReconstructionError} BODY_ROOT_MISMATCH naming the first body that differs.
+ */
+export function signedHeaderEnvelopeToFull(
+  headerEnvelope: SignedExecutionPayloadHeaderEnvelope,
+  bodies: ExecutionPayloadBodies
+): SignedExecutionPayloadEnvelope {
+  const {payloadHeader, ...envelopeFields} = headerEnvelope.message;
+  const {transactionsRoot, withdrawalsRoot, blockAccessListRoot, ...scalars} = payloadHeader;
+  const slot = scalars.slotNumber;
+
+  assertBodyRoot("transactions", slot, transactionsRoot, transactions.hashTreeRoot(bodies.transactions));
+  assertBodyRoot("withdrawals", slot, withdrawalsRoot, withdrawals.hashTreeRoot(bodies.withdrawals));
+  assertBodyRoot("blockAccessList", slot, blockAccessListRoot, blockAccessList.hashTreeRoot(bodies.blockAccessList));
+
+  return {
+    message: {...envelopeFields, payload: {...scalars, ...bodies}},
+    signature: headerEnvelope.signature,
+  };
+}
+
+function assertBodyRoot(field: ExecutionPayloadBodyField, slot: number, stored: Uint8Array, rebuilt: Uint8Array): void {
+  if (!ssz.Root.equals(stored, rebuilt)) {
+    throw new EnvelopeReconstructionError(
+      {code: EnvelopeReconstructionErrorCode.BODY_ROOT_MISMATCH, slot, field},
+      `reconstructed ${field} root mismatch slot=${slot} stored=${toRootHex(stored)} rebuilt=${toRootHex(rebuilt)}`
+    );
+  }
+}

package/src/util/shuffle.ts

@@ -10,12 +10,3 @@ export function shuffle<T>(arr: T[]): T[] {
   }
   return _arr;
 }
-
-/**
- * Return one random item from array
- */
-export function shuffleOne<T>(arr: T[]): T | undefined {
-  if (arr.length === 0) return undefined;
-
-  return arr[Math.floor(Math.random() * arr.length)];
-}

package/lib/chain/archiveStore/utils/updateBackfillRange.d.ts

@@ -1,20 +0,0 @@
-import { CheckpointWithHex } from "@lodestar/fork-choice";
-import { Logger } from "@lodestar/logger";
-import { IBeaconDb } from "../../../db/interface.js";
-import { IBeaconChain } from "../../interface.js";
-/**
- * Backfill sync relies on verified connected ranges (which are represented as key,value
- * with a verified jump from a key back to value). Since the node could have progressed
- * ahead from, we need to save the forward progress of this node as another backfill
- * range entry, that backfill sync will use to jump back if this node is restarted
- * for any reason.
- * The current backfill has its own backfill entry from anchor slot to last backfilled
- * slot. And this would create the entry from the current finalized slot to the anchor
- * slot.
- */
-export declare function updateBackfillRange({ chain, db, logger }: {
-    chain: IBeaconChain;
-    db: IBeaconDb;
-    logger: Logger;
-}, finalized: CheckpointWithHex): Promise<void>;
-//# sourceMappingURL=updateBackfillRange.d.ts.map

package/lib/chain/archiveStore/utils/updateBackfillRange.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"updateBackfillRange.d.ts","sourceRoot":"","sources":["../../../../src/chain/archiveStore/utils/updateBackfillRange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAC,MAAM,EAAC,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAC,SAAS,EAAC,MAAM,0BAA0B,CAAC;AACnD,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAEhD;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,EAAC,KAAK,EAAE,EAAE,EAAE,MAAM,EAAC,EAAE;IAAC,KAAK,EAAE,YAAY,CAAC;IAAC,EAAE,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,EACzE,SAAS,EAAE,iBAAiB,GAC3B,OAAO,CAAC,IAAI,CAAC,CA+Bf"}

package/lib/chain/archiveStore/utils/updateBackfillRange.js

@@ -1,40 +0,0 @@
-/**
- * Backfill sync relies on verified connected ranges (which are represented as key,value
- * with a verified jump from a key back to value). Since the node could have progressed
- * ahead from, we need to save the forward progress of this node as another backfill
- * range entry, that backfill sync will use to jump back if this node is restarted
- * for any reason.
- * The current backfill has its own backfill entry from anchor slot to last backfilled
- * slot. And this would create the entry from the current finalized slot to the anchor
- * slot.
- */
-export async function updateBackfillRange({ chain, db, logger }, finalized) {
-    try {
-        // Mark the sequence in backfill db from finalized block's slot till anchor slot as
-        // filled.
-        const finalizedBlockFC = chain.forkChoice.getBlockHexDefaultStatus(finalized.rootHex);
-        if (finalizedBlockFC && finalizedBlockFC.slot > chain.anchorStateLatestBlockSlot) {
-            await db.backfilledRanges.put(finalizedBlockFC.slot, chain.anchorStateLatestBlockSlot);
-            // Clear previously marked sequence till anchorStateLatestBlockSlot, without
-            // touching backfill sync process sequence which are at
-            // <=anchorStateLatestBlockSlot i.e. clear >anchorStateLatestBlockSlot
-            // and < currentSlot
-            const filteredSeqs = await db.backfilledRanges.entries({
-                gt: chain.anchorStateLatestBlockSlot,
-                lt: finalizedBlockFC.slot,
-            });
-            logger.debug("updated backfilledRanges", {
-                key: finalizedBlockFC.slot,
-                value: chain.anchorStateLatestBlockSlot,
-            });
-            if (filteredSeqs.length > 0) {
-                await db.backfilledRanges.batchDelete(filteredSeqs.map((entry) => entry.key));
-                logger.debug(`Forward Sync - cleaned up backfilledRanges between ${finalizedBlockFC.slot},${chain.anchorStateLatestBlockSlot}`, { seqs: JSON.stringify(filteredSeqs) });
-            }
-        }
-    }
-    catch (e) {
-        logger.error("Error updating backfilledRanges on finalization", { epoch: finalized.epoch }, e);
-    }
-}
-//# sourceMappingURL=updateBackfillRange.js.map

package/lib/chain/archiveStore/utils/updateBackfillRange.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"updateBackfillRange.js","sourceRoot":"","sources":["../../../../src/chain/archiveStore/utils/updateBackfillRange.ts"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,EAAC,KAAK,EAAE,EAAE,EAAE,MAAM,EAAuD,EACzE,SAA4B;IAE5B,IAAI,CAAC;QACH,mFAAmF;QACnF,UAAU;QACV,MAAM,gBAAgB,GAAG,KAAK,CAAC,UAAU,CAAC,wBAAwB,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QACtF,IAAI,gBAAgB,IAAI,gBAAgB,CAAC,IAAI,GAAG,KAAK,CAAC,0BAA0B,EAAE,CAAC;YACjF,MAAM,EAAE,CAAC,gBAAgB,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,0BAA0B,CAAC,CAAC;YAEvF,4EAA4E;YAC5E,uDAAuD;YACvD,sEAAsE;YACtE,oBAAoB;YACpB,MAAM,YAAY,GAAG,MAAM,EAAE,CAAC,gBAAgB,CAAC,OAAO,CAAC;gBACrD,EAAE,EAAE,KAAK,CAAC,0BAA0B;gBACpC,EAAE,EAAE,gBAAgB,CAAC,IAAI;aAC1B,CAAC,CAAC;YACH,MAAM,CAAC,KAAK,CAAC,0BAA0B,EAAE;gBACvC,GAAG,EAAE,gBAAgB,CAAC,IAAI;gBAC1B,KAAK,EAAE,KAAK,CAAC,0BAA0B;aACxC,CAAC,CAAC;YACH,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5B,MAAM,EAAE,CAAC,gBAAgB,CAAC,WAAW,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC9E,MAAM,CAAC,KAAK,CACV,sDAAsD,gBAAgB,CAAC,IAAI,IAAI,KAAK,CAAC,0BAA0B,EAAE,EACjH,EAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,EAAC,CACrC,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,CAAC,KAAK,CAAC,iDAAiD,EAAE,EAAC,KAAK,EAAE,SAAS,CAAC,KAAK,EAAC,EAAE,CAAU,CAAC,CAAC;IACxG,CAAC;AACH,CAAC"}

package/lib/db/repositories/backfilledRanges.d.ts

@@ -1,18 +0,0 @@
-import { ChainForkConfig } from "@lodestar/config";
-import { DatabaseController, Repository } from "@lodestar/db";
-import { Slot } from "@lodestar/types";
-/**
- * Slot to slot ranges that ensure that block range is fully backfilled
- *
- * If node starts backfilling at slots 1000, and backfills to 800, there will be an entry
- * 1000 -> 800
- *
- * When the node is backfilling if it starts at 1200 and backfills to 1000, it will find this sequence and,
- * jump directly to 800 and delete the key 1000.
- */
-export declare class BackfilledRanges extends Repository<Slot, Slot> {
-    constructor(config: ChainForkConfig, db: DatabaseController<Uint8Array, Uint8Array>);
-    decodeKey(data: Buffer): number;
-    getId(_value: Slot): number;
-}
-//# sourceMappingURL=backfilledRanges.d.ts.map

package/lib/db/repositories/backfilledRanges.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfilledRanges.d.ts","sourceRoot":"","sources":["../../../src/db/repositories/backfilledRanges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAC,kBAAkB,EAAE,UAAU,EAAC,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAC,IAAI,EAAM,MAAM,iBAAiB,CAAC;AAI1C;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,SAAQ,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC;IAC1D,YAAY,MAAM,EAAE,eAAe,EAAE,EAAE,EAAE,kBAAkB,CAAC,UAAU,EAAE,UAAU,CAAC,EAGlF;IAED,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9B;IAED,KAAK,CAAC,MAAM,EAAE,IAAI,GAAG,MAAM,CAE1B;CACF"}

package/lib/db/repositories/backfilledRanges.js

@@ -1,26 +0,0 @@
-import { Repository } from "@lodestar/db";
-import { ssz } from "@lodestar/types";
-import { bytesToInt } from "@lodestar/utils";
-import { Bucket, getBucketNameByValue } from "../buckets.js";
-/**
- * Slot to slot ranges that ensure that block range is fully backfilled
- *
- * If node starts backfilling at slots 1000, and backfills to 800, there will be an entry
- * 1000 -> 800
- *
- * When the node is backfilling if it starts at 1200 and backfills to 1000, it will find this sequence and,
- * jump directly to 800 and delete the key 1000.
- */
-export class BackfilledRanges extends Repository {
-    constructor(config, db) {
-        const bucket = Bucket.backfilled_ranges;
-        super(config, db, bucket, ssz.Slot, getBucketNameByValue(bucket));
-    }
-    decodeKey(data) {
-        return bytesToInt(super.decodeKey(data), "be");
-    }
-    getId(_value) {
-        throw new Error("Cannot get the db key from slot");
-    }
-}
-//# sourceMappingURL=backfilledRanges.js.map

package/lib/db/repositories/backfilledRanges.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfilledRanges.js","sourceRoot":"","sources":["../../../src/db/repositories/backfilledRanges.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,UAAU,EAAC,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAO,GAAG,EAAC,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAC,MAAM,EAAE,oBAAoB,EAAC,MAAM,eAAe,CAAC;AAE3D;;;;;;;;GAQG;AACH,MAAM,OAAO,gBAAiB,SAAQ,UAAsB;IAC1D,YAAY,MAAuB,EAAE,EAA8C;QACjF,MAAM,MAAM,GAAG,MAAM,CAAC,iBAAiB,CAAC;QACxC,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,OAAO,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAA0B,EAAE,IAAI,CAAC,CAAC;IAC1E,CAAC;IAED,KAAK,CAAC,MAAY;QAChB,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACrD,CAAC;CACF"}

package/lib/sync/backfill/backfill.d.ts

@@ -1,169 +0,0 @@
-import { EventEmitter } from "node:events";
-import { StrictEventEmitter } from "strict-event-emitter-types";
-import { BeaconConfig } from "@lodestar/config";
-import { IBeaconStateView } from "@lodestar/state-transition";
-import { Root, SignedBeaconBlock, Slot, phase0 } from "@lodestar/types";
-import { Logger } from "@lodestar/utils";
-import { IBeaconChain } from "../../chain/index.js";
-import { IBeaconDb } from "../../db/index.js";
-import { Metrics } from "../../metrics/metrics.js";
-import { INetwork } from "../../network/index.js";
-import { BackfillBlock, BackfillBlockHeader } from "./verify.js";
-export type BackfillSyncModules = {
-    chain: IBeaconChain;
-    db: IBeaconDb;
-    network: INetwork;
-    config: BeaconConfig;
-    logger: Logger;
-    metrics: Metrics | null;
-    anchorState: IBeaconStateView;
-    wsCheckpoint?: phase0.Checkpoint;
-    signal: AbortSignal;
-};
-type BackfillModules = BackfillSyncModules & {
-    syncAnchor: BackFillSyncAnchor;
-    backfillStartFromSlot: Slot;
-    prevFinalizedCheckpointBlock: BackfillBlockHeader;
-    wsCheckpointHeader: BackfillBlockHeader | null;
-    backfillRangeWrittenSlot: Slot | null;
-};
-export type BackfillSyncOpts = {
-    backfillBatchSize: number;
-};
-export declare enum BackfillSyncEvent {
-    completed = "BackfillSync-completed"
-}
-export declare enum BackfillSyncMethod {
-    database = "database",
-    backfilled_ranges = "backfilled_ranges",
-    rangesync = "rangesync",
-    blockbyroot = "blockbyroot"
-}
-export declare enum BackfillSyncStatus {
-    pending = "pending",
-    syncing = "syncing",
-    completed = "completed",
-    aborted = "aborted"
-}
-type BackfillSyncEvents = {
-    [BackfillSyncEvent.completed]: (
-    /** Oldest slot synced */
-    oldestSlotSynced: Slot) => void;
-};
-type BackfillSyncEmitter = StrictEventEmitter<EventEmitter, BackfillSyncEvents>;
-/**
- * At any given point, we should have
- * 1. anchorBlock (with its root anchorBlockRoot at anchorSlot) for next round of sync
- *    which is the same as the lastBackSyncedBlock
- * 2. We know the anchorBlockRoot but don't have its anchorBlock and anchorSlot yet, and its
- *    parent of lastBackSyncedBlock we synced in a previous successfull round
- * 3. We just started with only anchorBlockRoot, but we know (and will validate) its anchorSlot
- */
-type BackFillSyncAnchor = {
-    anchorBlock: SignedBeaconBlock;
-    anchorBlockRoot: Root;
-    anchorSlot: Slot;
-    lastBackSyncedBlock: BackfillBlock;
-} | {
-    anchorBlock: null;
-    anchorBlockRoot: Root;
-    anchorSlot: null;
-    lastBackSyncedBlock: BackfillBlock;
-} | {
-    anchorBlock: null;
-    anchorBlockRoot: Root;
-    anchorSlot: Slot;
-    lastBackSyncedBlock: null;
-};
-declare const BackfillSync_base: new () => BackfillSyncEmitter;
-export declare class BackfillSync extends BackfillSync_base {
-    /** Lowest slot that we have backfilled to */
-    syncAnchor: BackFillSyncAnchor;
-    private readonly chain;
-    private readonly network;
-    private readonly db;
-    private readonly config;
-    private readonly logger;
-    private readonly metrics;
-    /**
-     * Process in blocks of at max batchSize
-     */
-    private opts;
-    /**
-     * If wsCheckpoint provided was in past then the (db) state from which beacon node started,
-     * needs to be validated as per spec.
-     *
-     * 1. This could lie in between of the previous backfilled range, in which case it would be
-     *    sufficient to check if its DB, once the linkage to that range has been verified.
-     * 2. Else if it lies outside the backfilled range, the linkage to this checkpoint in
-     *    backfill needs to be verified.
-     */
-    private wsCheckpointHeader;
-    private wsValidated;
-    /**
-     * From https://github.com/ethereum/consensus-specs/blob/v1.6.1/specs/phase0/weak-subjectivity.md
-     *
-     *
-     * If
-     *   1. The wsCheckpoint provided was ahead of the db's finalized checkpoint or
-     *   2. There were gaps in the backfill - keys to backfillRanges are always (by construction)
-     *     a) Finalized Checkpoint or b) previous wsCheckpoint
-     *
-     * the linkage to the previous finalized/wss checkpoint(s) needs to be verfied. If there is
-     * no such checkpoint remaining, the linkage to genesis needs to be validated
-     *
-     * Initialize with the blockArchive's last block, and on verification update to the next
-     * preceding backfillRange key's checkpoint.
-     */
-    private prevFinalizedCheckpointBlock;
-    /** Starting point that this specific backfill sync "session" started from */
-    private backfillStartFromSlot;
-    private backfillRangeWrittenSlot;
-    private processor;
-    private peers;
-    private status;
-    private signal;
-    constructor(opts: BackfillSyncOpts, modules: BackfillModules);
-    /**
-     * Use the root of the anchorState of the beacon node as the starting point of the
-     * backfill sync with its expected slot to be anchorState.slot, which will be
-     * validated once the block is resolved in the backfill sync.
-     *
-     * NOTE: init here is quite light involving couple of
-     *
-     *   1. db keys lookup in stateArchive/backfilledRanges
-     *   2. computing root(s) for anchorBlockRoot and prevFinalizedCheckpointBlock
-     *
-     * The way we initialize beacon node, wsCheckpoint's slot is always <= anchorSlot
-     * If:
-     *   the root belonging to wsCheckpoint is in the DB, we need to verify linkage to it
-     *   i.e. it becomes our first prevFinalizedCheckpointBlock
-     * Else
-     *   we initialize prevFinalizedCheckpointBlock from the last stored db finalized state
-     *   for verification and when we go below its epoch we just check if a correct block
-     *   corresponding to wsCheckpoint root was stored.
-     *
-     * and then we continue going back and verifying the next unconnected previous finalized
-     * or wsCheckpoints identifiable as the keys of backfill sync.
-     */
-    static init<T extends BackfillSync = BackfillSync>(opts: BackfillSyncOpts, modules: BackfillSyncModules): Promise<T>;
-    /** Throw / return all AsyncGenerators */
-    close(): void;
-    /**
-     * @returns Returns oldestSlotSynced
-     */
-    private sync;
-    private addPeer;
-    private removePeer;
-    /**
-     * Ensure that any weak subjectivity checkpoint provided in past with respect
-     * the initialization point is the same block tree as the DB once backfill
-     */
-    private checkIfCheckpointSyncedAndValidate;
-    private checkUpdateFromBackfillSequences;
-    private fastBackfillDb;
-    private syncBlockByRoot;
-    private syncRange;
-}
-export {};
-//# sourceMappingURL=backfill.d.ts.map

package/lib/sync/backfill/backfill.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backfill.d.ts","sourceRoot":"","sources":["../../../src/sync/backfill/backfill.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AACzC,OAAO,EAAC,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAC,YAAY,EAAkB,MAAM,kBAAkB,CAAC;AAE/D,OAAO,EAAC,gBAAgB,EAAgB,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAAC,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,EAAM,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAe,MAAM,EAAoC,MAAM,iBAAiB,CAAC;AACxF,OAAO,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAC,SAAS,EAAC,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAC,OAAO,EAAC,MAAM,0BAA0B,CAAC;AACjD,OAAO,EAAC,QAAQ,EAA6C,MAAM,wBAAwB,CAAC;AAK5F,OAAO,EAAC,aAAa,EAAE,mBAAmB,EAAoD,MAAM,aAAa,CAAC;AAQlH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,YAAY,CAAC;IACpB,EAAE,EAAE,SAAS,CAAC;IACd,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,gBAAgB,CAAC;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACjC,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF,KAAK,eAAe,GAAG,mBAAmB,GAAG;IAC3C,UAAU,EAAE,kBAAkB,CAAC;IAC/B,qBAAqB,EAAE,IAAI,CAAC;IAC5B,4BAA4B,EAAE,mBAAmB,CAAC;IAClD,kBAAkB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC/C,wBAAwB,EAAE,IAAI,GAAG,IAAI,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,oBAAY,iBAAiB;IAC3B,SAAS,2BAA2B;CACrC;AAED,oBAAY,kBAAkB;IAC5B,QAAQ,aAAa;IACrB,iBAAiB,sBAAsB;IACvC,SAAS,cAAc;IACvB,WAAW,gBAAgB;CAC5B;AAED,oBAAY,kBAAkB;IAC5B,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,OAAO,YAAY;CACpB;AAUD,KAAK,kBAAkB,GAAG;IACxB,CAAC,iBAAiB,CAAC,SAAS,CAAC,EAAE;IAC7B,yBAAyB;IACzB,gBAAgB,EAAE,IAAI,KACnB,IAAI,CAAC;CACX,CAAC;AAEF,KAAK,mBAAmB,GAAG,kBAAkB,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;AAEhF;;;;;;;GAOG;AACH,KAAK,kBAAkB,GACnB;IACE,WAAW,EAAE,iBAAiB,CAAC;IAC/B,eAAe,EAAE,IAAI,CAAC;IACtB,UAAU,EAAE,IAAI,CAAC;IACjB,mBAAmB,EAAE,aAAa,CAAC;CACpC,GACD;IAAC,WAAW,EAAE,IAAI,CAAC;IAAC,eAAe,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,IAAI,CAAC;IAAC,mBAAmB,EAAE,aAAa,CAAA;CAAC,GAChG;IAAC,WAAW,EAAE,IAAI,CAAC;IAAC,eAAe,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,IAAI,CAAC;IAAC,mBAAmB,EAAE,IAAI,CAAA;CAAC,CAAC;2CAEhC,mBAAmB;AAA/E,qBAAa,YAAa,SAAQ,iBAA+C;IAC/E,6CAA6C;IAC7C,UAAU,EAAE,kBAAkB,CAAC;IAE/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAW;IACnC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAY;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IAEzC;;OAEG;IACH,OAAO,CAAC,IAAI,CAAmB;IAC/B;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB,CAA6B;IACvD,OAAO,CAAC,WAAW,CAAS;IAE5B;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,4BAA4B,CAAsB;IAC1D,6EAA6E;IAC7E,OAAO,CAAC,qBAAqB,CAAO;IACpC,OAAO,CAAC,wBAAwB,CAAc;IAE9C,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,MAAM,CAAkD;IAChE,OAAO,CAAC,MAAM,CAAc;IAE5B,YAAY,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,eAAe,EAkD3D;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAa,IAAI,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,EACrD,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,CAAC,CAAC,CAyCZ;IAED,yCAAyC;IACzC,KAAK,IAAI,IAAI,CAIZ;IAED;;OAEG;YACW,IAAI;IAyMlB,OAAO,CAAC,OAAO,CAOb;IAEF,OAAO,CAAC,UAAU,CAEhB;IAEF;;;OAGG;YACW,kCAAkC;YA2ClC,gCAAgC;YA4GhC,cAAc;YA4Fd,eAAe;YAsCf,SAAS;CA8FxB"}