@lodestar/state-transition 1.48.0-dev.e9c9b8835d → 1.48.0-dev.fd70e5fc15

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.48.0-dev.e9c9b8835d",
+  "version": "1.48.0-dev.fd70e5fc15",
   "type": "module",
   "exports": {
     ".": {
@@ -70,14 +70,14 @@
     "@chainsafe/persistent-merkle-tree": "^1.3.1",
     "@chainsafe/ssz": "^1.7.0",
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@lodestar/config": "^1.48.0-dev.e9c9b8835d",
-    "@lodestar/params": "^1.48.0-dev.e9c9b8835d",
-    "@lodestar/types": "^1.48.0-dev.e9c9b8835d",
-    "@lodestar/utils": "^1.48.0-dev.e9c9b8835d",
+    "@lodestar/config": "^1.48.0-dev.fd70e5fc15",
+    "@lodestar/params": "^1.48.0-dev.fd70e5fc15",
+    "@lodestar/types": "^1.48.0-dev.fd70e5fc15",
+    "@lodestar/utils": "^1.48.0-dev.fd70e5fc15",
     "@vekexasia/bigint-buffer2": "^1.1.1"
   },
   "devDependencies": {
-    "@lodestar/api": "^1.48.0-dev.e9c9b8835d"
+    "@lodestar/api": "^1.48.0-dev.fd70e5fc15"
   },
   "keywords": [
     "ethereum",
@@ -85,5 +85,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "37d9901d2effe005e9b5de4e25d019c216c23fff"
+  "gitHead": "dbc49c8fa4a2870bc2b4b102fe61a4d2909621fa"
 }

package/src/block/index.ts

@@ -20,7 +20,7 @@ import {processPayloadAttestation} from "./processPayloadAttestation.js";
 import {processRandao} from "./processRandao.js";
 import {processSyncAggregate} from "./processSyncCommittee.js";
 import {processWithdrawals} from "./processWithdrawals.js";
-import {BlockProcessStep, ProcessBlockOpts, ProposerRewardType} from "./types.js";
+import {ProcessBlockOpts, ProposerRewardType} from "./types.js";
 
 // Spec tests
 export {
@@ -60,31 +60,21 @@ export function processBlock(
   // Apply the parent's deferred payload effects before everything else. Must run before
   // processBlockHeader and processExecutionPayloadBid so subsequent steps see the updated state.
   if (fork >= ForkSeq.gloas) {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processParentExecutionPayload});
     processParentExecutionPayload(state as CachedBeaconStateGloas, block as BeaconBlock<ForkPostGloas>);
-    timer?.();
   }
 
-  {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processBlockHeader});
-    processBlockHeader(state, block);
-    timer?.();
-  }
+  processBlockHeader(state, block);
 
-  if (fork >= ForkSeq.capella) {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processWithdrawals});
-    if (fork >= ForkSeq.gloas) {
-      // Parent payload's execution requests were already applied by processParentExecutionPayload above
-      processWithdrawals(fork, state as CachedBeaconStateGloas);
-    } else {
-      const fullOrBlindedPayload = getFullOrBlindedPayload(block);
-      processWithdrawals(
-        fork,
-        state as CachedBeaconStateCapella,
-        fullOrBlindedPayload as capella.FullOrBlindedExecutionPayload
-      );
-    }
-    timer?.();
+  if (fork >= ForkSeq.gloas) {
+    // Parent payload's execution requests were already applied by processParentExecutionPayload above
+    processWithdrawals(fork, state as CachedBeaconStateGloas);
+  } else if (fork >= ForkSeq.capella) {
+    const fullOrBlindedPayload = getFullOrBlindedPayload(block);
+    processWithdrawals(
+      fork,
+      state as CachedBeaconStateCapella,
+      fullOrBlindedPayload as capella.FullOrBlindedExecutionPayload
+    );
   }
 
   // The call to the process_execution_payload must happen before the call to the process_randao as the former depends
@@ -97,48 +87,25 @@ export function processBlock(
     fork >= ForkSeq.bellatrix &&
     isExecutionEnabled(state as CachedBeaconStateBellatrix, block)
   ) {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processExecutionPayload});
     processExecutionPayload(fork, state as CachedBeaconStateBellatrix, block.body, externalData);
-    timer?.();
   }
 
   if (fork >= ForkSeq.gloas) {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processExecutionPayloadBid});
     processExecutionPayloadBid(
       state as CachedBeaconStateGloas,
       (block as BeaconBlock<ForkPostGloas>).body.signedExecutionPayloadBid
     );
-    timer?.();
-  }
-
-  {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processRandao});
-    processRandao(state, block, verifySignatures);
-    timer?.();
-  }
-
-  {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processEth1Data});
-    processEth1Data(state, block.body.eth1Data);
-    timer?.();
-  }
-
-  {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processOperations});
-    processOperations(fork, state, block.body, parentSlot, opts, metrics);
-    timer?.();
   }
 
+  processRandao(state, block, verifySignatures);
+  processEth1Data(state, block.body.eth1Data);
+  processOperations(fork, state, block.body, parentSlot, opts, metrics);
   if (fork >= ForkSeq.altair) {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processSyncAggregate});
     processSyncAggregate(state, block as altair.BeaconBlock, verifySignatures);
-    timer?.();
   }
 
   if (fork >= ForkSeq.deneb) {
-    const timer = metrics?.processBlockStepTime.startTimer({step: BlockProcessStep.processBlobKzgCommitments});
     processBlobKzgCommitments(externalData);
-    timer?.();
     // Only throw PreData so beacon can also sync/process blocks optimistically
     // and let forkChoice handle it
     if (externalData.dataAvailabilityStatus === DataAvailabilityStatus.PreData) {

package/src/block/processOperations.ts

@@ -18,7 +18,7 @@ import {processPayloadAttestation} from "./processPayloadAttestation.js";
 import {processProposerSlashing} from "./processProposerSlashing.js";
 import {processVoluntaryExit} from "./processVoluntaryExit.js";
 import {processWithdrawalRequest} from "./processWithdrawalRequest.js";
-import {ProcessBlockOpts, ProcessOperationsStep} from "./types.js";
+import {ProcessBlockOpts} from "./types.js";
 
 export {
   processProposerSlashing,
@@ -49,94 +49,49 @@ export function processOperations(
     );
   }
 
-  {
-    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processProposerSlashing});
-    for (const proposerSlashing of body.proposerSlashings) {
-      processProposerSlashing(fork, state, proposerSlashing, opts.verifySignatures);
-    }
-    timer?.();
+  for (const proposerSlashing of body.proposerSlashings) {
+    processProposerSlashing(fork, state, proposerSlashing, opts.verifySignatures);
   }
-
-  {
-    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processAttesterSlashing});
-    for (const attesterSlashing of body.attesterSlashings) {
-      processAttesterSlashing(fork, state, attesterSlashing, opts.verifySignatures);
-    }
-    timer?.();
+  for (const attesterSlashing of body.attesterSlashings) {
+    processAttesterSlashing(fork, state, attesterSlashing, opts.verifySignatures);
   }
 
-  {
-    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processAttestations});
-    processAttestations(fork, state, body.attestations, parentSlot, opts.verifySignatures, metrics);
-    timer?.();
-  }
+  processAttestations(fork, state, body.attestations, parentSlot, opts.verifySignatures, metrics);
 
-  {
-    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processDeposit});
-    for (const deposit of body.deposits) {
-      processDeposit(fork, state, deposit);
-    }
-    timer?.();
+  for (const deposit of body.deposits) {
+    processDeposit(fork, state, deposit);
   }
 
-  {
-    const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processVoluntaryExit});
-    for (const voluntaryExit of body.voluntaryExits) {
-      processVoluntaryExit(fork, state, voluntaryExit, opts.verifySignatures);
-    }
-    timer?.();
+  for (const voluntaryExit of body.voluntaryExits) {
+    processVoluntaryExit(fork, state, voluntaryExit, opts.verifySignatures);
   }
 
   if (fork >= ForkSeq.capella) {
-    const timer = metrics?.processOperationsStepTime.startTimer({
-      step: ProcessOperationsStep.processBlsToExecutionChange,
-    });
     for (const blsToExecutionChange of (body as capella.BeaconBlockBody).blsToExecutionChanges) {
       processBlsToExecutionChange(state as CachedBeaconStateCapella, blsToExecutionChange);
     }
-    timer?.();
   }
 
   if (fork >= ForkSeq.electra && fork < ForkSeq.gloas) {
     const stateElectra = state as CachedBeaconStateElectra;
     const bodyElectra = body as electra.BeaconBlockBody;
 
-    {
-      const timer = metrics?.processOperationsStepTime.startTimer({step: ProcessOperationsStep.processDepositRequest});
-      for (const depositRequest of bodyElectra.executionRequests.deposits) {
-        processDepositRequest(fork, stateElectra, depositRequest);
-      }
-      timer?.();
+    for (const depositRequest of bodyElectra.executionRequests.deposits) {
+      processDepositRequest(fork, stateElectra, depositRequest);
     }
 
-    {
-      const timer = metrics?.processOperationsStepTime.startTimer({
-        step: ProcessOperationsStep.processWithdrawalRequest,
-      });
-      for (const elWithdrawalRequest of bodyElectra.executionRequests.withdrawals) {
-        processWithdrawalRequest(fork, stateElectra, elWithdrawalRequest);
-      }
-      timer?.();
+    for (const elWithdrawalRequest of bodyElectra.executionRequests.withdrawals) {
+      processWithdrawalRequest(fork, stateElectra, elWithdrawalRequest);
     }
 
-    {
-      const timer = metrics?.processOperationsStepTime.startTimer({
-        step: ProcessOperationsStep.processConsolidationRequest,
-      });
-      for (const elConsolidationRequest of bodyElectra.executionRequests.consolidations) {
-        processConsolidationRequest(stateElectra, elConsolidationRequest);
-      }
-      timer?.();
+    for (const elConsolidationRequest of bodyElectra.executionRequests.consolidations) {
+      processConsolidationRequest(stateElectra, elConsolidationRequest);
     }
   }
 
   if (fork >= ForkSeq.gloas) {
-    const timer = metrics?.processOperationsStepTime.startTimer({
-      step: ProcessOperationsStep.processPayloadAttestation,
-    });
     for (const payloadAttestation of (body as gloas.BeaconBlockBody).payloadAttestations) {
-      processPayloadAttestation(state as CachedBeaconStateGloas, payloadAttestation, opts.verifySignatures);
+      processPayloadAttestation(state as CachedBeaconStateGloas, payloadAttestation);
     }
-    timer?.();
   }
 }

package/src/block/processPayloadAttestation.ts

@@ -5,8 +5,7 @@ import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestati
 
 export function processPayloadAttestation(
   state: CachedBeaconStateGloas,
-  payloadAttestation: gloas.PayloadAttestation,
-  verifySignature = true
+  payloadAttestation: gloas.PayloadAttestation
 ): void {
   const data = payloadAttestation.data;
 
@@ -20,7 +19,7 @@ export function processPayloadAttestation(
 
   const indexedPayloadAttestation = state.epochCtx.getIndexedPayloadAttestation(data.slot, payloadAttestation);
 
-  if (!isValidIndexedPayloadAttestation(state, indexedPayloadAttestation, verifySignature)) {
+  if (!isValidIndexedPayloadAttestation(state, indexedPayloadAttestation, true)) {
     throw Error("Invalid payload attestation");
   }
 }

package/src/block/types.ts

@@ -7,35 +7,3 @@ export enum ProposerRewardType {
   syncAggregate = "sync_aggregate",
   slashing = "slashing",
 }
-
-/**
- * Steps of `processBlock()` tracked in metrics
- */
-export enum BlockProcessStep {
-  processParentExecutionPayload = "processParentExecutionPayload",
-  processBlockHeader = "processBlockHeader",
-  processWithdrawals = "processWithdrawals",
-  processExecutionPayload = "processExecutionPayload",
-  processExecutionPayloadBid = "processExecutionPayloadBid",
-  processRandao = "processRandao",
-  processEth1Data = "processEth1Data",
-  processOperations = "processOperations",
-  processSyncAggregate = "processSyncAggregate",
-  processBlobKzgCommitments = "processBlobKzgCommitments",
-}
-
-/**
- * Steps of `processOperations()` tracked in metrics
- */
-export enum ProcessOperationsStep {
-  processProposerSlashing = "processProposerSlashing",
-  processAttesterSlashing = "processAttesterSlashing",
-  processAttestations = "processAttestations",
-  processDeposit = "processDeposit",
-  processVoluntaryExit = "processVoluntaryExit",
-  processBlsToExecutionChange = "processBlsToExecutionChange",
-  processDepositRequest = "processDepositRequest",
-  processWithdrawalRequest = "processWithdrawalRequest",
-  processConsolidationRequest = "processConsolidationRequest",
-  processPayloadAttestation = "processPayloadAttestation",
-}

package/src/epoch/processPtcWindow.ts

@@ -1,4 +1,4 @@
-import {MIN_SEED_LOOKAHEAD, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {MIN_SEED_LOOKAHEAD} from "@lodestar/params";
 import {ssz} from "@lodestar/types";
 import {CachedBeaconStateGloas, EpochTransitionCache} from "../types.js";
 import {computeEpochShuffling} from "../util/epochShuffling.js";
@@ -22,24 +22,17 @@ export function processPtcWindow(state: CachedBeaconStateGloas, cache: EpochTran
     state,
     nextEpoch,
     nextEpochShuffling.committees,
-    nextEpochShuffling.shuffling,
     state.epochCtx.effectiveBalanceIncrements
   );
 
   // Stash for finalProcessEpoch to shift into epoch cache
   cache.nextEpochPayloadTimelinessCommittees = newNextPayloadTimelinessCommittees;
 
-  // Shift the current and next epochs forward by reusing their SSZ subtrees and cached hashes.
-  // Only the newly computed epoch needs new subtrees.
-  const ptcWindow = state.ptcWindow;
-  const retainedLength = ptcWindow.length - SLOTS_PER_EPOCH;
-  for (let i = 0; i < retainedLength; i++) {
-    ptcWindow.set(i, ptcWindow.getReadonly(i + SLOTS_PER_EPOCH));
-  }
-  for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
-    ptcWindow.set(
-      retainedLength + i,
-      ssz.gloas.PayloadTimelinessCommittee.toViewDU(newNextPayloadTimelinessCommittees[i])
-    );
-  }
+  // Write shifted window to state: current(N) + next(N+1) + newlyComputed(N+2)
+  // From the perspective of upcoming epoch N+1, this is previous + current + next
+  state.ptcWindow = ssz.gloas.PayloadTimelinessCommitteeWindow.toViewDU([
+    ...state.epochCtx.payloadTimelinessCommittees,
+    ...state.epochCtx.nextPayloadTimelinessCommittees,
+    ...newNextPayloadTimelinessCommittees,
+  ]);
 }

package/src/index.ts

@@ -13,7 +13,7 @@ export {
 } from "./block/processVoluntaryExit.js";
 // Withdrawals for new blocks
 export {getExpectedWithdrawals} from "./block/processWithdrawals.js";
-export {BlockProcessStep, ProcessOperationsStep, ProposerRewardType} from "./block/types.js";
+export {ProposerRewardType} from "./block/types.js";
 export {
   type EffectiveBalanceIncrements,
   getEffectiveBalanceIncrementsWithLen,

package/src/metrics.ts

@@ -1,6 +1,6 @@
 import {ForkName} from "@lodestar/params";
 import {MetricsRegister} from "@lodestar/utils";
-import {BlockProcessStep, ProcessOperationsStep, ProposerRewardType} from "./block/types.js";
+import {ProposerRewardType} from "./block/types.js";
 import {EpochTransitionStep} from "./epoch/index.js";
 import {StateCloneSource, StateHashTreeRootSource} from "./stateTransition.js";
 import {CachedBeaconStateAllForks} from "./types.js";
@@ -57,21 +57,10 @@ export function getMetrics(register: MetricsRegister) {
     processBlockTime: register.histogram({
       name: "lodestar_stfn_process_block_seconds",
       help: "Time to process a single block in seconds",
+      // TODO: Add metrics for each step
       // Block processing can take 5-40ms, 100ms max
       buckets: [0.005, 0.01, 0.02, 0.05, 0.1, 1],
     }),
-    processBlockStepTime: register.histogram<{step: BlockProcessStep}>({
-      name: "lodestar_stfn_process_block_step_seconds",
-      help: "Time to call each step of process block in seconds",
-      labelNames: ["step"],
-      buckets: [0.001, 0.005, 0.01, 0.025, 0.05, 0.1],
-    }),
-    processOperationsStepTime: register.histogram<{step: ProcessOperationsStep}>({
-      name: "lodestar_stfn_process_operations_step_seconds",
-      help: "Time to call each step of process operations in seconds",
-      labelNames: ["step"],
-      buckets: [0.001, 0.005, 0.01, 0.025, 0.05, 0.1],
-    }),
     processBlockCommitTime: register.histogram({
       name: "lodestar_stfn_process_block_commit_seconds",
       help: "Time to call commit after process a single block in seconds",

package/src/signatureSets/index.ts

@@ -1,14 +1,13 @@
 import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq} from "@lodestar/params";
-import {IndexedAttestation, SignedBeaconBlock, altair, capella, gloas} from "@lodestar/types";
+import {IndexedAttestation, SignedBeaconBlock, altair, capella} from "@lodestar/types";
 import {getSyncCommitteeSignatureSet} from "../block/processSyncCommittee.js";
 import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
-import {IBeaconStateView, IBeaconStateViewGloas} from "../stateView/interface.js";
-import {ISignatureSet, createAggregateSignatureSetFromComponents} from "../util/index.js";
+import {IBeaconStateView} from "../stateView/interface.js";
+import {ISignatureSet} from "../util/index.js";
 import {getAttesterSlashingsSignatureSets} from "./attesterSlashings.js";
 import {getBlsToExecutionChangeSignatureSets} from "./blsToExecutionChange.js";
 import {getAttestationsSignatureSets} from "./indexedAttestation.js";
-import {getPayloadAttestationDataSigningRoot} from "./indexedPayloadAttestation.js";
 import {getBlockProposerSignatureSet} from "./proposer.js";
 import {getProposerSlashingsSignatureSets} from "./proposerSlashings.js";
 import {getRandaoRevealSignatureSet} from "./randao.js";
@@ -80,18 +79,5 @@ export function getBlockSignatureSets(
     }
   }
 
-  if (fork >= ForkSeq.gloas) {
-    for (const payloadAttestation of (signedBlock as gloas.SignedBeaconBlock).message.body.payloadAttestations) {
-      const ptc = (state as IBeaconStateViewGloas).getPayloadTimelinessCommittee(payloadAttestation.data.slot);
-      signatureSets.push(
-        createAggregateSignatureSetFromComponents(
-          payloadAttestation.aggregationBits.intersectValues(ptc),
-          getPayloadAttestationDataSigningRoot(config, payloadAttestation.data),
-          payloadAttestation.signature
-        )
-      );
-    }
-  }
-
   return signatureSets;
 }

package/src/stateView/beaconStateView.ts

@@ -456,18 +456,6 @@ export class BeaconStateView implements IBeaconStateViewLatestFork {
     }
     throw new Error(`PTC committees are not available for epoch=${epoch}`);
   }
-
-  /**
-   * Return the PTC for a slot in the previous, current or next epoch
-   */
-  getPayloadTimelinessCommittee(slot: Slot): Uint32Array {
-    if (this.config.getForkSeq(this.cachedState.slot) < ForkSeq.gloas) {
-      throw new Error("PTC committees are not supported before Gloas");
-    }
-
-    return (this.cachedState as CachedBeaconStateGloas).epochCtx.getPayloadTimelinessCommittee(slot);
-  }
-
   /**
    * Return all positions of the validator in the PTC committee for the given slot.
    *

package/src/stateView/interface.ts

@@ -285,7 +285,6 @@ export interface IBeaconStateViewGloas extends IBeaconStateViewFulu {
   getBuildersLength(): number;
   canBuilderCoverBid(builderIndex: BuilderIndex, bidAmount: number): boolean;
   getEpochPTCs(epoch: Epoch): Uint32Array[];
-  getPayloadTimelinessCommittee(slot: Slot): Uint32Array;
   getIndicesInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number[];
   /**
    * Clone the state and apply parent execution payload effects.

package/src/stateView/nativeBeaconStateView.ts

@@ -926,10 +926,6 @@ export class NativeBeaconStateView implements IBeaconStateViewLatestFork {
     return cached;
   }
 
-  getPayloadTimelinessCommittee(slot: Slot): Uint32Array {
-    return this.binding.getPayloadTimelinessCommittee(slot);
-  }
-
   getIndicesInPayloadTimelinessCommittee(validatorIndex: ValidatorIndex, slot: Slot): number[] {
     return this.binding.getIndicesInPayloadTimelinessCommittee(validatorIndex, slot);
   }

package/src/util/gloas.ts

@@ -220,7 +220,6 @@ export function initializePtcWindow(state: CachedBeaconStateFulu): Uint32Array[]
         state,
         epoch,
         shuffling.committees,
-        shuffling.shuffling,
         state.epochCtx.effectiveBalanceIncrements
       )
     );

package/src/util/seed.ts

@@ -1,5 +1,4 @@
 import {digest} from "@chainsafe/as-sha256";
-import {computePtcIndicesForEpoch} from "@chainsafe/lodestar-z/shuffle";
 import {
   computeProposerIndex as nativeComputeProposerIndex,
   computeSyncCommitteeIndices as nativeComputeSyncCommitteeIndices,
@@ -276,36 +275,25 @@ export function computePayloadTimelinessCommitteesForEpoch(
   state: BeaconStateAllForks,
   epoch: number,
   committees: Uint32Array[][],
-  shuffling: Uint32Array,
   effectiveBalanceIncrements: EffectiveBalanceIncrements
 ): Uint32Array[] {
   const epochSeed = getSeed(state, epoch, DOMAIN_PTC_ATTESTER);
   const startSlot = epoch * SLOTS_PER_EPOCH;
-  const slotOffsets = new Uint32Array(SLOTS_PER_EPOCH + 1);
-  let shufflingLength = 0;
-  for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
-    slotOffsets[i] = shufflingLength;
-    for (const committee of committees[i]) {
-      shufflingLength += committee.length;
-    }
-  }
-  slotOffsets[SLOTS_PER_EPOCH] = shufflingLength;
-
-  // Native sampling returns all committees concatenated in slot order, with PTC_SIZE indices per slot.
-  const flatPtcIndices = computePtcIndicesForEpoch(
-    epochSeed,
-    startSlot,
-    SLOTS_PER_EPOCH,
-    shuffling,
-    slotOffsets,
-    effectiveBalanceIncrements,
-    PTC_SIZE,
-    MAX_EFFECTIVE_BALANCE_ELECTRA,
-    EFFECTIVE_BALANCE_INCREMENT
-  );
   const result: Uint32Array[] = new Array(SLOTS_PER_EPOCH);
+
+  // Pre-allocate slot seed buffer once, reuse across all slots
+  const slotSeedInput = new Uint8Array(epochSeed.length + 8);
+  slotSeedInput.set(epochSeed, 0);
+  const slotSeedView = new DataView(slotSeedInput.buffer, slotSeedInput.byteOffset, slotSeedInput.byteLength);
+
   for (let i = 0; i < SLOTS_PER_EPOCH; i++) {
-    result[i] = flatPtcIndices.subarray(i * PTC_SIZE, (i + 1) * PTC_SIZE);
+    const slot = startSlot + i;
+    // Write slot as little-endian uint64 (fits in uint32 range)
+    slotSeedView.setUint32(epochSeed.length, slot, true);
+    slotSeedView.setUint32(epochSeed.length + 4, 0, true);
+    const slotSeed = digest(slotSeedInput);
+
+    result[i] = computePayloadTimelinessCommitteeForSlot(slotSeed, committees[i], effectiveBalanceIncrements);
   }
   return result;
 }