@lodestar/beacon-node 1.48.0-dev.acdde443d2 → 1.48.0-dev.af8bc602aa

package/src/db/repositories/blockArchive.ts

@@ -1,17 +1,16 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {Db, DbBatch, FilterOptions, KeyValue, Repository} from "@lodestar/db";
+import {Db, FilterOptions, KeyValue, Repository} from "@lodestar/db";
 import {Root, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
-import {bytesToInt, intToBytes} from "@lodestar/utils";
+import {bytesToInt} from "@lodestar/utils";
 import {getSignedBlockTypeFromBytes} from "../../util/multifork.js";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 import {
   deleteParentRootIndex,
   deleteRootIndex,
   getParentRootIndex,
-  getParentRootIndexKey,
   getRootIndex,
-  getRootIndexKey,
-  getSlotIndexKey,
+  storeParentRootIndex,
+  storeRootIndex,
 } from "./blockArchiveIndex.js";
 
 export interface BlockFilterOptions extends FilterOptions<Slot> {
@@ -57,91 +56,37 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
   // Overrides to index
 
   async put(key: Slot, value: SignedBeaconBlock): Promise<void> {
-    await this.batchPut([{key, value}]);
-  }
-
-  async putBinary(key: Slot, value: Uint8Array): Promise<void> {
-    const block = this.decodeValue(value);
-    await this.batchPutBinary([
-      {
-        key,
-        value,
-        slot: block.message.slot,
-        blockRoot: this.config.getForkTypes(block.message.slot).BeaconBlock.hashTreeRoot(block.message),
-        parentRoot: block.message.parentRoot,
-      },
+    const blockRoot = this.config.getForkTypes(value.message.slot).BeaconBlock.hashTreeRoot(value.message);
+    const slot = value.message.slot;
+    await Promise.all([
+      super.put(key, value),
+      storeRootIndex(this.db, slot, blockRoot),
+      storeParentRootIndex(this.db, slot, value.message.parentRoot),
     ]);
   }
 
   async batchPut(items: KeyValue<Slot, SignedBeaconBlock>[]): Promise<void> {
-    await this.batchPutBinary(
-      items.map(({key, value}) => ({
-        key,
-        value: this.encodeValue(value),
-        slot: value.message.slot,
-        blockRoot: this.config.getForkTypes(value.message.slot).BeaconBlock.hashTreeRoot(value.message),
-        parentRoot: value.message.parentRoot,
-      }))
-    );
+    await Promise.all([
+      super.batchPut(items),
+      Array.from(items).map((item) => {
+        const slot = item.value.message.slot;
+        const blockRoot = this.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(item.value.message);
+        return storeRootIndex(this.db, slot, blockRoot);
+      }),
+      Array.from(items).map((item) => {
+        const slot = item.value.message.slot;
+        const parentRoot = item.value.message.parentRoot;
+        return storeParentRootIndex(this.db, slot, parentRoot);
+      }),
+    ]);
   }
 
   async batchPutBinary(items: BlockArchiveBatchPutBinaryItem[]): Promise<void> {
-    await this.db.batchPut(
-      items.flatMap((item) => this.indexedBlockEntries(item)),
-      this.dbReqOpts
-    );
-  }
-
-  async delete(slot: Slot): Promise<void> {
-    await this.batchDelete([slot]);
-  }
-
-  async batchDelete(slots: Slot[]): Promise<void> {
-    await this.db.batchDelete(
-      slots.flatMap((slot) => [this.encodeKey(slot), getSlotIndexKey(slot)]),
-      this.dbReqOpts
-    );
-  }
-
-  async batch(operations: DbBatch<Slot, SignedBeaconBlock>): Promise<void> {
-    await this.batchBinary(
-      operations.map((operation) =>
-        operation.type === "put" ? {...operation, value: this.encodeValue(operation.value)} : operation
-      )
-    );
-  }
-
-  async batchBinary(operations: DbBatch<Slot, Uint8Array>): Promise<void> {
-    const batch: DbBatch<Uint8Array, Uint8Array> = [];
-    for (const operation of operations) {
-      if (operation.type === "del") {
-        batch.push(
-          {type: "del", key: this.encodeKey(operation.key)},
-          {type: "del", key: getSlotIndexKey(operation.key)}
-        );
-      } else {
-        const block = this.decodeValue(operation.value);
-        const entries = this.indexedBlockEntries({
-          key: operation.key,
-          value: operation.value,
-          slot: block.message.slot,
-          blockRoot: this.config.getForkTypes(block.message.slot).BeaconBlock.hashTreeRoot(block.message),
-          parentRoot: block.message.parentRoot,
-        });
-        batch.push(...entries.map((entry) => ({type: "put" as const, ...entry})));
-      }
-    }
-    await this.db.batch(batch, this.dbReqOpts);
-  }
-
-  private indexedBlockEntries(item: BlockArchiveBatchPutBinaryItem): KeyValue<Uint8Array, Uint8Array>[] {
-    const slotBytes = intToBytes(item.slot, 8, "be");
-    return [
-      {key: this.encodeKey(item.key), value: item.value},
-      {key: getRootIndexKey(item.blockRoot), value: slotBytes},
-      {key: getParentRootIndexKey(item.parentRoot), value: slotBytes},
-      {key: getSlotIndexKey(item.key), value: item.blockRoot},
-    ];
+    await Promise.all([
+      super.batchPutBinary(items),
+      Array.from(items).map((item) => storeRootIndex(this.db, item.slot, item.blockRoot)),
+      Array.from(items).map((item) => storeParentRootIndex(this.db, item.slot, item.parentRoot)),
+    ]);
   }
 
   async remove(value: SignedBeaconBlock): Promise<void> {
@@ -155,10 +100,10 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
   async batchRemove(values: SignedBeaconBlock[]): Promise<void> {
     await Promise.all([
       super.batchRemove(values),
-      ...values.map((value) =>
+      Array.from(values).map((value) =>
         deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).SignedBeaconBlock, value)
       ),
-      ...values.map((value) => deleteParentRootIndex(this.db, value)),
+      Array.from(values).map((value) => deleteParentRootIndex(this.db, value)),
     ]);
   }
 
@@ -195,10 +140,6 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
     return slot !== null ? this.get(slot) : null;
   }
 
-  async getRootBySlot(slot: Slot): Promise<Root | null> {
-    return this.db.get(getSlotIndexKey(slot), {bucketId: getBucketNameByValue(Bucket.index_mainChain)});
-  }
-
   async getSlotByRoot(root: Root): Promise<Slot | null> {
     return this.parseSlot(await getRootIndex(this.db, root));
   }

package/src/db/repositories/blockArchiveIndex.ts

@@ -1,6 +1,7 @@
 import {Db, encodeKey} from "@lodestar/db";
 import {ForkAll} from "@lodestar/params";
 import {Root, SSZTypesFor, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
+import {intToBytes} from "@lodestar/utils";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 export const rootIndexBucketId = getBucketNameByValue(Bucket.index_blockArchiveRootIndex);
@@ -14,6 +15,14 @@ export async function getParentRootIndex(db: Db, parentRoot: Root): Promise<Uint
   return db.get(getParentRootIndexKey(parentRoot), {bucketId: parentRootIndexBucketId});
 }
 
+export async function storeRootIndex(db: Db, slot: Slot, blockRoot: Root): Promise<void> {
+  return db.put(getRootIndexKey(blockRoot), intToBytes(slot, 8, "be"), {bucketId: rootIndexBucketId});
+}
+
+export async function storeParentRootIndex(db: Db, slot: Slot, parentRoot: Root): Promise<void> {
+  return db.put(getParentRootIndexKey(parentRoot), intToBytes(slot, 8, "be"), {bucketId: parentRootIndexBucketId});
+}
+
 export async function deleteRootIndex(
   db: Db,
   signedBeaconBlockType: SSZTypesFor<ForkAll, "SignedBeaconBlock">,
@@ -34,7 +43,3 @@ export function getParentRootIndexKey(parentRoot: Root): Uint8Array {
 export function getRootIndexKey(root: Root): Uint8Array {
   return encodeKey(Bucket.index_blockArchiveRootIndex, root);
 }
-
-export function getSlotIndexKey(slot: Slot): Uint8Array {
-  return encodeKey(Bucket.index_mainChain, slot);
-}

package/src/metrics/metrics/lodestar.ts

@@ -21,7 +21,6 @@ import {ReprocessStatus} from "../../chain/reprocess.js";
 import {RejectReason} from "../../chain/seenCache/seenAttestationData.js";
 import {CacheItemType} from "../../chain/stateCache/types.js";
 import {OpSource} from "../../chain/validatorMonitor.js";
-import type {FlatFileStoreOperation} from "../../db/flatFileStore/metrics.js";
 import {ExecutionPayloadStatus} from "../../execution/index.js";
 import {GossipType} from "../../network/index.js";
 import {CannotAcceptWorkReason, ReprocessRejectReason} from "../../network/processor/index.js";
@@ -2100,7 +2099,7 @@ export function createLodestarMetrics(
       }),
       dbSizeTotal: register.gauge({
         name: "lodestar_db_size_bytes_total",
-        help: "Approximate number of bytes of file system space used by LevelDB",
+        help: "Approximate number of bytes of file system space used by db",
       }),
       dbApproximateSizeTime: register.histogram({
         name: "lodestar_db_approximate_size_time_seconds",
@@ -2109,61 +2108,6 @@ export function createLodestarMetrics(
       }),
     },
 
-    flatFileStore: {
-      operationDuration: {
-        read: register.histogram({
-          name: "lodestar_flat_file_store_read_duration_seconds",
-          help: "Duration of flat file store reads in seconds",
-          buckets: [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05],
-        }),
-        write: register.histogram({
-          name: "lodestar_flat_file_store_write_duration_seconds",
-          help: "Duration of flat file store writes in seconds",
-          buckets: [0.005, 0.01, 0.05, 0.1, 0.5, 1],
-        }),
-        delete: register.histogram({
-          name: "lodestar_flat_file_store_delete_duration_seconds",
-          help: "Duration of flat file store deletions in seconds",
-          buckets: [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05],
-        }),
-        prune: register.histogram({
-          name: "lodestar_flat_file_store_prune_duration_seconds",
-          help: "Duration of flat file store pruning in seconds",
-          buckets: [0.0005, 0.01, 0.05, 0.5, 5, 30],
-        }),
-      },
-      operationErrors: register.counter<{operation: FlatFileStoreOperation}>({
-        name: "lodestar_flat_file_store_operation_errors_total",
-        help: "Total count of failed flat file store operations",
-        labelNames: ["operation"],
-      }),
-      readBytes: register.counter({
-        name: "lodestar_flat_file_store_read_bytes_total",
-        help: "Total bytes read from flat file storage",
-      }),
-      writeBytes: register.counter({
-        name: "lodestar_flat_file_store_write_bytes_total",
-        help: "Total bytes written to flat file storage",
-      }),
-      prunedDirectories: register.counter({
-        name: "lodestar_flat_file_store_pruned_directories_total",
-        help: "Total count of slot directories pruned from flat file storage",
-      }),
-      slotIndexSize: register.gauge({
-        name: "lodestar_flat_file_store_indexed_slots",
-        help: "Count of indexed flat file slot directories, including empty directories awaiting pruning",
-      }),
-      startupDuration: register.histogram({
-        name: "lodestar_flat_file_store_startup_duration_seconds",
-        help: "Duration of flat file store slot index reconstruction in seconds",
-        buckets: [0.1, 0.5, 1, 5, 10, 30, 60, 300],
-      }),
-      startupErrors: register.counter({
-        name: "lodestar_flat_file_store_startup_errors_total",
-        help: "Total count of flat file store startup failures",
-      }),
-    },
-
     pruneHistory: {
       pruneCount: register.gauge({
         name: "lodestar_prune_history_prune_count_total",

package/src/monitoring/clientStats.ts

@@ -107,7 +107,7 @@ function createBeaconNodeStats(): ClientStats {
       metricName: "lodestar_db_size_bytes_total",
       jsonType: JsonType.Number,
       defaultValue: 0,
-      description: "Amount of bytes consumed on disk by the beacon node's LevelDB database",
+      description: "Amount of bytes consumed on disk by the beacon node's database",
     }),
     networkLibp2pBytesTotalReceive: new MetricProperty({
       jsonKey: "network_libp2p_bytes_total_receive",

package/src/network/gossip/encoding.ts

@@ -123,6 +123,9 @@ export class DataTransformSnappy implements DataTransform {
     if (uncompressedDataLength > maxSize) {
       throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${maxSize}`);
     }
+    if (uncompressedDataLength > sszType.maxSize) {
+      throw Error(`ssz_snappy decoded data length ${uncompressedDataLength} > ${sszType.maxSize}`);
+    }
 
     // Only after sanity length checks, we can decompress the data
     // Using Buffer.alloc() instead of Buffer.allocUnsafe() to mitigate high GC pressure observed in some environments
@@ -143,6 +146,9 @@ export class DataTransformSnappy implements DataTransform {
     if (data.length > maxSize) {
       throw Error(`ssz_snappy encoded data length ${data.length} > ${maxSize}`);
     }
+    if (data.length > sszType.maxSize) {
+      throw Error(`ssz_snappy encoded data length ${data.length} > ${sszType.maxSize}`);
+    }
 
     // Using Buffer.alloc() instead of Buffer.allocUnsafe() to mitigate high GC pressure observed in some environments
     const compressedData = Buffer.alloc(snappyWasm.max_compress_len(data.length));

package/src/network/gossip/topic.ts

@@ -4,11 +4,17 @@ import {
   ATTESTATION_SUBNET_COUNT,
   ForkName,
   ForkSeq,
+  MAX_ATTESTER_SLASHING_SIZE,
+  MAX_DATA_COLUMN_SIDECAR_SIZE,
+  MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE,
+  MAX_SIGNED_EXECUTION_PAYLOAD_BID_SIZE,
+  MAX_SIGNED_EXECUTION_PAYLOAD_BID_SIZE_HEZE,
   SYNC_COMMITTEE_SUBNET_COUNT,
   isForkPostAltair,
   isForkPostElectra,
   isForkPostFulu,
   isForkPostGloas,
+  isForkPostHeze,
 } from "@lodestar/params";
 import {Attestation, SingleAttestation, ssz, sszTypesFor} from "@lodestar/types";
 import {GossipAction, GossipActionError, GossipErrorCode} from "../../chain/errors/gossipValidation.js";
@@ -133,11 +139,27 @@ export function getGossipSSZType(topic: GossipTopic) {
 }
 
 /**
- * Return the maximum uncompressed SSZ byte length accepted for a gossip object, the SSZ type max size
- * or MAX_PAYLOAD_SIZE, whichever is smaller.
+ * Return the maximum uncompressed SSZ byte length accepted for a gossip object.
  */
 export function getGossipSSZMaxSize(topic: GossipTopic, maxPayloadSize: number, sszType?: CompositeTypeAny): number {
-  return Math.min((sszType ?? getGossipSSZType(topic)).maxSize, maxPayloadSize);
+  const {fork} = topic.boundary;
+  // Gloas progressive containers have broad theoretical SSZ max sizes; use the preset p2p bounds instead.
+  switch (topic.type) {
+    case GossipType.beacon_block:
+      return maxPayloadSize;
+    case GossipType.beacon_aggregate_and_proof:
+      return isForkPostGloas(fork) ? MAX_SIGNED_AGGREGATE_AND_PROOF_SIZE : (sszType ?? getGossipSSZType(topic)).maxSize;
+    case GossipType.attester_slashing:
+      return isForkPostGloas(fork) ? MAX_ATTESTER_SLASHING_SIZE : (sszType ?? getGossipSSZType(topic)).maxSize;
+    case GossipType.data_column_sidecar:
+      return isForkPostGloas(fork) ? MAX_DATA_COLUMN_SIDECAR_SIZE : (sszType ?? getGossipSSZType(topic)).maxSize;
+    case GossipType.execution_payload:
+      return maxPayloadSize;
+    case GossipType.execution_payload_bid:
+      return isForkPostHeze(fork) ? MAX_SIGNED_EXECUTION_PAYLOAD_BID_SIZE_HEZE : MAX_SIGNED_EXECUTION_PAYLOAD_BID_SIZE;
+    default:
+      return (sszType ?? getGossipSSZType(topic)).maxSize;
+  }
 }
 
 /**

package/src/network/processor/gossipHandlers.ts

@@ -27,7 +27,7 @@ import {
   ssz,
   sszTypesFor,
 } from "@lodestar/types";
-import {LogLevel, Logger, toHex, toRootHex} from "@lodestar/utils";
+import {LogLevel, Logger, prettyBytes, toHex, toRootHex} from "@lodestar/utils";
 import {
   BlockInput,
   BlockInputColumns,
@@ -157,6 +157,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     const slot = signedBlock.message.slot;
     const forkTypes = config.getForkTypes(slot);
     const blockRootHex = toRootHex(forkTypes.BeaconBlock.hashTreeRoot(signedBlock.message));
+    const blockShortHex = prettyBytes(blockRootHex);
     const delaySec = chain.clock.secFromSlot(slot, seenTimestampSec);
     const recvToValLatency = Date.now() / 1000 - seenTimestampSec;
 
@@ -166,7 +167,6 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
 
     const logCtx = {
       slot,
-      root: blockRootHex,
       currentSlot: chain.clock.currentSlot,
       peerId: peerIdStr,
       delaySec,
@@ -227,7 +227,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       return blockInput;
     } catch (e) {
       if (e instanceof BlockGossipError) {
-        logger.debug("Gossip block has error", {slot, root: blockRootHex, code: e.type.code});
+        logger.debug("Gossip block has error", {slot, root: blockShortHex, code: e.type.code});
         if (
           (e.type.code === BlockErrorCode.PARENT_BLOCK_UNKNOWN ||
             e.type.code === BlockErrorCode.PARENT_PAYLOAD_UNKNOWN) &&
@@ -249,12 +249,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
           throw e;
         }
 
-        chain.persistInvalidSszValue(
-          forkTypes.SignedBeaconBlock,
-          signedBlock,
-          `gossip_reject_slot_${slot}`,
-          blockRootHex
-        );
+        chain.persistInvalidSszValue(forkTypes.SignedBeaconBlock, signedBlock, `gossip_reject_slot_${slot}`);
       }
 
       // REJECT or unexpected (non-BlockGossipError) error: drop the optimistically-added entries from
@@ -284,6 +279,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
     const slot = blobBlockHeader.slot;
     const fork = config.getForkName(slot);
     const blockRootHex = toRootHex(ssz.phase0.BeaconBlockHeader.hashTreeRoot(blobBlockHeader));
+    const blockShortHex = prettyBytes(blockRootHex);
 
     const delaySec = chain.clock.secFromSlot(slot, seenTimestampSec);
     const recvToValLatency = Date.now() / 1000 - seenTimestampSec;
@@ -336,7 +332,7 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
       if (e instanceof BlobSidecarGossipError) {
         // Don't trigger this yet if full block and blobs haven't arrived yet
         if (e.type.code === BlobSidecarErrorCode.PARENT_UNKNOWN) {
-          logger.debug("Gossip blob has error", {slot, root: blockRootHex, code: e.type.code});
+          logger.debug("Gossip blob has error", {slot, root: blockShortHex, code: e.type.code});
           // no need to trigger `unknownBlockParent` event here, as we already did it in `validateBeaconBlock()`
           //
           // TODO(fulu): is this note above correct? Could have random blob that we see that could trigger
@@ -700,7 +696,11 @@ function getSequentialHandlers(modules: ValidatorFnsModules, options: GossipHand
           logLevel = LogLevel.error;
         }
         metrics?.gossipBlock.processBlockErrors.inc({error: e instanceof BlockError ? e.type.code : "NOT_BLOCK_ERROR"});
-        logger[logLevel]("Error processing block", {slot, root: blockInput.blockRootHex, peer: peerIdStr}, e as Error);
+        logger[logLevel](
+          "Error processing block",
+          {slot, peer: peerIdStr, blockRoot: prettyBytes(blockInput.blockRootHex)},
+          e as Error
+        );
         // TODO(fulu): Revisit when we prune block inputs
         chain.seenBlockInputCache.prune(blockInput.blockRootHex);
       });