chore: integrate peerdas-kzg

packages/beacon-node/package.json

@@ -105,6 +105,7 @@
     "@chainsafe/prometheus-gc-stats": "^1.0.0",
     "@chainsafe/ssz": "^0.17.0",
     "@chainsafe/threads": "^1.11.1",
+    "@crate-crypto/node-eth-kzg": "0.4.1",
     "@ethersproject/abi": "^5.7.0",
     "@fastify/bearer-auth": "^9.0.0",
     "@fastify/cors": "^8.2.1",
@@ -167,4 +168,4 @@
     "beacon",
     "blockchain"
   ]
-}
+}

packages/beacon-node/src/network/peers/discover.ts

@@ -23,6 +23,8 @@ const MAX_CACHED_ENRS = 100;
 /** Max age a cached ENR will be considered for dial */
 const MAX_CACHED_ENR_AGE_MS = 5 * 60 * 1000;
 
+const MAX_CACHED_NODEIDS = 10000;
+
 export type PeerDiscoveryOpts = {
   maxPeers: number;
   discv5FirstQueryDelayMs: number;
@@ -354,6 +356,11 @@ export class PeerDiscovery {
     }
     // async due to some crypto that's no longer necessary
     const peerId = await enr.peerId();
+
+    const nodeId = fromHexString(enr.nodeId);
+    this.peerIdToNodeId.set(peerId.toString(), nodeId);
+    pruneSetToMax(this.peerIdToNodeId, MAX_CACHED_NODEIDS);
+
     // tcp multiaddr is known to be be present, checked inside the worker
     const multiaddrTCP = enr.getLocationMultiaddr(ENRKey.tcp);
     if (!multiaddrTCP) {

packages/beacon-node/src/network/peers/peerManager.ts

@@ -675,6 +675,7 @@ export class PeerManager {
       agentVersion: null,
       agentClient: null,
       encodingPreference: null,
+      custodySubnetCount,
     };
     this.connectedPeers.set(remotePeer.toString(), peerData);
 

packages/beacon-node/src/network/peers/peersData.ts

@@ -24,6 +24,7 @@ export type PeerData = {
   agentVersion: string | null;
   agentClient: ClientKind | null;
   encodingPreference: Encoding | null;
+  custodySubnetCount: number | null;
 };
 
 /**

packages/beacon-node/src/util/kzg.ts

@@ -1,13 +1,20 @@
 import path from "node:path";
 import fs from "node:fs";
 import {fileURLToPath} from "node:url";
+import {ProverContextJs, VerifierContextJs} from "@crate-crypto/peerdas-kzg";
 import {fromHex, toHex} from "@lodestar/utils";
 
 /* eslint-disable @typescript-eslint/naming-convention */
 
 // "c-kzg" has hardcoded the mainnet value, do not use params
 export const FIELD_ELEMENTS_PER_BLOB_MAINNET = 4096;
 
+// A constant to switch between the two libraries at compile time
+declare let USE_PEERDAS_KZG: boolean | undefined;
+if (typeof USE_PEERDAS_KZG === "undefined") {
+  USE_PEERDAS_KZG = false; // use c-kzg by default, if the constant is not set
+}
+
 function ckzgNotLoaded(): never {
   throw Error("c-kzg library not loaded");
 }
@@ -19,9 +26,12 @@ export let ckzg: {
   computeBlobKzgProof(blob: Uint8Array, commitment: Uint8Array): Uint8Array;
   verifyBlobKzgProof(blob: Uint8Array, commitment: Uint8Array, proof: Uint8Array): boolean;
   verifyBlobKzgProofBatch(blobs: Uint8Array[], expectedKzgCommitments: Uint8Array[], kzgProofs: Uint8Array[]): boolean;
+  // TODO:This is deprecated
   computeCells(blob: Uint8Array): Uint8Array[];
   computeCellsAndKzgProofs(blob: Uint8Array): [Uint8Array[], Uint8Array[]];
+  // TODO:This is deprecated
   cellsToBlob(cells: Uint8Array[]): Uint8Array;
+  // TODO:This is deprecated
   recoverAllCells(cellIds: number[], cells: Uint8Array[]): Uint8Array[];
   verifyCellKzgProof(commitmentBytes: Uint8Array, cellId: number, cell: Uint8Array, proofBytes: Uint8Array): boolean;
   verifyCellKzgProofBatch(
@@ -60,6 +70,10 @@ const G1POINT_COUNT = FIELD_ELEMENTS_PER_BLOB_MAINNET;
 const G2POINT_COUNT = 65;
 const TOTAL_SIZE = 2 * POINT_COUNT_BYTES + G1POINT_BYTES * G1POINT_COUNT + G2POINT_BYTES * G2POINT_COUNT;
 
+// TODO: We can think of a better way to initialize this
+let proverContext: ProverContextJs;
+let verifierContext: VerifierContextJs;
+
 export async function initCKZG(): Promise<void> {
   /* eslint-disable @typescript-eslint/ban-ts-comment */
   // @ts-ignore
@@ -83,6 +97,8 @@ export function loadEthereumTrustedSetup(
   filePath?: string
 ): void {
   try {
+    proverContext = new ProverContextJs();
+    verifierContext = new VerifierContextJs();
     let setupFilePath;
     if (mode === TrustedFileMode.Bin) {
       const binPath = filePath ?? TRUSTED_SETUP_BIN_FILEPATH;
@@ -183,3 +199,28 @@ function strip0xPrefix(hex: string): string {
     return hex;
   }
 }
+
+export function computeCellsAndKzgProofs(blob: Uint8Array): [Uint8Array[], Uint8Array[]] {
+  if (USE_PEERDAS_KZG) {
+    const cellsAndProofs = proverContext.computeCellsAndKzgProofs(blob);
+    return [cellsAndProofs.cells, cellsAndProofs.proofs];
+  } else {
+    return ckzg.computeCellsAndKzgProofs(blob);
+  }
+}
+
+// This API is not correct imo, its concatenating all of the proofs and cells, which is a c-kzg
+// specific thing.
+// export function verifyCellKzgProofBatch(
+//   commitmentsBytes: Uint8Array[],
+//   rowIndices: number[],
+//   columnIndices: number[],
+//   cells: Uint8Array[],
+//   proofsBytes: Uint8Array[]
+// ): boolean {
+//   if (USE_PEERDAS_KZG) {
+//      return verifierContext.verifyCellKzgProofBatch(commitmentsBytes, rowIndices, columnIndices, cells, proofsBytes)
+//   } else {
+//     return ckzg.verifyCellKzgProofBatch(commitmentsBytes, rowIndices, columnIndices, cells, proofsBytes);
+//   }
+// }

packages/cli/src/cmds/beacon/initPeerIdAndEnr.ts

@@ -87,6 +87,7 @@ export function overwriteEnrWithCliArgs(
     maybeUpdateEnr(enr, "tcp", args["enr.tcp"] ?? port ?? enr.tcp);
     maybeUpdateEnr(enr, "tcp6", args["enr.tcp6"] ?? port6 ?? enr.tcp6);
   }
+  enr.set("custody_subnet_count", ssz.UintNum64.serialize(config.CUSTODY_REQUIREMENT));
 
   // csc is big ending but since 1 bytes suffices for now so its the same
   enr.set("csc", ssz.Uint8.serialize(Math.max(config.CUSTODY_REQUIREMENT, config.NODE_CUSTODY_REQUIREMENT)));

packages/types/src/types.ts

@@ -164,6 +164,40 @@ type TypesByFork = {
     SyncCommittee: altair.SyncCommittee;
     SyncAggregate: altair.SyncAggregate;
   };
+  [ForkName.electra]: {
+    BeaconBlockHeader: phase0.BeaconBlockHeader;
+    SignedBeaconBlockHeader: phase0.SignedBeaconBlockHeader;
+    BeaconBlock: electra.BeaconBlock;
+    BeaconBlockBody: electra.BeaconBlockBody;
+    BeaconState: electra.BeaconState;
+    SignedBeaconBlock: electra.SignedBeaconBlock;
+    Metadata: altair.Metadata;
+    LightClientHeader: electra.LightClientHeader;
+    LightClientBootstrap: electra.LightClientBootstrap;
+    LightClientUpdate: electra.LightClientUpdate;
+    LightClientFinalityUpdate: electra.LightClientFinalityUpdate;
+    LightClientOptimisticUpdate: electra.LightClientOptimisticUpdate;
+    LightClientStore: electra.LightClientStore;
+    BlindedBeaconBlock: electra.BlindedBeaconBlock;
+    BlindedBeaconBlockBody: electra.BlindedBeaconBlockBody;
+    SignedBlindedBeaconBlock: electra.SignedBlindedBeaconBlock;
+    ExecutionPayload: electra.ExecutionPayload;
+    ExecutionPayloadHeader: electra.ExecutionPayloadHeader;
+    BuilderBid: electra.BuilderBid;
+    SignedBuilderBid: electra.SignedBuilderBid;
+    SSEPayloadAttributes: electra.SSEPayloadAttributes;
+    BlockContents: {block: BeaconBlock<ForkName.electra>; kzgProofs: deneb.KZGProofs; blobs: deneb.Blobs};
+    SignedBlockContents: {
+      signedBlock: SignedBeaconBlock<ForkName.electra>;
+      kzgProofs: deneb.KZGProofs;
+      blobs: deneb.Blobs;
+    };
+    ExecutionPayloadAndBlobsBundle: deneb.ExecutionPayloadAndBlobsBundle;
+    BlobsBundle: deneb.BlobsBundle;
+    Contents: deneb.Contents;
+    SyncCommittee: altair.SyncCommittee;
+    SyncAggregate: altair.SyncAggregate;
+  };
 };
 
 export type TypesFor<F extends ForkName, K extends keyof TypesByFork[F] | void = void> = K extends void