@lodestar/beacon-node 1.47.0-dev.d2f4b96574 → 1.47.0-dev.d79d81f994

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.47.0-dev.d2f4b96574",
+  "version": "1.47.0-dev.d79d81f994",
   "type": "module",
   "exports": {
     ".": {
@@ -100,51 +100,51 @@
     "check-readme": "pnpm exec tsx ../../scripts/check_readme.ts"
   },
   "dependencies": {
-    "@chainsafe/as-sha256": "^1.2.4",
-    "@chainsafe/blst": "^2.2.0",
+    "@chainsafe/as-sha256": "^1.2.5",
     "@chainsafe/discv5": "^12.0.2",
     "@chainsafe/enr": "^6.0.2",
     "@chainsafe/libp2p-noise": "^17.0.0",
     "@chainsafe/libp2p-quic": "^2.1.3",
-    "@chainsafe/persistent-merkle-tree": "^1.3.0",
+    "@chainsafe/lodestar-z": "catalog:",
+    "@chainsafe/persistent-merkle-tree": "^1.3.1",
     "@chainsafe/prometheus-gc-stats": "^1.0.0",
     "@chainsafe/snappy-wasm": "^0.5.0",
-    "@chainsafe/ssz": "^1.6.2",
+    "@chainsafe/ssz": "^1.6.3",
     "@chainsafe/threads": "^1.11.3",
     "@crate-crypto/node-eth-kzg": "0.9.1",
     "@fastify/bearer-auth": "^10.0.1",
     "@fastify/cors": "^10.0.1",
     "@fastify/swagger": "^9.0.0",
     "@fastify/swagger-ui": "^5.0.1",
-    "@libp2p/bootstrap": "^12.0.14",
-    "@libp2p/crypto": "^5.1.13",
-    "@libp2p/gossipsub": "^16.0.2",
-    "@libp2p/identify": "^4.0.13",
-    "@libp2p/interface": "^3.1.0",
-    "@libp2p/mdns": "^12.0.14",
-    "@libp2p/mplex": "^12.0.14",
-    "@libp2p/peer-id": "^6.0.4",
-    "@libp2p/prometheus-metrics": "^5.0.14",
-    "@libp2p/tcp": "^11.0.13",
-    "@lodestar/api": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/config": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/db": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/fork-choice": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/logger": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/params": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/reqresp": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/state-transition": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/types": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/utils": "^1.47.0-dev.d2f4b96574",
-    "@lodestar/validator": "^1.47.0-dev.d2f4b96574",
+    "@libp2p/bootstrap": "^12.0.30",
+    "@libp2p/crypto": "^5.1.23",
+    "@libp2p/gossipsub": "^17.1.0",
+    "@libp2p/identify": "^4.1.13",
+    "@libp2p/interface": "^3.3.0",
+    "@libp2p/mdns": "^12.0.30",
+    "@libp2p/mplex": "^12.0.30",
+    "@libp2p/peer-id": "^6.0.15",
+    "@libp2p/prometheus-metrics": "^5.0.28",
+    "@libp2p/tcp": "^11.0.27",
+    "@lodestar/api": "^1.47.0-dev.d79d81f994",
+    "@lodestar/config": "^1.47.0-dev.d79d81f994",
+    "@lodestar/db": "^1.47.0-dev.d79d81f994",
+    "@lodestar/fork-choice": "^1.47.0-dev.d79d81f994",
+    "@lodestar/logger": "^1.47.0-dev.d79d81f994",
+    "@lodestar/params": "^1.47.0-dev.d79d81f994",
+    "@lodestar/reqresp": "^1.47.0-dev.d79d81f994",
+    "@lodestar/state-transition": "^1.47.0-dev.d79d81f994",
+    "@lodestar/types": "^1.47.0-dev.d79d81f994",
+    "@lodestar/utils": "^1.47.0-dev.d79d81f994",
+    "@lodestar/validator": "^1.47.0-dev.d79d81f994",
     "@multiformats/multiaddr": "^13.0.1",
-    "datastore-core": "^11.0.2",
-    "datastore-level": "^12.0.2",
+    "datastore-core": "^12.0.1",
+    "datastore-level": "^13.0.1",
     "deepmerge": "^4.3.1",
     "fastify": "^5.8.1",
-    "interface-datastore": "^9.0.2",
+    "interface-datastore": "^10.0.1",
     "jwt-simple": "0.5.6",
-    "libp2p": "3.1.6",
+    "libp2p": "3.3.9",
     "multiformats": "^13.4.2",
     "prom-client": "^15.1.0",
     "qs": "^6.14.2",
@@ -155,10 +155,10 @@
   },
   "devDependencies": {
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@libp2p/interface-internal": "^3.0.13",
-    "@libp2p/logger": "^6.2.2",
-    "@libp2p/utils": "^7.0.13",
-    "@lodestar/spec-test-util": "^1.47.0-dev.d2f4b96574",
+    "@libp2p/interface-internal": "^3.1.12",
+    "@libp2p/logger": "^6.2.13",
+    "@libp2p/utils": "^7.4.0",
+    "@lodestar/spec-test-util": "^1.47.0-dev.d79d81f994",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
@@ -175,5 +175,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "2675cce1f22601a540e3e8c5c3a3b2cae426f5d9"
+  "gitHead": "a24de7c608b912e980422a572b34ada1eec7c023"
 }

package/src/api/impl/beacon/blocks/index.ts

@@ -104,8 +104,8 @@ export function getBeaconBlockApi({
   "chain" | "config" | "metrics" | "network" | "db"
 >): ApplicationMethods<routes.beacon.block.Endpoints> {
   const publishBlockV2: ApplicationMethods<routes.beacon.block.Endpoints>["publishBlockV2"] = async (
-    {signedBlockContents, broadcastValidation},
-    _context,
+    {signedBlockContents, broadcastValidation, builderUrl},
+    context,
     opts: PublishBlockOpts = {}
   ) => {
     const seenTimestampSec = Date.now() / 1000;
@@ -128,7 +128,8 @@ export function getBeaconBlockApi({
         forkName: fork,
         sampledColumns: chain.custodyConfig.sampledColumns,
         custodyColumns: chain.custodyConfig.custodyColumns,
-        timeCreatedSec: seenTimestampSec,
+        seenTimestampSec,
+        source: PayloadEnvelopeInputSource.api,
       });
     }
 
@@ -208,6 +209,12 @@ export function getBeaconBlockApi({
     const blockLocallyProduced = chain.blockProductionCache.has(blockRoot);
     const valLogMeta = {slot, blockRoot, bodyRoot, broadcastValidation, blockLocallyProduced};
 
+    if (chain.forkChoice.hasBlockHex(blockRoot)) {
+      // Block was already imported, e.g. published again by the validator client or received via gossip
+      chain.logger.debug("Ignoring already-known block during publishing", valLogMeta);
+      return;
+    }
+
     switch (broadcastValidation) {
       case routes.beacon.BroadcastValidation.gossip: {
         if (!blockLocallyProduced) {
@@ -220,12 +227,6 @@ export function getBeaconBlockApi({
                   // Block has already been seen, e.g. via gossip racing the publish API. Benign.
                   chain.logger.debug("Ignoring already-known block during publishing", valLogMeta);
                   return;
-                case BlockErrorCode.REPEAT_PROPOSAL:
-                  // The proposer already produced a block for this slot. For a solo setup this is a
-                  // notable signal (duplicate-proposal attempt). For fallback / DVT setups it is
-                  // expected on every block where another node published first.
-                  chain.logger.warn("Ignoring repeat-proposal block during publishing", valLogMeta);
-                  return;
               }
             }
 
@@ -361,6 +362,24 @@ export function getBeaconBlockApi({
     chain.validatorMonitor?.registerBeaconBlock(OpSource.api, delaySec, signedBlock.message);
 
     chain.logger.info("Publishing block", valLogMeta);
+
+    // Forward the signed block to the winning builder echoed by the validator client so it can
+    // help disseminate the block and learn that its bid won without waiting for block gossip.
+    // Failures are non-fatal, the builder also sees the block on gossip.
+    if (isForkPostGloas(fork) && builderUrl !== undefined) {
+      const gloasBlock = signedBlock as SignedBeaconBlock<ForkPostGloas>;
+      if (gloasBlock.message.body.signedExecutionPayloadBid.message.builderIndex !== BUILDER_INDEX_SELF_BUILD) {
+        chain.builderApiClient
+          .submitSignedBeaconBlock(builderUrl, {data: gloasBlock, bytes: context?.sszBytes ?? undefined})
+          .then(() => {
+            chain.logger.debug("Submitted signed block to builder", {slot, builderUrl});
+          })
+          .catch((e) => {
+            chain.logger.warn("Failed to submit signed block to builder", {...valLogMeta, builderUrl}, e);
+          });
+      }
+    }
+
     const publishPromises = [
       // Send the block, regardless of whether or not it is valid. The API
       // specification is very clear that this is the desired behavior.
@@ -379,16 +398,20 @@ export function getBeaconBlockApi({
         chain
           .processBlock(blockForImport, opts)
           .catch((e) => {
-            if (
-              e instanceof BlockError &&
-              (e.type.code === BlockErrorCode.PARENT_BLOCK_UNKNOWN ||
-                e.type.code === BlockErrorCode.PARENT_PAYLOAD_UNKNOWN)
-            ) {
-              chain.emitter.emit(ChainEvent.blockUnknownParent, {
-                blockInput: blockForImport,
-                peer: IDENTITY_PEER_ID,
-                source: BlockInputSource.api,
-              });
+            if (e instanceof BlockError) {
+              switch (e.type.code) {
+                case BlockErrorCode.ALREADY_KNOWN:
+                  // Block was imported while publishing, e.g. received via gossip
+                  chain.logger.debug("Ignoring already-known block during publishing", valLogMeta);
+                  return;
+                case BlockErrorCode.PARENT_BLOCK_UNKNOWN:
+                case BlockErrorCode.PARENT_PAYLOAD_UNKNOWN:
+                  chain.emitter.emit(ChainEvent.blockUnknownParent, {
+                    blockInput: blockForImport,
+                    peer: IDENTITY_PEER_ID,
+                    source: BlockInputSource.api,
+                  });
+              }
             }
             throw e;
           }),
@@ -407,7 +430,7 @@ export function getBeaconBlockApi({
       for (let i = 0; i < dataColumnSidecars.length; i++) {
         // + 1 because we publish to beacon_block first
         const {sentPeers, alreadyPublished} = sentPeersArr[i + 1] as {sentPeers: number; alreadyPublished: boolean};
-        // sent peers could be 0 as we set `allowPublishToZeroTopicPeers=true` in network.publishDataColumnSidecar()
+        // sent peers could be 0, data_column_sidecar opts out of the zero peers publish error, see gossipTopicAllowPublishToZeroPeers
         metrics?.dataColumns.sentPeersPerSubnet.observe(sentPeers);
         // A duplicate publish (alreadyPublished=true) means the column is already propagating on the network —
         // expected in self-build flows where peers gossip columns back to us before we publish the envelope.
@@ -1032,6 +1055,7 @@ export function getBeaconBlockApi({
     },
 
     async publishExecutionPayloadBid({signedExecutionPayloadBid}) {
+      const seenTimestampSec = Date.now() / 1000;
       const bid = signedExecutionPayloadBid.message;
       const slot = bid.slot;
       const fork = config.getForkName(slot);
@@ -1040,10 +1064,20 @@ export function getBeaconBlockApi({
         throw new ApiError(400, `publishExecutionPayloadBid not supported for pre-gloas fork=${fork}`);
       }
 
+      const validationTimer = metrics?.opPool.executionPayloadBidPool.apiValidationTime.startTimer();
+      // TODO: once the builder is tested and can be trusted, skip this local validation
+      // to publish faster, accepting peer-score risk if it ever emits an invalid bid.
       await validateApiExecutionPayloadBid(chain, signedExecutionPayloadBid);
+      validationTimer?.();
+
+      const elapsedSec = chain.clock.secFromSlot(slot, seenTimestampSec);
+      metrics?.gossipExecutionPayloadBid.elapsedTimeTillReceived.observe({source: OpSource.api}, elapsedSec);
 
       try {
-        const insertOutcome = chain.executionPayloadBidPool.add(signedExecutionPayloadBid);
+        const insertOutcome = chain.executionPayloadBidPool.add(
+          signedExecutionPayloadBid,
+          Math.floor(elapsedSec * 1000)
+        );
         metrics?.opPool.executionPayloadBidPool.apiInsertOutcome.inc({insertOutcome});
       } catch (e) {
         chain.logger.error("Error adding to executionPayloadBid pool", {}, e as Error);

package/src/api/impl/beacon/pool/index.ts

@@ -25,6 +25,7 @@ import {validateApiPayloadAttestationMessage} from "../../../../chain/validation
 import {validateApiProposerSlashing} from "../../../../chain/validation/proposerSlashing.js";
 import {validateApiSyncCommittee} from "../../../../chain/validation/syncCommittee.js";
 import {validateApiVoluntaryExit} from "../../../../chain/validation/voluntaryExit.js";
+import {OpSource} from "../../../../chain/validatorMonitor.js";
 import {validateGossipFnRetryUnknownRoot} from "../../../../network/processor/gossipHandlers.js";
 import {ApiError, FailureList, IndexedError} from "../../errors.js";
 import {ApiModules} from "../../types.js";
@@ -99,7 +100,9 @@ export function getBeaconPoolApi({
             const {indexedAttestation, subnet, attDataRootHex, committeeIndex, validatorCommitteeIndex, committeeSize} =
               await validateGossipFnRetryUnknownRoot(validateFn, network, chain, slot, beaconBlockRoot);
 
-            if (network.shouldAggregate(subnet, slot)) {
+            try {
+              // `is_aggregator` only covers aggregating what we receive on the subnet via gossip, not what
+              // a validator client hands us directly, see https://github.com/ChainSafe/lodestar/issues/7548
               const insertOutcome = chain.attestationPool.add(
                 committeeIndex,
                 attestation,
@@ -109,6 +112,10 @@ export function getBeaconPoolApi({
                 priority
               );
               metrics?.opPool.attestationPool.apiInsertOutcome.inc({insertOutcome});
+            } catch (e) {
+              // The pool is a local optimization, failing to insert must not stop us from publishing a
+              // validated attestation, which the route requires us to do. Same handling as the gossip path
+              logger.debug("Error adding unaggregated attestation to pool", {subnet}, e as Error);
             }
 
             if (isForkPostElectra(fork)) {
@@ -172,7 +179,21 @@ export function getBeaconPoolApi({
     },
 
     async submitPoolVoluntaryExit({signedVoluntaryExit}) {
-      await validateApiVoluntaryExit(chain, signedVoluntaryExit);
+      const result = await validateApiVoluntaryExit(chain, signedVoluntaryExit);
+
+      if (result.status === "deferred") {
+        const currentEpoch = chain.clock.currentEpoch;
+        const inserted = chain.deferredVoluntaryExitPool.insert(signedVoluntaryExit, result.validity, currentEpoch);
+        if (!inserted) {
+          throw new ApiError(400, "Deferred voluntary exit pool is full or already contains this validator");
+        }
+        logger.info("Voluntary exit deferred until transient conditions are met", {
+          validatorIndex: signedVoluntaryExit.message.validatorIndex,
+          reason: result.validity,
+        });
+        return;
+      }
+
       chain.opPool.insertVoluntaryExit(signedVoluntaryExit);
       chain.emitter.emit(routes.events.EventType.voluntaryExit, signedVoluntaryExit);
       await network.publishVoluntaryExit(signedVoluntaryExit);
@@ -211,6 +232,7 @@ export function getBeaconPoolApi({
     },
 
     async submitPayloadAttestationMessages({payloadAttestationMessages}) {
+      const seenTimestampSec = Date.now() / 1000;
       const failures: FailureList = [];
 
       await Promise.all(
@@ -226,6 +248,9 @@ export function getBeaconPoolApi({
               beaconBlockRoot
             );
 
+            const delaySec = chain.clock.secFromSlot(slot, seenTimestampSec);
+            metrics?.gossipPayloadAttestationMessage.elapsedTimeTillReceived.observe({source: OpSource.api}, delaySec);
+
             const insertOutcome = chain.payloadAttestationPool.add(
               payloadAttestationMessage,
               attDataRootHex,

package/src/api/impl/beacon/state/utils.ts

@@ -1,7 +1,8 @@
+import {type PubkeyCache} from "@chainsafe/lodestar-z/pubkeys";
 import {routes} from "@lodestar/api";
 import {CheckpointWithHex, IForkChoice} from "@lodestar/fork-choice";
 import {GENESIS_SLOT} from "@lodestar/params";
-import {IBeaconStateView, IBeaconStateViewGloas, PubkeyCache} from "@lodestar/state-transition";
+import {IBeaconStateView, IBeaconStateViewGloas} from "@lodestar/state-transition";
 import {
   BLSPubkey,
   BuilderIndex,

package/src/api/impl/events/index.ts

@@ -4,7 +4,8 @@ import {ApiModules} from "../types.js";
 
 export function getEventsApi({
   chain,
-}: Pick<ApiModules, "chain" | "config">): ApplicationMethods<routes.events.Endpoints> {
+  logger,
+}: Pick<ApiModules, "chain" | "config" | "logger">): ApplicationMethods<routes.events.Endpoints> {
   return {
     async eventstream({topics, signal, onEvent}) {
       const onAbortFns: (() => void)[] = [];
@@ -12,9 +13,16 @@ export function getEventsApi({
       for (const topic of topics) {
         // biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
         const handler = (data: any): void => {
-          // TODO: What happens if this handler throws? Does it break the other chain.emitter listeners?
-
-          onEvent({type: topic, message: data});
+          try {
+            // TS only relates `{type, message}` to the `BeaconEvent` discriminated union while
+            // `EventType` stays within its ~25-member cap; without the cast, adding events trips TS2345.
+            onEvent({type: topic, message: data} as routes.events.BeaconEvent);
+          } catch (e) {
+            // `chain.emitter` emits synchronously, a throwing listener would propagate the error to
+            // whoever emitted the event, e.g. a gossip handler, and skip the remaining listeners.
+            // A single misbehaving event or client must not affect the node or other subscribers.
+            logger.warn("Error sending event to client", {topic}, e as Error);
+          }
         };
 
         chain.emitter.on(topic, handler);

package/src/api/impl/lodestar/index.ts

@@ -147,7 +147,7 @@ export function getLodestarApi({
     },
 
     async dropStateCache() {
-      chain.regen.dropCache();
+      await chain.regen.dropCache();
     },
 
     async connectPeer({peerId, multiaddrs}) {
@@ -280,7 +280,7 @@ export function getLodestarApi({
     },
 
     async getFastConfirmationInfo() {
-      const confirmedRoot = chain.forkChoice.getConfirmedRoot();
+      const fcrStore = chain.forkChoice.getFastConfirmationStore();
       const confirmedBlock = chain.forkChoice.getConfirmedBlock();
       const justifiedCheckpoint = chain.forkChoice.getJustifiedCheckpoint();
       const finalizedCheckpoint = chain.forkChoice.getFinalizedCheckpoint();
@@ -290,21 +290,20 @@ export function getLodestarApi({
       return {
         data: {
           confirmed: {
-            rootHex: confirmedRoot,
-            slot: confirmedBlock?.slot ?? null,
+            root: fromHex(fcrStore.confirmedRoot),
+            slot: confirmedBlock?.slot ?? 0,
           },
           head: {
-            rootHex: headRoot,
+            root: fromHex(headRoot),
             slot: head.slot,
           },
-          justifiedCheckpoint: {
-            rootHex: justifiedCheckpoint.rootHex,
-            epoch: justifiedCheckpoint.epoch,
-          },
-          finalizedCheckpoint: {
-            rootHex: finalizedCheckpoint.rootHex,
-            epoch: finalizedCheckpoint.epoch,
-          },
+          justifiedCheckpoint,
+          finalizedCheckpoint,
+          previousEpochObservedJustifiedCheckpoint: fcrStore.previousEpochObservedJustifiedCheckpoint,
+          currentEpochObservedJustifiedCheckpoint: fcrStore.currentEpochObservedJustifiedCheckpoint,
+          previousEpochGreatestUnrealizedCheckpoint: fcrStore.previousEpochGreatestUnrealizedCheckpoint,
+          previousSlotHead: fromHex(fcrStore.previousSlotHead),
+          currentSlotHead: fromHex(fcrStore.currentSlotHead),
         },
       };
     },