@lodestar/beacon-node 1.41.0-dev.eb7efb2b90 → 1.41.0-dev.f225223000

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.41.0-dev.eb7efb2b90",
+  "version": "1.41.0-dev.f225223000",
   "type": "module",
   "exports": {
     ".": {
@@ -134,18 +134,18 @@
     "@libp2p/peer-id": "^5.1.0",
     "@libp2p/prometheus-metrics": "^4.3.15",
     "@libp2p/tcp": "^10.1.8",
-    "@lodestar/api": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/config": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/db": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/fork-choice": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/light-client": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/logger": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/params": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/reqresp": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/state-transition": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/types": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/utils": "^1.41.0-dev.eb7efb2b90",
-    "@lodestar/validator": "^1.41.0-dev.eb7efb2b90",
+    "@lodestar/api": "^1.41.0-dev.f225223000",
+    "@lodestar/config": "^1.41.0-dev.f225223000",
+    "@lodestar/db": "^1.41.0-dev.f225223000",
+    "@lodestar/fork-choice": "^1.41.0-dev.f225223000",
+    "@lodestar/light-client": "^1.41.0-dev.f225223000",
+    "@lodestar/logger": "^1.41.0-dev.f225223000",
+    "@lodestar/params": "^1.41.0-dev.f225223000",
+    "@lodestar/reqresp": "^1.41.0-dev.f225223000",
+    "@lodestar/state-transition": "^1.41.0-dev.f225223000",
+    "@lodestar/types": "^1.41.0-dev.f225223000",
+    "@lodestar/utils": "^1.41.0-dev.f225223000",
+    "@lodestar/validator": "^1.41.0-dev.f225223000",
     "@multiformats/multiaddr": "^12.1.3",
     "datastore-core": "^10.0.2",
     "datastore-fs": "^10.0.6",
@@ -169,7 +169,7 @@
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
     "@libp2p/interface-internal": "^2.3.18",
     "@libp2p/logger": "^5.1.21",
-    "@lodestar/spec-test-util": "^1.41.0-dev.eb7efb2b90",
+    "@lodestar/spec-test-util": "^1.41.0-dev.f225223000",
     "@types/js-yaml": "^4.0.5",
     "@types/qs": "^6.9.7",
     "@types/tmp": "^0.2.3",
@@ -188,5 +188,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "d6ca8441fc1a4672d34982134b73d23827487759"
+  "gitHead": "2aa1d42fb2bdca26a2d93338129c593a816f2b97"
 }

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

@@ -1,6 +1,7 @@
 import {routes} from "@lodestar/api";
 import {ApiError, ApplicationMethods} from "@lodestar/api/server";
 import {
+  BUILDER_INDEX_SELF_BUILD,
   ForkPostBellatrix,
   ForkPostFulu,
   ForkPreGloas,
@@ -27,6 +28,7 @@ import {
   WithOptionalBytes,
   deneb,
   fulu,
+  gloas,
   isDenebBlockContents,
   sszTypesFor,
 } from "@lodestar/types";
@@ -42,6 +44,7 @@ import {
   ProduceFullBellatrix,
   ProduceFullDeneb,
   ProduceFullFulu,
+  ProduceFullGloas,
 } from "../../../../chain/produceBlock/index.js";
 import {validateGossipBlock} from "../../../../chain/validation/block.js";
 import {OpSource} from "../../../../chain/validatorMonitor.js";
@@ -51,7 +54,7 @@ import {
   kzgCommitmentToVersionedHash,
   reconstructBlobs,
 } from "../../../../util/blobs.js";
-import {getDataColumnSidecarsFromBlock} from "../../../../util/dataColumns.js";
+import {getDataColumnSidecarsForGloas, getDataColumnSidecarsFromBlock} from "../../../../util/dataColumns.js";
 import {isOptimisticBlock} from "../../../../util/forkChoice.js";
 import {kzg} from "../../../../util/kzg.js";
 import {promiseAllMaybeAsync} from "../../../../util/promises.js";
@@ -93,6 +96,7 @@ export function getBeaconBlockApi({
     const fork = config.getForkName(slot);
     const blockRoot = toRootHex(chain.config.getForkTypes(slot).BeaconBlock.hashTreeRoot(signedBlock.message));
 
+    // TODO GLOAS: handle new BlockInput type
     const blockForImport = chain.seenBlockInputCache.getByBlock({
       block: signedBlock,
       source: BlockInputSource.api,
@@ -309,7 +313,9 @@ export function getBeaconBlockApi({
     ];
     const sentPeersArr = await promiseAllMaybeAsync<number | void>(publishPromises);
 
-    if (isForkPostFulu(fork)) {
+    if (isForkPostGloas(fork)) {
+      // After gloas, data columns are not published with the block but when publishing the execution payload envelope
+    } else if (isForkPostFulu(fork)) {
       let columnsPublishedWithZeroPeers = 0;
       // sent peers per topic are logged in network.publishGossip(), here we only track metrics for it
       // starting from fulu, we have to push to 128 subnets so need to make sure we have enough sent peers per topic
@@ -632,6 +638,143 @@ export function getBeaconBlockApi({
       await publishBlock(args, context, opts);
     },
 
+    async publishExecutionPayloadEnvelope({signedExecutionPayloadEnvelope}) {
+      const seenTimestampSec = Date.now() / 1000;
+      const envelope = signedExecutionPayloadEnvelope.message;
+      const slot = envelope.slot;
+      const fork = config.getForkName(slot);
+      const blockRootHex = toRootHex(envelope.beaconBlockRoot);
+
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `publishExecutionPayloadEnvelope not supported for pre-gloas fork=${fork}`);
+      }
+
+      // TODO GLOAS: review checks, do we want to implement `broadcast_validation`?
+      const block = chain.forkChoice.getBlockHex(blockRootHex);
+      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}`);
+      }
+
+      const isSelfBuild = envelope.builderIndex === BUILDER_INDEX_SELF_BUILD;
+      let dataColumnSidecars: gloas.DataColumnSidecars = [];
+
+      if (isSelfBuild) {
+        // For self-builds, construct and publish data column sidecars from cached block production data
+        const cachedResult = chain.blockProductionCache.get(blockRootHex) as ProduceFullGloas | undefined;
+        if (cachedResult === undefined) {
+          throw new ApiError(404, `No cached block production result found for block root ${blockRootHex}`);
+        }
+        if (!isForkPostGloas(cachedResult.fork)) {
+          throw new ApiError(400, `Cached block production result is for pre-gloas fork=${cachedResult.fork}`);
+        }
+        if (cachedResult.type !== BlockType.Full) {
+          throw new ApiError(400, "Cached block production result is not full block");
+        }
+
+        if (cachedResult.cells && cachedResult.blobsBundle.commitments.length > 0) {
+          const cellsAndProofs = cachedResult.cells.map((rowCells, rowIndex) => ({
+            cells: rowCells,
+            proofs: cachedResult.blobsBundle.proofs.slice(
+              rowIndex * NUMBER_OF_COLUMNS,
+              (rowIndex + 1) * NUMBER_OF_COLUMNS
+            ),
+          }));
+
+          dataColumnSidecars = getDataColumnSidecarsForGloas(slot, envelope.beaconBlockRoot, cellsAndProofs);
+        }
+      } else {
+        // TODO GLOAS: will this api be used by builders or only for self-building?
+      }
+
+      // TODO GLOAS: Verify execution payload envelope signature
+      // For self-builds, the proposer signs with their own validator key
+      // For external builders, verify using the builder's registered pubkey
+      // Use verify_execution_payload_envelope_signature(state, signed_envelope)
+
+      // TODO GLOAS: Process execution payload via state transition
+      // Call process_execution_payload(state, signed_envelope, execution_engine)
+
+      // TODO GLOAS: Update fork choice with the execution payload
+      // Call on_execution_payload(store, signed_envelope) to update fork choice state
+
+      // TODO GLOAS: Add envelope and data columns to block input via seenBlockInputCache
+      // and trigger block import (Gloas block import requires both beacon block and envelope)
+
+      const valLogMeta = {
+        slot,
+        blockRoot: blockRootHex,
+        builderIndex: envelope.builderIndex,
+        isSelfBuild,
+        dataColumns: dataColumnSidecars.length,
+      };
+
+      // If called near a slot boundary (e.g. late in slot N-1), hold briefly so gossip aligns with slot N.
+      const msToBlockSlot = computeTimeAtSlot(config, slot, chain.genesisTime) * 1000 - Date.now();
+      if (msToBlockSlot <= MAX_API_CLOCK_DISPARITY_MS && msToBlockSlot > 0) {
+        await sleep(msToBlockSlot);
+      }
+
+      const delaySec = seenTimestampSec - computeTimeAtSlot(config, slot, chain.genesisTime);
+      metrics?.gossipExecutionPayloadEnvelope.elapsedTimeTillReceived.observe({source: OpSource.api}, delaySec);
+
+      chain.logger.info("Publishing execution payload envelope", valLogMeta);
+
+      // Publish envelope and data columns
+      const publishPromises = [
+        // Gossip the signed execution payload envelope first
+        () => network.publishSignedExecutionPayloadEnvelope(signedExecutionPayloadEnvelope),
+        // For self-builds, publish all data column sidecars
+        ...dataColumnSidecars.map((dataColumnSidecar) => () => network.publishDataColumnSidecar(dataColumnSidecar)),
+      ];
+
+      const sentPeersArr = await promiseAllMaybeAsync<number | void>(publishPromises);
+
+      // Track metrics for data column publishing
+      if (dataColumnSidecars.length > 0) {
+        let columnsPublishedWithZeroPeers = 0;
+        // Skip first entry (envelope), track data columns
+        for (let i = 1; i < sentPeersArr.length; i++) {
+          const sentPeers = sentPeersArr[i] as number;
+          metrics?.dataColumns.sentPeersPerSubnet.observe(sentPeers);
+          if (sentPeers === 0) {
+            columnsPublishedWithZeroPeers++;
+          }
+        }
+        if (columnsPublishedWithZeroPeers > 0) {
+          chain.logger.warn("Published data columns to 0 peers, increased risk of reorg", {
+            slot,
+            blockRoot: blockRootHex,
+            columns: columnsPublishedWithZeroPeers,
+          });
+        }
+
+        metrics?.dataColumns.bySource.inc({source: BlockInputSource.api}, dataColumnSidecars.length);
+
+        if (chain.emitter.listenerCount(routes.events.EventType.dataColumnSidecar)) {
+          // TODO GLOAS: revisit this, we likely don't wanna emit KZG commitments anymore
+          const cachedResult = chain.blockProductionCache.get(blockRootHex) as ProduceFullGloas | undefined;
+          const kzgCommitments = cachedResult?.blobsBundle.commitments.map(toHex) ?? [];
+          for (const dataColumnSidecar of dataColumnSidecars) {
+            chain.emitter.emit(routes.events.EventType.dataColumnSidecar, {
+              blockRoot: blockRootHex,
+              slot,
+              index: dataColumnSidecar.index,
+              kzgCommitments,
+            });
+          }
+        }
+      }
+
+      chain.logger.info("Published execution payload envelope", {
+        ...valLogMeta,
+        delaySec,
+        sentPeers: (sentPeersArr[0] as number) ?? 0,
+      });
+    },
+
     async getBlobSidecars({blockId, indices}) {
       assertUniqueItems(indices, "Duplicate indices provided");
 

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

@@ -95,14 +95,14 @@ export function getBeaconStateApi({
       const {state, executionOptimistic, finalized} = await getState(stateId);
       const currentEpoch = getCurrentEpoch(state);
       const {validators, balances} = state; // Get the validators sub tree once for all the loop
-      const {pubkey2index} = chain;
+      const {pubkeyCache} = chain;
 
       const validatorResponses: routes.beacon.ValidatorResponse[] = [];
       if (validatorIds.length) {
         assertUniqueItems(validatorIds, "Duplicate validator IDs provided");
 
         for (const id of validatorIds) {
-          const resp = getStateValidatorIndex(id, state, pubkey2index);
+          const resp = getStateValidatorIndex(id, state, pubkeyCache);
           if (resp.valid) {
             const validatorIndex = resp.validatorIndex;
             const validator = validators.getReadonly(validatorIndex);
@@ -127,7 +127,7 @@ export function getBeaconStateApi({
       if (statuses.length) {
         assertUniqueItems(statuses, "Duplicate statuses provided");
 
-        const validatorsByStatus = filterStateValidatorsByStatus(statuses, state, pubkey2index, currentEpoch);
+        const validatorsByStatus = filterStateValidatorsByStatus(statuses, state, pubkeyCache, currentEpoch);
         return {
           data: validatorsByStatus,
           meta: {executionOptimistic, finalized},
@@ -154,7 +154,7 @@ export function getBeaconStateApi({
 
     async postStateValidatorIdentities({stateId, validatorIds = []}) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
-      const {pubkey2index} = chain;
+      const {pubkeyCache} = chain;
 
       let validatorIdentities: routes.beacon.ValidatorIdentities;
 
@@ -163,7 +163,7 @@ export function getBeaconStateApi({
 
         validatorIdentities = [];
         for (const id of validatorIds) {
-          const resp = getStateValidatorIndex(id, state, pubkey2index);
+          const resp = getStateValidatorIndex(id, state, pubkeyCache);
           if (resp.valid) {
             const index = resp.validatorIndex;
             const {pubkey, activationEpoch} = state.validators.getReadonly(index);
@@ -187,9 +187,9 @@ export function getBeaconStateApi({
 
     async getStateValidator({stateId, validatorId}) {
       const {state, executionOptimistic, finalized} = await getState(stateId);
-      const {pubkey2index} = chain;
+      const {pubkeyCache} = chain;
 
-      const resp = getStateValidatorIndex(validatorId, state, pubkey2index);
+      const resp = getStateValidatorIndex(validatorId, state, pubkeyCache);
       if (!resp.valid) {
         throw new ApiError(resp.code, resp.reason);
       }
@@ -214,7 +214,7 @@ export function getBeaconStateApi({
 
         const balances: routes.beacon.ValidatorBalance[] = [];
         for (const id of validatorIds) {
-          const resp = getStateValidatorIndex(id, state, chain.pubkey2index);
+          const resp = getStateValidatorIndex(id, state, chain.pubkeyCache);
 
           if (resp.valid) {
             balances.push({

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

@@ -1,9 +1,17 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {routes} from "@lodestar/api";
 import {CheckpointWithHex, IForkChoice} from "@lodestar/fork-choice";
 import {GENESIS_SLOT} from "@lodestar/params";
-import {BeaconStateAllForks, CachedBeaconStateAllForks} from "@lodestar/state-transition";
-import {BLSPubkey, Epoch, RootHex, Slot, ValidatorIndex, getValidatorStatus, phase0} from "@lodestar/types";
+import {BeaconStateAllForks, CachedBeaconStateAllForks, PubkeyCache} from "@lodestar/state-transition";
+import {
+  BLSPubkey,
+  Epoch,
+  RootHex,
+  Slot,
+  ValidatorIndex,
+  getValidatorStatus,
+  mapToGeneralStatus,
+  phase0,
+} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
 import {IBeaconChain} from "../../../../chain/index.js";
 import {ApiError, ValidationError} from "../../errors.js";
@@ -65,28 +73,6 @@ export async function getStateResponseWithRegen(
   return res;
 }
 
-type GeneralValidatorStatus = "active" | "pending" | "exited" | "withdrawal";
-
-function mapToGeneralStatus(subStatus: routes.beacon.ValidatorStatus): GeneralValidatorStatus {
-  switch (subStatus) {
-    case "active_ongoing":
-    case "active_exiting":
-    case "active_slashed":
-      return "active";
-    case "pending_initialized":
-    case "pending_queued":
-      return "pending";
-    case "exited_slashed":
-    case "exited_unslashed":
-      return "exited";
-    case "withdrawal_possible":
-    case "withdrawal_done":
-      return "withdrawal";
-    default:
-      throw new Error(`Unknown substatus: ${subStatus}`);
-  }
-}
-
 export function toValidatorResponse(
   index: ValidatorIndex,
   validator: phase0.Validator,
@@ -104,7 +90,7 @@ export function toValidatorResponse(
 export function filterStateValidatorsByStatus(
   statuses: string[],
   state: BeaconStateAllForks,
-  pubkey2index: PubkeyIndexMap,
+  pubkeyCache: PubkeyCache,
   currentEpoch: Epoch
 ): routes.beacon.ValidatorResponse[] {
   const responses: routes.beacon.ValidatorResponse[] = [];
@@ -115,7 +101,7 @@ export function filterStateValidatorsByStatus(
     const validatorStatus = getValidatorStatus(validator, currentEpoch);
     const generalStatus = mapToGeneralStatus(validatorStatus);
 
-    const resp = getStateValidatorIndex(validator.pubkey, state, pubkey2index);
+    const resp = getStateValidatorIndex(validator.pubkey, state, pubkeyCache);
     if (resp.valid && (statusSet.has(validatorStatus) || statusSet.has(generalStatus))) {
       responses.push(
         toValidatorResponse(resp.validatorIndex, validator, state.balances.get(resp.validatorIndex), currentEpoch)
@@ -132,7 +118,7 @@ type StateValidatorIndexResponse =
 export function getStateValidatorIndex(
   id: routes.beacon.ValidatorId | BLSPubkey,
   state: BeaconStateAllForks,
-  pubkey2index: PubkeyIndexMap
+  pubkeyCache: PubkeyCache
 ): StateValidatorIndexResponse {
   if (typeof id === "string") {
     // mutate `id` and fallthrough to below
@@ -160,7 +146,7 @@ export function getStateValidatorIndex(
   }
 
   // typeof id === Uint8Array
-  const validatorIndex = pubkey2index.get(id);
+  const validatorIndex = pubkeyCache.getIndex(id);
   if (validatorIndex === null) {
     return {valid: false, code: 404, reason: "Validator pubkey not found in state"};
   }

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

@@ -1,9 +1,10 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ExecutionStatus} from "@lodestar/fork-choice";
-import {ZERO_HASH_HEX, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
-import {BeaconState, deneb, fulu, sszTypesFor} from "@lodestar/types";
+import {ForkPostDeneb, ZERO_HASH_HEX, isForkPostDeneb, isForkPostFulu} from "@lodestar/params";
+import {BeaconState, DataColumnSidecars, type SignedBeaconBlock, sszTypesFor} from "@lodestar/types";
 import {toRootHex} from "@lodestar/utils";
+import {getBlobKzgCommitments} from "../../../util/dataColumns.js";
 import {isOptimisticBlock} from "../../../util/forkChoice.js";
 import {getStateSlotFromBytes} from "../../../util/multifork.js";
 import {getBlockResponse} from "../beacon/blocks/utils.js";
@@ -96,10 +97,10 @@ export function getDebugApi({
       const fork = config.getForkName(block.message.slot);
       const blockRoot = sszTypesFor(fork).BeaconBlock.hashTreeRoot(block.message);
 
-      let dataColumnSidecars: fulu.DataColumnSidecars;
+      let dataColumnSidecars: DataColumnSidecars;
 
       const blobCount = isForkPostDeneb(fork)
-        ? (block.message.body as deneb.BeaconBlockBody).blobKzgCommitments.length
+        ? getBlobKzgCommitments(fork, block as SignedBeaconBlock<ForkPostDeneb>).length
         : 0;
 
       if (isForkPostFulu(fork) && blobCount > 0) {
@@ -115,7 +116,9 @@ export function getDebugApi({
       }
 
       return {
-        data: indices ? dataColumnSidecars.filter(({index}) => indices.includes(index)) : dataColumnSidecars,
+        data: (indices
+          ? dataColumnSidecars.filter(({index}) => indices.includes(index))
+          : dataColumnSidecars) as DataColumnSidecars,
         meta: {
           executionOptimistic,
           finalized,

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

@@ -1,7 +1,9 @@
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {MAX_REQUEST_LIGHT_CLIENT_COMMITTEE_HASHES, MAX_REQUEST_LIGHT_CLIENT_UPDATES} from "@lodestar/params";
+import type {LightClientUpdate} from "@lodestar/types";
 import {fromHex} from "@lodestar/utils";
+import {LightClientServerError, LightClientServerErrorCode} from "../../../chain/errors/lightClientError.js";
 import {assertLightClientServer} from "../../../node/utils/lightclient.js";
 import {ApiModules} from "../types.js";
 // TODO: Import from lightclient/server package
@@ -16,8 +18,23 @@ export function getLightclientApi({
       assertLightClientServer(lightClientServer);
 
       const maxAllowedCount = Math.min(MAX_REQUEST_LIGHT_CLIENT_UPDATES, count);
-      const periods = Array.from({length: maxAllowedCount}, (_ignored, i) => i + startPeriod);
-      const updates = await Promise.all(periods.map((period) => lightClientServer.getUpdate(period)));
+      const updates: LightClientUpdate[] = [];
+      for (let i = 0; i < maxAllowedCount; i++) {
+        try {
+          const update = await lightClientServer.getUpdate(startPeriod + i);
+          updates.push(update);
+        } catch (e) {
+          if ((e as LightClientServerError).type?.code === LightClientServerErrorCode.RESOURCE_UNAVAILABLE) {
+            // Period not available, if we already have results, stop to preserve
+            // consecutive order. If not, skip and try the next period.
+            if (updates.length > 0) break;
+            continue;
+          }
+          // Unexpected error
+          throw e;
+        }
+      }
+
       return {
         data: updates,
         meta: {versions: updates.map((update) => config.getForkName(update.attestedHeader.beacon.slot))},

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

@@ -1,8 +1,8 @@
-import {PubkeyIndexMap} from "@chainsafe/pubkey-index-map";
 import {routes} from "@lodestar/api";
 import {ApplicationMethods} from "@lodestar/api/server";
 import {ExecutionStatus, ProtoBlock} from "@lodestar/fork-choice";
 import {
+  BUILDER_INDEX_SELF_BUILD,
   ForkName,
   ForkPostBellatrix,
   ForkPreGloas,
@@ -14,6 +14,7 @@ import {
   isForkPostBellatrix,
   isForkPostDeneb,
   isForkPostElectra,
+  isForkPostGloas,
 } from "@lodestar/params";
 import {
   CachedBeaconStateAllForks,
@@ -25,6 +26,7 @@ import {
   computeStartSlotAtEpoch,
   computeTimeAtSlot,
   createCachedBeaconState,
+  createPubkeyCache,
   getBlockRootAtSlot,
   getCurrentSlot,
   loadState,
@@ -45,6 +47,7 @@ import {
   Wei,
   bellatrix,
   getValidatorStatus,
+  gloas,
   phase0,
   ssz,
 } from "@lodestar/types";
@@ -69,7 +72,7 @@ import {
 } from "../../../chain/errors/index.js";
 import {ChainEvent, CommonBlockBody} from "../../../chain/index.js";
 import {PREPARE_NEXT_SLOT_BPS} from "../../../chain/prepareNextSlot.js";
-import {BlockType, ProduceFullDeneb} from "../../../chain/produceBlock/index.js";
+import {BlockType, ProduceFullDeneb, ProduceFullGloas} from "../../../chain/produceBlock/index.js";
 import {RegenCaller} from "../../../chain/regen/index.js";
 import {CheckpointHex} from "../../../chain/stateCache/types.js";
 import {validateApiAggregateAndProof} from "../../../chain/validation/index.js";
@@ -901,6 +904,77 @@ export function getValidatorApi(
       return {data, meta};
     },
 
+    async produceBlockV4({slot, randaoReveal, graffiti, feeRecipient}) {
+      const fork = config.getForkName(slot);
+
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `produceBlockV4 not supported for pre-gloas fork=${fork}`);
+      }
+
+      notWhileSyncing();
+      await waitForSlot(slot);
+
+      // TODO GLOAS: support producing blocks from builder bids
+      const source = ProducedBlockSource.engine;
+
+      // TODO GLOAS: needs to be updated after fork choice changes are merged
+      const parentBlock = chain.getProposerHead(slot);
+      const {blockRoot: parentBlockRootHex, slot: parentSlot} = parentBlock;
+      const parentBlockRoot = fromHex(parentBlockRootHex);
+      notOnOutOfRangeData(parentBlockRoot);
+      metrics?.blockProductionSlotDelta.set(slot - parentSlot);
+      metrics?.blockProductionRequests.inc({source});
+
+      const graffitiBytes = toGraffitiBytes(
+        graffiti ?? getDefaultGraffiti(getLodestarClientVersion(), chain.executionEngine.clientVersion, {})
+      );
+      const commonBlockBodyPromise = chain.produceCommonBlockBody({
+        slot,
+        parentBlock,
+        randaoReveal,
+        graffiti: graffitiBytes,
+      });
+
+      let timer: undefined | ((opts: {source: ProducedBlockSource}) => number);
+      try {
+        timer = metrics?.blockProductionTime.startTimer();
+        const {block, executionPayloadValue, consensusBlockValue} = await chain.produceBlock({
+          slot,
+          parentBlock,
+          randaoReveal,
+          graffiti: graffitiBytes,
+          feeRecipient,
+          commonBlockBodyPromise,
+        });
+
+        metrics?.blockProductionSuccess.inc({source});
+        metrics?.blockProductionNumAggregated.observe({source}, block.body.attestations.length);
+        metrics?.blockProductionConsensusBlockValue.observe({source}, Number(formatWeiToEth(consensusBlockValue)));
+        metrics?.blockProductionExecutionPayloadValue.observe({source}, Number(formatWeiToEth(executionPayloadValue)));
+
+        const blockRoot = toRootHex(config.getForkTypes(slot).BeaconBlock.hashTreeRoot(block));
+        logger.verbose("Produced block", {
+          slot,
+          executionPayloadValue,
+          consensusBlockValue,
+          root: blockRoot,
+        });
+        if (chain.opts.persistProducedBlocks) {
+          void chain.persistBlock(block, "produced_engine_block");
+        }
+
+        return {
+          data: block as gloas.BeaconBlock,
+          meta: {
+            version: fork,
+            consensusBlockValue,
+          },
+        };
+      } finally {
+        timer?.({source});
+      }
+    },
+
     async produceAttestationData({committeeIndex, slot}) {
       notWhileSyncing();
 
@@ -1049,8 +1123,7 @@ export function getValidatorApi(
             {
               config: chain.config,
               // Not required to compute proposers
-              pubkey2index: new PubkeyIndexMap(),
-              index2pubkey: [],
+              pubkeyCache: createPubkeyCache(),
             },
             {skipSyncPubkeys: true, skipSyncCommitteeCache: true}
           );
@@ -1511,7 +1584,7 @@ export function getValidatorApi(
 
       const filteredRegistrations = registrations.filter((registration) => {
         const {pubkey} = registration.message;
-        const validatorIndex = chain.pubkey2index.get(pubkey);
+        const validatorIndex = chain.pubkeyCache.getIndex(pubkey);
         if (validatorIndex === null) return false;
 
         const validator = headState.validators.getReadonly(validatorIndex);
@@ -1532,5 +1605,54 @@ export function getValidatorApi(
         count: filteredRegistrations.length,
       });
     },
+
+    async getExecutionPayloadEnvelope({slot, beaconBlockRoot}) {
+      const fork = config.getForkName(slot);
+
+      if (!isForkPostGloas(fork)) {
+        throw new ApiError(400, `getExecutionPayloadEnvelope not supported for pre-gloas fork=${fork}`);
+      }
+
+      notWhileSyncing();
+      await waitForSlot(slot);
+
+      const blockRootHex = toRootHex(beaconBlockRoot);
+      const produceResult = chain.blockProductionCache.get(blockRootHex);
+
+      if (produceResult === undefined) {
+        throw new ApiError(404, `No cached block production result found for block root ${blockRootHex}`);
+      }
+      if (!isForkPostGloas(produceResult.fork)) {
+        throw Error(`Cached block production result is for pre-gloas fork=${produceResult.fork}`);
+      }
+      if (produceResult.type !== BlockType.Full) {
+        throw Error("Cached block production result is not full block");
+      }
+
+      const {executionPayload, executionRequests, envelopeStateRoot} = produceResult as ProduceFullGloas;
+
+      const envelope: gloas.ExecutionPayloadEnvelope = {
+        payload: executionPayload,
+        executionRequests: executionRequests,
+        builderIndex: BUILDER_INDEX_SELF_BUILD,
+        beaconBlockRoot,
+        slot,
+        stateRoot: envelopeStateRoot,
+      };
+
+      logger.info("Produced execution payload envelope", {
+        slot,
+        blockRoot: blockRootHex,
+        transactions: executionPayload.transactions.length,
+        blockHash: toRootHex(executionPayload.blockHash),
+      });
+
+      return {
+        data: envelope,
+        meta: {
+          version: fork,
+        },
+      };
+    },
   };
 }