@lodestar/beacon-node 1.44.0-dev.6ef8199cfa → 1.44.0-dev.762dd5f186

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

@@ -11,7 +11,6 @@ import {
   SLOTS_PER_HISTORICAL_ROOT,
   isForkPostBellatrix,
   isForkPostDeneb,
-  isForkPostElectra,
   isForkPostFulu,
   isForkPostGloas,
 } from "@lodestar/params";
@@ -50,6 +49,7 @@ import {
   ProduceFullGloas,
 } from "../../../../chain/produceBlock/index.js";
 import {validateGossipBlock} from "../../../../chain/validation/block.js";
+import {validateApiExecutionPayloadBid} from "../../../../chain/validation/executionPayloadBid.js";
 import {validateApiExecutionPayloadEnvelope} from "../../../../chain/validation/executionPayloadEnvelope.js";
 import {OpSource} from "../../../../chain/validatorMonitor.js";
 import {
@@ -93,7 +93,7 @@ export function getBeaconBlockApi({
   ApiModules,
   "chain" | "config" | "metrics" | "network" | "db"
 >): ApplicationMethods<routes.beacon.block.Endpoints> {
-  const publishBlock: ApplicationMethods<routes.beacon.block.Endpoints>["publishBlockV2"] = async (
+  const publishBlockV2: ApplicationMethods<routes.beacon.block.Endpoints>["publishBlockV2"] = async (
     {signedBlockContents, broadcastValidation},
     _context,
     opts: PublishBlockOpts = {}
@@ -204,11 +204,19 @@ export function getBeaconBlockApi({
           try {
             await validateGossipBlock(config, chain, signedBlock, fork);
           } catch (error) {
-            if (error instanceof BlockGossipError && error.type.code === BlockErrorCode.ALREADY_KNOWN) {
-              chain.logger.debug("Ignoring known block during publishing", valLogMeta);
-              // Blocks might already be published by another node as part of a fallback setup or DVT cluster
-              // and can reach our node by gossip before the api. The error can be ignored and should not result in a 500 response.
-              return;
+            if (error instanceof BlockGossipError) {
+              switch (error.type.code) {
+                case BlockErrorCode.ALREADY_KNOWN:
+                  // 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;
+              }
             }
 
             chain.logger.error("Gossip validations failed while publishing the block", valLogMeta, error as Error);
@@ -397,8 +405,8 @@ export function getBeaconBlockApi({
     }
   };
 
-  const publishBlindedBlock: ApplicationMethods<routes.beacon.block.Endpoints>["publishBlindedBlock"] = async (
-    {signedBlindedBlock},
+  const publishBlindedBlockV2: ApplicationMethods<routes.beacon.block.Endpoints>["publishBlindedBlockV2"] = async (
+    {signedBlindedBlock, broadcastValidation},
     context,
     opts: PublishBlockOpts = {}
   ) => {
@@ -428,7 +436,7 @@ export function getBeaconBlockApi({
       );
 
       chain.logger.info("Publishing assembled block", {slot, blockRoot, source});
-      return publishBlock({signedBlockContents}, {...context, sszBytes: null}, opts);
+      return publishBlockV2({signedBlockContents, broadcastValidation}, {...context, sszBytes: null}, opts);
     }
 
     const source = ProducedBlockSource.builder;
@@ -454,7 +462,11 @@ export function getBeaconBlockApi({
       //
       // see: https://github.com/ChainSafe/lodestar/issues/5404
       chain.logger.info("Publishing assembled block", {slot, blockRoot, source});
-      return publishBlock({signedBlockContents}, {...context, sszBytes: null}, {...opts, ignoreIfKnown: true});
+      return publishBlockV2(
+        {signedBlockContents, broadcastValidation},
+        {...context, sszBytes: null},
+        {...opts, ignoreIfKnown: true}
+      );
     }
   };
 
@@ -589,23 +601,6 @@ export function getBeaconBlockApi({
       };
     },
 
-    async getBlockAttestations({blockId}) {
-      const {block, executionOptimistic, finalized} = await getBlockResponse(chain, blockId);
-      const fork = config.getForkName(block.message.slot);
-
-      if (isForkPostElectra(fork)) {
-        throw new ApiError(
-          400,
-          `Use getBlockAttestationsV2 to retrieve block attestations for post-electra fork=${fork}`
-        );
-      }
-
-      return {
-        data: block.message.body.attestations,
-        meta: {executionOptimistic, finalized},
-      };
-    },
-
     async getBlockAttestationsV2({blockId}) {
       const {block, executionOptimistic, finalized} = await getBlockResponse(chain, blockId);
       return {
@@ -653,16 +648,8 @@ export function getBeaconBlockApi({
       };
     },
 
-    publishBlock,
-    publishBlindedBlock,
-
-    async publishBlindedBlockV2(args, context, opts) {
-      await publishBlindedBlock(args, context, opts);
-    },
-
-    async publishBlockV2(args, context, opts) {
-      await publishBlock(args, context, opts);
-    },
+    publishBlockV2,
+    publishBlindedBlockV2,
 
     async publishExecutionPayloadEnvelope({signedExecutionPayloadEnvelope}) {
       const seenTimestampSec = Date.now() / 1000;
@@ -677,9 +664,20 @@ export function getBeaconBlockApi({
       }
 
       // TODO GLOAS: review checks, do we want to implement `broadcast_validation`?
-      const block = chain.forkChoice.getBlockHex(blockRootHex, PayloadStatus.EMPTY);
+      let block = chain.forkChoice.getBlockHex(blockRootHex, PayloadStatus.EMPTY);
       if (block === null) {
-        throw new ApiError(404, `Block not found for beacon block root ${blockRootHex}`);
+        // Only wait if the envelope is for the current slot
+        if (chain.clock.isCurrentSlotGivenGossipDisparity(slot)) {
+          chain.logger.debug("Execution payload envelope received before block, waiting for block to be imported", {
+            blockRoot: blockRootHex,
+            slot,
+          });
+          await chain.waitForBlock(slot, blockRootHex);
+          block = chain.forkChoice.getBlockHex(blockRootHex, PayloadStatus.EMPTY);
+        }
+        if (block === null) {
+          throw new ApiError(404, `Block not found for beacon block root ${blockRootHex}`);
+        }
       }
       if (block.slot !== slot) {
         throw new ApiError(400, `Envelope slot ${slot} does not match block slot ${block.slot}`);
@@ -726,10 +724,11 @@ export function getBeaconBlockApi({
         await sleep(msToBlockSlot);
       }
 
-      // TODO GLOAS: if block and payload are submitted in parallel, payloadInput may not yet exist.
-      // A queuing mechanism is needed to handle this case. See https://github.com/ChainSafe/lodestar/issues/8915
       const payloadInput = chain.seenPayloadEnvelopeInputCache.get(blockRootHex);
       if (!payloadInput) {
+        // The block is awaited above (queuing if the envelope arrived first), and both the API and
+        // gossip import paths seed the PayloadEnvelopeInput before importing the block, so the input
+        // should exist here.
         throw new ApiError(404, `PayloadEnvelopeInput not found for block root ${blockRootHex}`);
       }
 
@@ -825,6 +824,41 @@ export function getBeaconBlockApi({
       });
     },
 
+    async publishExecutionPayloadBid({signedExecutionPayloadBid}) {
+      const bid = signedExecutionPayloadBid.message;
+      const slot = bid.slot;
+      const fork = config.getForkName(slot);
+
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `publishExecutionPayloadBid not supported for pre-gloas fork=${fork}`);
+      }
+
+      await validateApiExecutionPayloadBid(chain, signedExecutionPayloadBid);
+
+      try {
+        const insertOutcome = chain.executionPayloadBidPool.add(signedExecutionPayloadBid);
+        metrics?.opPool.executionPayloadBidPool.apiInsertOutcome.inc({insertOutcome});
+      } catch (e) {
+        chain.logger.error("Error adding to executionPayloadBid pool", {}, e as Error);
+      }
+
+      const sentPeers = await network.publishSignedExecutionPayloadBid(signedExecutionPayloadBid);
+
+      chain.emitter.emit(routes.events.EventType.executionPayloadBid, {
+        version: fork,
+        data: signedExecutionPayloadBid,
+      });
+
+      chain.logger.info("Published execution payload bid", {
+        slot,
+        builderIndex: bid.builderIndex,
+        blockHash: toRootHex(bid.blockHash),
+        parentBlockHash: toRootHex(bid.parentBlockHash),
+        value: bid.value,
+        sentPeers,
+      });
+    },
+
     async getSignedExecutionPayloadEnvelope({blockId}, context) {
       const {block, executionOptimistic, finalized} = await getBlockResponse(chain, blockId);
       const slot = block.message.slot;

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

@@ -9,7 +9,7 @@ import {
   isForkPostGloas,
 } from "@lodestar/params";
 import {isStatePostAltair} from "@lodestar/state-transition";
-import {Attestation, Epoch, SingleAttestation, isElectraAttestation, ssz, sszTypesFor} from "@lodestar/types";
+import {Epoch, SingleAttestation, isElectraAttestation, ssz, sszTypesFor} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {
   AttestationError,
@@ -40,25 +40,6 @@ export function getBeaconPoolApi({
   network,
 }: Pick<ApiModules, "chain" | "logger" | "metrics" | "network">): ApplicationMethods<routes.beacon.pool.Endpoints> {
   return {
-    async getPoolAttestations({slot, committeeIndex}) {
-      // Already filtered by slot
-      let attestations: Attestation[] = chain.aggregatedAttestationPool.getAll(slot);
-      const fork = chain.config.getForkName(slot ?? chain.clock.currentSlot);
-
-      if (isForkPostElectra(fork)) {
-        throw new ApiError(
-          400,
-          `Use getPoolAttestationsV2 to retrieve pool attestations for post-electra fork=${fork}`
-        );
-      }
-
-      if (committeeIndex !== undefined) {
-        attestations = attestations.filter((attestation) => committeeIndex === attestation.data.index);
-      }
-
-      return {data: attestations};
-    },
-
     async getPoolAttestationsV2({slot, committeeIndex}) {
       // Already filtered by slot
       let attestations = chain.aggregatedAttestationPool.getAll(slot);
@@ -134,19 +115,6 @@ export function getBeaconPoolApi({
       }
     },
 
-    async getPoolAttesterSlashings() {
-      const fork = chain.config.getForkName(chain.clock.currentSlot);
-
-      if (isForkPostElectra(fork)) {
-        throw new ApiError(
-          400,
-          `Use getPoolAttesterSlashingsV2 to retrieve pool attester slashings for post-electra fork=${fork}`
-        );
-      }
-
-      return {data: chain.opPool.getAllAttesterSlashings()};
-    },
-
     async getPoolAttesterSlashingsV2() {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
       return {data: chain.opPool.getAllAttesterSlashings(), meta: {version: fork}};
@@ -164,10 +132,6 @@ export function getBeaconPoolApi({
       return {data: chain.opPool.getAllBlsToExecutionChanges().map(({data}) => data)};
     },
 
-    async submitPoolAttestations({signedAttestations}) {
-      await this.submitPoolAttestationsV2({signedAttestations});
-    },
-
     async submitPoolAttestationsV2({signedAttestations}) {
       const fork = chain.config.getForkName(chain.clock.currentSlot);
       const seenTimestampSec = Date.now() / 1000;
@@ -247,10 +211,6 @@ export function getBeaconPoolApi({
       }
     },
 
-    async submitPoolAttesterSlashings({attesterSlashing}) {
-      await this.submitPoolAttesterSlashingsV2({attesterSlashing});
-    },
-
     async submitPoolAttesterSlashingsV2({attesterSlashing}) {
       await validateApiAttesterSlashing(chain, attesterSlashing);
       const fork = chain.config.getForkName(Number(attesterSlashing.attestation1.data.slot));
@@ -328,8 +288,10 @@ export function getBeaconPoolApi({
 
             chain.forkChoice.notifyPtcMessages(
               toRootHex(payloadAttestationMessage.data.beaconBlockRoot),
+              payloadAttestationMessage.data.slot,
               validatorCommitteeIndices,
-              payloadAttestationMessage.data.payloadPresent
+              payloadAttestationMessage.data.payloadPresent,
+              payloadAttestationMessage.data.blobDataAvailable
             );
 
             await network.publishPayloadAttestationMessage(payloadAttestationMessage);

package/src/api/impl/config/constants.ts

@@ -5,6 +5,8 @@ import {
   BASE_REWARDS_PER_EPOCH,
   BLOB_TX_TYPE,
   BLS_WITHDRAWAL_PREFIX,
+  BUILDER_DEPOSIT_REQUEST_TYPE,
+  BUILDER_EXIT_REQUEST_TYPE,
   BUILDER_INDEX_FLAG,
   BUILDER_INDEX_SELF_BUILD,
   BUILDER_PAYMENT_THRESHOLD_DENOMINATOR,
@@ -21,6 +23,7 @@ import {
   DOMAIN_BEACON_BUILDER,
   DOMAIN_BEACON_PROPOSER,
   DOMAIN_BLS_TO_EXECUTION_CHANGE,
+  DOMAIN_BUILDER_DEPOSIT,
   DOMAIN_CONTRIBUTION_AND_PROOF,
   DOMAIN_DEPOSIT,
   DOMAIN_PROPOSER_PREFERENCES,
@@ -38,6 +41,7 @@ import {
   JUSTIFICATION_BITS_LENGTH,
   MAX_CONCURRENT_REQUESTS,
   NODE_ID_BITS,
+  PAYLOAD_BUILDER_VERSION,
   PROPOSER_WEIGHT,
   SYNC_COMMITTEE_SUBNET_COUNT,
   SYNC_REWARD_WEIGHT,
@@ -53,6 +57,7 @@ import {
   VERSIONED_HASH_VERSION_KZG,
   WEIGHT_DENOMINATOR,
   WITHDRAWAL_REQUEST_TYPE,
+  ZERO_HASH_HEX,
 } from "@lodestar/params";
 
 /**
@@ -69,6 +74,7 @@ export const specConstants = {
   DEPOSIT_CONTRACT_TREE_DEPTH,
   JUSTIFICATION_BITS_LENGTH,
   ENDIANNESS: "little",
+  EMPTY_BLOCK_HASH: ZERO_HASH_HEX,
   // ## Withdrawal prefixes
   BLS_WITHDRAWAL_PREFIX: toHexByte(BLS_WITHDRAWAL_PREFIX),
   ETH1_ADDRESS_WITHDRAWAL_PREFIX: toHexByte(ETH1_ADDRESS_WITHDRAWAL_PREFIX),
@@ -138,6 +144,10 @@ export const specConstants = {
   BUILDER_INDEX_SELF_BUILD,
   BUILDER_PAYMENT_THRESHOLD_NUMERATOR,
   BUILDER_PAYMENT_THRESHOLD_DENOMINATOR,
+  PAYLOAD_BUILDER_VERSION,
+  DOMAIN_BUILDER_DEPOSIT,
+  BUILDER_DEPOSIT_REQUEST_TYPE: toHexByte(BUILDER_DEPOSIT_REQUEST_TYPE),
+  BUILDER_EXIT_REQUEST_TYPE: toHexByte(BUILDER_EXIT_REQUEST_TYPE),
 };
 
 /** Convert single-byte numbers to hex strings for API spec compliance */

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

@@ -1,7 +1,8 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
-import {ExecutionStatus} from "@lodestar/fork-choice";
+import {ExecutionStatus, PayloadStatus} from "@lodestar/fork-choice";
 import {ForkPostDeneb, ZERO_HASH_HEX, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
+import {computeTimeAtSlot} from "@lodestar/state-transition";
 import {BeaconState, DataColumnSidecar, DataColumnSidecars, type SignedBeaconBlock, sszTypesFor} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
 import {getBlobKzgCommitments} from "../../../util/dataColumns.js";
@@ -12,6 +13,29 @@ import {getStateResponseWithRegen} from "../beacon/state/utils.js";
 import {ApiModules} from "../types.js";
 import {assertUniqueItems} from "../utils.js";
 
+function toForkChoiceValidity(status: ExecutionStatus): "valid" | "invalid" | "optimistic" {
+  switch (status) {
+    case ExecutionStatus.Valid:
+      return "valid";
+    case ExecutionStatus.Invalid:
+      return "invalid";
+    case ExecutionStatus.Syncing:
+    case ExecutionStatus.PreMerge:
+      return "optimistic";
+  }
+}
+
+function toPayloadStatusName(status: PayloadStatus): "pending" | "empty" | "full" {
+  switch (status) {
+    case PayloadStatus.PENDING:
+      return "pending";
+    case PayloadStatus.EMPTY:
+      return "empty";
+    case PayloadStatus.FULL:
+      return "full";
+  }
+}
+
 export function getDebugApi({
   chain,
   config,
@@ -40,23 +64,60 @@ export function getDebugApi({
             justifiedEpoch: node.justifiedEpoch,
             finalizedEpoch: node.finalizedEpoch,
             weight: node.weight,
-            validity: (() => {
-              switch (node.executionStatus) {
-                case ExecutionStatus.Valid:
-                  return "valid";
-                case ExecutionStatus.Invalid:
-                  return "invalid";
-                case ExecutionStatus.Syncing:
-                case ExecutionStatus.PreMerge:
-                  return "optimistic";
-              }
-            })(),
+            validity: toForkChoiceValidity(node.executionStatus),
             executionBlockHash: node.executionPayloadBlockHash ?? ZERO_HASH_HEX,
           })),
         },
       };
     },
 
+    async getDebugForkChoiceV2() {
+      const {forkChoice} = chain;
+      return {
+        data: {
+          justifiedCheckpoint: forkChoice.getJustifiedCheckpoint(),
+          finalizedCheckpoint: forkChoice.getFinalizedCheckpoint(),
+          forkChoiceNodes: forkChoice.getAllNodes().map((node) => {
+            // Payload-specific fields apply only to a revealed Gloas payload = the FULL variant of a
+            // Gloas block
+            const ptc = node.payloadStatus === PayloadStatus.FULL ? forkChoice.getPTCVoteCounts(node.blockRoot) : null;
+            return {
+              payloadStatus: toPayloadStatusName(node.payloadStatus),
+              slot: node.slot,
+              blockRoot: node.blockRoot,
+              parentRoot: node.parentRoot,
+              weight: node.weight,
+              validity: toForkChoiceValidity(node.executionStatus),
+              executionBlockHash: node.executionPayloadBlockHash ?? ZERO_HASH_HEX,
+              extraData: {
+                executionOptimistic: isOptimisticBlock(node),
+                timestamp: computeTimeAtSlot(config, node.slot, chain.genesisTime),
+                target: node.targetRoot,
+                justifiedEpoch: node.justifiedEpoch,
+                finalizedEpoch: node.finalizedEpoch,
+                unrealizedJustifiedEpoch: node.unrealizedJustifiedEpoch,
+                unrealizedFinalizedEpoch: node.unrealizedFinalizedEpoch,
+                payloadAttesterCount: ptc?.attesterCount ?? null,
+                payloadAvailabilityYesCount: ptc?.payloadPresentCount ?? null,
+                payloadDataAvailabilityYesCount: ptc?.dataAvailableCount ?? null,
+                gasLimit:
+                  node.payloadStatus === PayloadStatus.FULL && "executionPayloadGasLimit" in node
+                    ? node.executionPayloadGasLimit
+                    : null,
+              },
+            };
+          }),
+          extraData: {
+            unrealizedJustifiedCheckpoint: forkChoice.getUnrealizedJustifiedCheckpoint(),
+            unrealizedFinalizedCheckpoint: forkChoice.getUnrealizedFinalizedCheckpoint(),
+            proposerBoostRoot: forkChoice.getProposerBoostRoot(),
+            previousProposerBoostRoot: forkChoice.getPreviousProposerBoostRoot(),
+            headRoot: forkChoice.getHeadRoot(),
+          },
+        },
+      };
+    },
+
     async getProtoArrayNodes() {
       const nodes = chain.forkChoice.getAllNodes().map((node) => ({
         // if node has executionPayloadNumber, it will overwrite the below default

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

@@ -280,6 +280,36 @@ export function getLodestarApi({
       };
     },
 
+    async getFastConfirmationInfo() {
+      const confirmedRoot = chain.forkChoice.getConfirmedRoot();
+      const confirmedBlock = chain.forkChoice.getConfirmedBlock();
+      const justifiedCheckpoint = chain.forkChoice.getJustifiedCheckpoint();
+      const finalizedCheckpoint = chain.forkChoice.getFinalizedCheckpoint();
+      const headRoot = chain.forkChoice.getHeadRoot();
+      const head = chain.forkChoice.getHead();
+
+      return {
+        data: {
+          confirmed: {
+            rootHex: confirmedRoot,
+            slot: confirmedBlock?.slot ?? null,
+          },
+          head: {
+            rootHex: headRoot,
+            slot: head.slot,
+          },
+          justifiedCheckpoint: {
+            rootHex: justifiedCheckpoint.rootHex,
+            epoch: justifiedCheckpoint.epoch,
+          },
+          finalizedCheckpoint: {
+            rootHex: finalizedCheckpoint.rootHex,
+            epoch: finalizedCheckpoint.epoch,
+          },
+        },
+      };
+    },
+
     async getAttesterSlashingsFromBlocks({signedBlocks}) {
       const attestations = new Map<Epoch, Attestation[]>();