@lodestar/beacon-node 1.50.0-dev.033e6b7138 → 1.50.0-dev.03c05fa09a

package/src/db/interface.ts

@@ -3,6 +3,7 @@ import {Slot} from "@lodestar/types";
 import type {IDataColumnStore} from "./dataColumnStore.js";
 import type {FlatFileStoreMetrics} from "./flatFileStore/metrics.js";
 import {CheckpointStateRepository} from "./repositories/checkpointState.js";
+import {EarliestAvailableSlotRepository} from "./repositories/earliestAvailableSlot.js";
 import {
   AttesterSlashingRepository,
   BLSToExecutionChangeRepository,
@@ -16,6 +17,7 @@ import {
   DataColumnSidecarRepository,
   ExecutionPayloadEnvelopeArchiveRepository,
   ExecutionPayloadEnvelopeRepository,
+  ProposerPreferencesRepository,
   ProposerSlashingRepository,
   StateArchiveRepository,
   SyncCommitteeRepository,
@@ -46,10 +48,12 @@ export interface IBeaconDb {
   stateArchive: StateArchiveRepository;
   // checkpoint states
   checkpointState: CheckpointStateRepository;
+  earliestAvailableSlot: EarliestAvailableSlotRepository;
 
   // op pool
   voluntaryExit: VoluntaryExitRepository;
   proposerSlashing: ProposerSlashingRepository;
+  proposerPreferences: ProposerPreferencesRepository;
   attesterSlashing: AttesterSlashingRepository;
   blsToExecutionChange: BLSToExecutionChangeRepository;
 

package/src/db/repositories/blockArchive.ts

@@ -184,7 +184,7 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
   async remove(value: SignedBeaconBlock): Promise<void> {
     await Promise.all([
       super.remove(value),
-      deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).SignedBeaconBlock, value),
+      deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).BeaconBlock, value),
       deleteParentRootIndex(this.db, value),
     ]);
   }
@@ -193,7 +193,7 @@ export class BlockArchiveRepository extends Repository<Slot, SignedBeaconBlock>
     await Promise.all([
       super.batchRemove(values),
       ...values.map((value) =>
-        deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).SignedBeaconBlock, value)
+        deleteRootIndex(this.db, this.config.getForkTypes(value.message.slot).BeaconBlock, value)
       ),
       ...values.map((value) => deleteParentRootIndex(this.db, value)),
     ]);

package/src/db/repositories/blockArchiveIndex.ts

@@ -1,6 +1,6 @@
 import {Db, encodeKey} from "@lodestar/db";
 import {ForkAll} from "@lodestar/params";
-import {Root, SSZTypesFor, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
+import {Root, SSZTypesFor, SignedBeaconBlock, Slot} from "@lodestar/types";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 export const rootIndexBucketId = getBucketNameByValue(Bucket.index_blockArchiveRootIndex);
@@ -16,10 +16,9 @@ export async function getParentRootIndex(db: Db, parentRoot: Root): Promise<Uint
 
 export async function deleteRootIndex(
   db: Db,
-  signedBeaconBlockType: SSZTypesFor<ForkAll, "SignedBeaconBlock">,
+  beaconBlockType: SSZTypesFor<ForkAll, "BeaconBlock">,
   block: SignedBeaconBlock
 ): Promise<void> {
-  const beaconBlockType = (signedBeaconBlockType as typeof ssz.phase0.SignedBeaconBlock).fields.message;
   return db.delete(getRootIndexKey(beaconBlockType.hashTreeRoot(block.message)), {bucketId: rootIndexBucketId});
 }
 

package/src/db/repositories/earliestAvailableSlot.ts

@@ -0,0 +1,19 @@
+import {Db, encodeKey} from "@lodestar/db";
+import {Slot, ssz} from "@lodestar/types";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+export class EarliestAvailableSlotRepository {
+  private readonly key = encodeKey(Bucket.earliestAvailableSlot, 0);
+  private readonly opts = {bucketId: getBucketNameByValue(Bucket.earliestAvailableSlot)};
+
+  constructor(private readonly db: Db) {}
+
+  async get(): Promise<Slot | null> {
+    const bytes = await this.db.get(this.key, this.opts);
+    return bytes === null ? null : ssz.Slot.deserialize(bytes);
+  }
+
+  async set(slot: Slot): Promise<void> {
+    await this.db.put(this.key, ssz.Slot.serialize(slot), this.opts);
+  }
+}

package/src/db/repositories/index.ts

@@ -18,6 +18,7 @@ export {BestLightClientUpdateRepository} from "./lightclientBestUpdate.js";
 export {CheckpointHeaderRepository} from "./lightclientCheckpointHeader.js";
 export {SyncCommitteeRepository} from "./lightclientSyncCommittee.js";
 export {SyncCommitteeWitnessRepository} from "./lightclientSyncCommitteeWitness.js";
+export {ProposerPreferencesRepository} from "./proposerPreferences.js";
 export {ProposerSlashingRepository} from "./proposerSlashing.js";
 export {StateArchiveRepository} from "./stateArchive.js";
 export {VoluntaryExitRepository} from "./voluntaryExit.js";

package/src/db/repositories/proposerPreferences.ts

@@ -0,0 +1,23 @@
+import {ChainForkConfig} from "@lodestar/config";
+import {Db, Repository} from "@lodestar/db";
+import {gloas, ssz} from "@lodestar/types";
+import {intToBytes} from "@lodestar/utils";
+import {Bucket, getBucketNameByValue} from "../buckets.js";
+
+/**
+ * SignedProposerPreferences indexed by proposal slot and dependent root
+ *
+ * Added via gossip or api
+ * Removed once the proposal slot has passed
+ */
+export class ProposerPreferencesRepository extends Repository<Uint8Array, gloas.SignedProposerPreferences> {
+  constructor(config: ChainForkConfig, db: Db) {
+    const bucket = Bucket.gloas_proposerPreferences;
+    super(config, db, bucket, ssz.gloas.SignedProposerPreferences, getBucketNameByValue(bucket));
+  }
+
+  getId(value: gloas.SignedProposerPreferences): Uint8Array {
+    const {proposalSlot, dependentRoot} = value.message;
+    return Buffer.concat([intToBytes(proposalSlot, 8, "be"), dependentRoot]);
+  }
+}

package/src/db/repositories/proposerSlashing.ts

@@ -1,6 +1,7 @@
 import {ChainForkConfig} from "@lodestar/config";
-import {Db, Repository} from "@lodestar/db";
+import {BUCKET_LENGTH, Db, Repository} from "@lodestar/db";
 import {ValidatorIndex, phase0, ssz} from "@lodestar/types";
+import {bytesToInt} from "@lodestar/utils";
 import {Bucket, getBucketNameByValue} from "../buckets.js";
 
 export class ProposerSlashingRepository extends Repository<ValidatorIndex, phase0.ProposerSlashing> {
@@ -12,4 +13,8 @@ export class ProposerSlashingRepository extends Repository<ValidatorIndex, phase
   getId(value: phase0.ProposerSlashing): ValidatorIndex {
     return value.signedHeader1.message.proposerIndex;
   }
+
+  decodeKey(data: Uint8Array): ValidatorIndex {
+    return bytesToInt(data.subarray(BUCKET_LENGTH), "be");
+  }
 }

package/src/execution/engine/blobVersionedHashes.ts

@@ -0,0 +1,72 @@
+import {byteArrayEquals} from "@lodestar/utils";
+import {VersionedHashes} from "./interface.js";
+
+/**
+ * Preserve Deneb's is_valid_versioned_hashes check when the REST envelope omits expected hashes.
+ * EIP-4844 encodes blob_versioned_hashes at index 10 of the signed type-3 transaction's RLP list.
+ * Skip unrelated fields without decoding or copying them, including untrusted nested access lists.
+ * The EL remains responsible for the other transaction validity checks.
+ */
+export function isValidBlobVersionedHashes(transactions: Uint8Array[], expected: VersionedHashes): boolean {
+  let index = 0;
+  for (const transaction of transactions) {
+    if (transaction.length === 0) return false;
+    if (transaction[0] !== 0x03) continue;
+
+    const outer = readRlpItem(transaction, 1, transaction.length);
+    if (!outer?.isList || outer.end !== transaction.length) return false;
+
+    let offset = outer.start;
+    for (let fieldIndex = 0; fieldIndex < 14; fieldIndex++) {
+      const field = readRlpItem(transaction, offset, outer.end);
+      if (field === null) return false;
+      if (fieldIndex === 10) {
+        if (!field.isList) return false;
+        // A canonical RLP-encoded Bytes32 is exactly the 0xa0 prefix followed by 32 bytes.
+        const count = (field.end - field.start) / 33;
+        if (!Number.isInteger(count) || index + count > expected.length) return false;
+        for (let hashOffset = field.start; hashOffset < field.end; hashOffset += 33) {
+          if (
+            transaction[hashOffset] !== 0xa0 ||
+            !byteArrayEquals(transaction.subarray(hashOffset + 1, hashOffset + 33), expected[index])
+          ) {
+            return false;
+          }
+          index++;
+        }
+      }
+      offset = field.end;
+    }
+    if (offset !== outer.end) return false;
+  }
+  return index === expected.length;
+}
+
+/** Read one RLP item's boundaries without descending into lists. */
+function readRlpItem(
+  bytes: Uint8Array,
+  offset: number,
+  limit: number
+): {start: number; end: number; isList: boolean} | null {
+  if (offset >= limit) return null;
+  const prefix = bytes[offset];
+  if (prefix < 0x80) return {start: offset, end: offset + 1, isList: false};
+
+  const isList = prefix >= 0xc0;
+  const lengthCode = prefix - (isList ? 0xc0 : 0x80);
+  let start = offset + 1;
+  let length = lengthCode;
+  if (lengthCode > 55) {
+    const lengthBytes = lengthCode - 55;
+    start += lengthBytes;
+    if (start > limit || bytes[offset + 1] === 0) return null;
+    length = 0;
+    for (let i = offset + 1; i < start; i++) {
+      length = length * 256 + bytes[i];
+    }
+    if (length <= 55) return null;
+  }
+  if (length > limit - start) return null;
+  if (!isList && length === 1 && bytes[start] < 0x80) return null;
+  return {start, end: start + length, isList};
+}

package/src/execution/engine/disabled.ts

@@ -21,18 +21,10 @@ export class ExecutionEngineDisabled implements IExecutionEngine {
     throw Error("Execution engine disabled");
   }
 
-  getPayloadBodiesByHash(): Promise<never> {
-    throw Error("Execution engine disabled");
-  }
-
   getPayloadBodiesByHashV2(): Promise<never> {
     throw Error("Execution engine disabled");
   }
 
-  getPayloadBodiesByRange(): Promise<never> {
-    throw Error("Execution engine disabled");
-  }
-
   getBlobs(): Promise<never> {
     throw Error("Execution engine disabled");
   }