@lodestar/state-transition 1.40.0-dev.9e8478fc70 → 1.40.0-dev.b87b37f4d0

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.40.0-dev.9e8478fc70",
+  "version": "1.40.0-dev.b87b37f4d0",
   "type": "module",
   "exports": {
     ".": {
@@ -62,14 +62,14 @@
     "@chainsafe/pubkey-index-map": "^3.0.0",
     "@chainsafe/ssz": "^1.2.2",
     "@chainsafe/swap-or-not-shuffle": "^1.2.1",
-    "@lodestar/config": "^1.40.0-dev.9e8478fc70",
-    "@lodestar/params": "^1.40.0-dev.9e8478fc70",
-    "@lodestar/types": "^1.40.0-dev.9e8478fc70",
-    "@lodestar/utils": "^1.40.0-dev.9e8478fc70",
-    "bigint-buffer": "^1.1.5"
+    "@lodestar/config": "^1.40.0-dev.b87b37f4d0",
+    "@lodestar/params": "^1.40.0-dev.b87b37f4d0",
+    "@lodestar/types": "^1.40.0-dev.b87b37f4d0",
+    "@lodestar/utils": "^1.40.0-dev.b87b37f4d0",
+    "@vekexasia/bigint-buffer2": "^1.1.0"
   },
   "devDependencies": {
-    "@lodestar/api": "^1.40.0-dev.9e8478fc70"
+    "@lodestar/api": "^1.40.0-dev.b87b37f4d0"
   },
   "keywords": [
     "ethereum",
@@ -77,5 +77,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "909616d65811ada87bde2cdf3672869dbe04a827"
+  "gitHead": "a31874a6b5684b145e5b0eb2ac120f6bad59d184"
 }

package/src/block/isValidIndexedAttestation.ts

@@ -21,7 +21,7 @@ export function isValidIndexedAttestation(
   }
 
   if (verifySignature) {
-    return verifySignatureSet(getIndexedAttestationSignatureSet(config, index2pubkey, stateSlot, indexedAttestation));
+    return verifySignatureSet(getIndexedAttestationSignatureSet(config, stateSlot, indexedAttestation), index2pubkey);
   }
   return true;
 }
@@ -40,7 +40,8 @@ export function isValidIndexedAttestationBigint(
 
   if (verifySignature) {
     return verifySignatureSet(
-      getIndexedAttestationBigintSignatureSet(config, index2pubkey, stateSlot, indexedAttestation)
+      getIndexedAttestationBigintSignatureSet(config, stateSlot, indexedAttestation),
+      index2pubkey
     );
   }
   return true;

package/src/block/isValidIndexedPayloadAttestation.ts

@@ -16,7 +16,10 @@ export function isValidIndexedPayloadAttestation(
   }
 
   if (verifySignature) {
-    return verifySignatureSet(getIndexedPayloadAttestationSignatureSet(state, indexedPayloadAttestation));
+    return verifySignatureSet(
+      getIndexedPayloadAttestationSignatureSet(state, indexedPayloadAttestation),
+      state.epochCtx.index2pubkey
+    );
   }
 
   return true;

package/src/block/processAttestationsAltair.ts

@@ -1,4 +1,3 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
 import {
   EFFECTIVE_BALANCE_INCREMENT,
   ForkSeq,
@@ -15,7 +14,7 @@ import {
   WEIGHT_DENOMINATOR,
 } from "@lodestar/params";
 import {Attestation, Epoch, phase0} from "@lodestar/types";
-import {intSqrt} from "@lodestar/utils";
+import {byteArrayEquals, intSqrt} from "@lodestar/utils";
 import {BeaconStateTransitionMetrics} from "../metrics.js";
 import {getAttestationWithIndicesSignatureSet} from "../signatureSets/indexedAttestation.js";
 import {CachedBeaconStateAltair, CachedBeaconStateGloas} from "../types.js";
@@ -64,14 +63,8 @@ export function processAttestationsAltair(
     // TODO: Why should we verify an indexed attestation that we just created? If it's just for the signature
     // we can verify only that and nothing else.
     if (verifySignature) {
-      const sigSet = getAttestationWithIndicesSignatureSet(
-        state.config,
-        epochCtx.index2pubkey,
-        state.slot,
-        attestation,
-        attestingIndices
-      );
-      if (!verifySignatureSet(sigSet)) {
+      const sigSet = getAttestationWithIndicesSignatureSet(state.config, state.slot, attestation, attestingIndices);
+      if (!verifySignatureSet(sigSet, state.epochCtx.index2pubkey)) {
         throw new Error("Attestation signature is not valid");
       }
     }

package/src/block/processBlockHeader.ts

@@ -1,6 +1,5 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
 import {BeaconBlock, BlindedBeaconBlock, ssz} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
+import {byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {ZERO_HASH} from "../constants/index.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {blindedOrFullBlockToHeader} from "../util/index.js";

package/src/block/processBlsToExecutionChange.ts

@@ -1,10 +1,9 @@
 import {digest} from "@chainsafe/as-sha256";
-import {byteArrayEquals} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {BLS_WITHDRAWAL_PREFIX, ETH1_ADDRESS_WITHDRAWAL_PREFIX} from "@lodestar/params";
 import {capella} from "@lodestar/types";
 import {Validator} from "@lodestar/types/phase0";
-import {toHex} from "@lodestar/utils";
+import {byteArrayEquals, toHex} from "@lodestar/utils";
 import {verifyBlsToExecutionChangeSignature} from "../signatureSets/index.js";
 import {CachedBeaconStateCapella} from "../types.js";
 

package/src/block/processConsolidationRequest.ts

@@ -1,5 +1,6 @@
 import {FAR_FUTURE_EPOCH, MIN_ACTIVATION_BALANCE, PENDING_CONSOLIDATIONS_LIMIT} from "@lodestar/params";
 import {electra, ssz} from "@lodestar/types";
+import {byteArrayEquals} from "@lodestar/utils";
 import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {hasEth1WithdrawalCredential} from "../util/capella.js";
 import {
@@ -56,7 +57,7 @@ export function processConsolidationRequest(
 
   // Verify source withdrawal credentials
   const hasCorrectCredential = hasExecutionWithdrawalCredential(sourceValidator.withdrawalCredentials);
-  const isCorrectSourceAddress = Buffer.compare(sourceWithdrawalAddress, sourceAddress) === 0;
+  const isCorrectSourceAddress = byteArrayEquals(sourceWithdrawalAddress, sourceAddress);
   if (!(hasCorrectCredential && isCorrectSourceAddress)) {
     return;
   }
@@ -124,7 +125,7 @@ function isValidSwitchToCompoundRequest(
   const sourceValidator = state.validators.getReadonly(sourceIndex);
   const sourceWithdrawalAddress = sourceValidator.withdrawalCredentials.subarray(12);
   // Verify request has been authorized
-  if (Buffer.compare(sourceWithdrawalAddress, sourceAddress) !== 0) {
+  if (!byteArrayEquals(sourceWithdrawalAddress, sourceAddress)) {
     return false;
   }
 

package/src/block/processExecutionPayload.ts

@@ -1,7 +1,6 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
 import {ForkName, ForkSeq, isForkPostDeneb} from "@lodestar/params";
 import {BeaconBlockBody, BlindedBeaconBlockBody, deneb, isExecutionPayload} from "@lodestar/types";
-import {toHex, toRootHex} from "@lodestar/utils";
+import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateBellatrix, CachedBeaconStateCapella} from "../types.js";
 import {
   executionPayloadToPayloadHeader,

package/src/block/processExecutionPayloadBid.ts

@@ -1,12 +1,12 @@
 import {PublicKey, Signature, verify} from "@chainsafe/blst";
-import {byteArrayEquals} from "@chainsafe/ssz";
-import {BUILDER_INDEX_SELF_BUILD, DOMAIN_BEACON_BUILDER, ForkPostGloas, SLOTS_PER_EPOCH} from "@lodestar/params";
+import {BUILDER_INDEX_SELF_BUILD, ForkPostGloas, SLOTS_PER_EPOCH} from "@lodestar/params";
 import {BeaconBlock, gloas, ssz} from "@lodestar/types";
-import {toHex, toRootHex} from "@lodestar/utils";
+import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
 import {G2_POINT_AT_INFINITY} from "../constants/constants.ts";
+import {getExecutionPayloadBidSigningRoot} from "../signatureSets/executionPayloadBid.js";
 import {CachedBeaconStateGloas} from "../types.ts";
 import {canBuilderCoverBid, isActiveBuilder} from "../util/gloas.ts";
-import {computeSigningRoot, getCurrentEpoch, getRandaoMix} from "../util/index.ts";
+import {getCurrentEpoch, getRandaoMix} from "../util/index.ts";
 
 export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block: BeaconBlock<ForkPostGloas>): void {
   const signedBid = block.body.signedExecutionPayloadBid;
@@ -27,7 +27,7 @@ export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block:
     const builder = state.builders.getReadonly(builderIndex);
 
     // Verify that the builder is active
-    if (!isActiveBuilder(state, builderIndex)) {
+    if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
       throw Error(`Invalid execution payload bid: builder ${builderIndex} is not active`);
     }
 
@@ -84,8 +84,7 @@ function verifyExecutionPayloadBidSignature(
   pubkey: Uint8Array,
   signedBid: gloas.SignedExecutionPayloadBid
 ): boolean {
-  const domain = state.config.getDomain(state.slot, DOMAIN_BEACON_BUILDER);
-  const signingRoot = computeSigningRoot(ssz.gloas.ExecutionPayloadBid, signedBid.message, domain);
+  const signingRoot = getExecutionPayloadBidSigningRoot(state.config, state.slot, signedBid.message);
 
   try {
     const publicKey = PublicKey.fromBytes(pubkey);

package/src/block/processExecutionPayloadEnvelope.ts

@@ -1,5 +1,4 @@
 import {PublicKey, Signature, verify} from "@chainsafe/blst";
-import {byteArrayEquals} from "@chainsafe/ssz";
 import {
   BUILDER_INDEX_SELF_BUILD,
   DOMAIN_BEACON_BUILDER,
@@ -7,7 +6,7 @@ import {
   SLOTS_PER_HISTORICAL_ROOT,
 } from "@lodestar/params";
 import {gloas, ssz} from "@lodestar/types";
-import {toHex, toRootHex} from "@lodestar/utils";
+import {byteArrayEquals, toHex, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateGloas} from "../types.ts";
 import {computeSigningRoot, computeTimeAtSlot} from "../util/index.ts";
 import {processConsolidationRequest} from "./processConsolidationRequest.ts";

package/src/block/processPayloadAttestation.ts

@@ -1,5 +1,5 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
 import {gloas} from "@lodestar/types";
+import {byteArrayEquals} from "@lodestar/utils";
 import {CachedBeaconStateGloas} from "../types.ts";
 import {isValidIndexedPayloadAttestation} from "./isValidIndexedPayloadAttestation.ts";
 

package/src/block/processProposerSlashing.ts

@@ -92,9 +92,9 @@ export function assertValidProposerSlashing(
 
   // verify signatures
   if (verifySignatures) {
-    const signatureSets = getProposerSlashingSignatureSets(config, index2pubkey, stateSlot, proposerSlashing);
+    const signatureSets = getProposerSlashingSignatureSets(config, stateSlot, proposerSlashing);
     for (let i = 0; i < signatureSets.length; i++) {
-      if (!verifySignatureSet(signatureSets[i])) {
+      if (!verifySignatureSet(signatureSets[i], index2pubkey)) {
         throw new Error(`ProposerSlashing header${i + 1} signature invalid`);
       }
     }

package/src/block/processSyncCommittee.ts

@@ -1,8 +1,7 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_SYNC_COMMITTEE, SYNC_COMMITTEE_SIZE} from "@lodestar/params";
 import {altair, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
+import {byteArrayEquals} from "@lodestar/utils";
 import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
 import {G2_POINT_AT_INFINITY} from "../constants/index.js";
 import {CachedBeaconStateAllForks} from "../types.js";
@@ -28,13 +27,12 @@ export function processSyncAggregate(
     const participantIndices = block.body.syncAggregate.syncCommitteeBits.intersectValues(committeeIndices);
     const signatureSet = getSyncCommitteeSignatureSet(
       state.config,
-      state.epochCtx.index2pubkey,
       state.epochCtx.currentSyncCommitteeIndexed,
       block,
       participantIndices
     );
-    // When there's no participation we consider the signature valid and just ignore i
-    if (signatureSet !== null && !verifySignatureSet(signatureSet)) {
+    // When there's no participation we consider the signature valid and just ignore it
+    if (signatureSet !== null && !verifySignatureSet(signatureSet, state.epochCtx.index2pubkey)) {
       throw Error("Sync committee signature invalid");
     }
   }
@@ -73,7 +71,6 @@ export function processSyncAggregate(
 
 export function getSyncCommitteeSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   currentSyncCommitteeIndexed: SyncCommitteeCache,
   block: altair.BeaconBlock,
   /** Optional parameter to prevent computing it twice */
@@ -122,7 +119,7 @@ export function getSyncCommitteeSignatureSet(
 
   return {
     type: SignatureSetType.aggregate,
-    pubkeys: participantIndices.map((i) => index2pubkey[i]),
+    indices: participantIndices,
     signingRoot: computeSigningRoot(ssz.Root, rootSigned, domain),
     signature,
   };

package/src/block/processVoluntaryExit.ts

@@ -49,7 +49,7 @@ export function processVoluntaryExit(
     const builder = stateGloas.builders.getReadonly(builderIndex);
 
     // Verify the builder is active
-    if (!isActiveBuilder(stateGloas, builderIndex)) {
+    if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
       throw Error(`Builder ${builderIndex} is not active`);
     }
 

package/src/block/processWithdrawals.ts

@@ -1,4 +1,3 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
 import {
   FAR_FUTURE_EPOCH,
   ForkSeq,
@@ -10,7 +9,7 @@ import {
   MIN_ACTIVATION_BALANCE,
 } from "@lodestar/params";
 import {BuilderIndex, ValidatorIndex, capella, ssz} from "@lodestar/types";
-import {toRootHex} from "@lodestar/utils";
+import {byteArrayEquals, toRootHex} from "@lodestar/utils";
 import {CachedBeaconStateCapella, CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {
   convertBuilderIndexToValidatorIndex,

package/src/epoch/processPendingAttestations.ts

@@ -1,5 +1,5 @@
-import {byteArrayEquals} from "@chainsafe/ssz";
 import {Epoch, phase0} from "@lodestar/types";
+import {byteArrayEquals} from "@lodestar/utils";
 import {CachedBeaconStatePhase0} from "../types.js";
 import {computeStartSlotAtEpoch, getBlockRootAtSlot} from "../util/index.js";
 

package/src/signatureSets/attesterSlashings.ts

@@ -1,38 +1,34 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
 import {AttesterSlashing, IndexedAttestationBigint, SignedBeaconBlock, Slot, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot, computeStartSlotAtEpoch} from "../util/index.js";
 
 /** Get signature sets from all AttesterSlashing objects in a block */
 export function getAttesterSlashingsSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlock: SignedBeaconBlock
 ): ISignatureSet[] {
   // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
   // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
   const blockSlot = signedBlock.message.slot;
   return signedBlock.message.body.attesterSlashings.flatMap((attesterSlashing) =>
-    getAttesterSlashingSignatureSets(config, index2pubkey, blockSlot, attesterSlashing)
+    getAttesterSlashingSignatureSets(config, blockSlot, attesterSlashing)
   );
 }
 
 /** Get signature sets from a single AttesterSlashing object */
 export function getAttesterSlashingSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   attesterSlashing: AttesterSlashing
 ): ISignatureSet[] {
   return [attesterSlashing.attestation1, attesterSlashing.attestation2].map((attestation) =>
-    getIndexedAttestationBigintSignatureSet(config, index2pubkey, stateSlot, attestation)
+    getIndexedAttestationBigintSignatureSet(config, stateSlot, attestation)
   );
 }
 
 export function getIndexedAttestationBigintSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   indexedAttestation: IndexedAttestationBigint
 ): ISignatureSet {
@@ -41,7 +37,7 @@ export function getIndexedAttestationBigintSignatureSet(
 
   return {
     type: SignatureSetType.aggregate,
-    pubkeys: indexedAttestation.attestingIndices.map((i) => index2pubkey[i]),
+    indices: indexedAttestation.attestingIndices.map((i) => Number(i)),
     signingRoot: computeSigningRoot(ssz.phase0.AttestationDataBigint, indexedAttestation.data, domain),
     signature: indexedAttestation.signature,
   };

package/src/signatureSets/blsToExecutionChange.ts

@@ -2,7 +2,7 @@ import {PublicKey} from "@chainsafe/blst";
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BLS_TO_EXECUTION_CHANGE, ForkName} from "@lodestar/params";
 import {capella, ssz} from "@lodestar/types";
-import {ISignatureSet, SignatureSetType, computeSigningRoot, verifySignatureSet} from "../util/index.js";
+import {SignatureSetType, SingleSignatureSet, computeSigningRoot, verifySignatureSet} from "../util/index.js";
 
 export function verifyBlsToExecutionChangeSignature(
   config: BeaconConfig,
@@ -17,7 +17,7 @@ export function verifyBlsToExecutionChangeSignature(
 export function getBlsToExecutionChangeSignatureSet(
   config: BeaconConfig,
   signedBLSToExecutionChange: capella.SignedBLSToExecutionChange
-): ISignatureSet {
+): SingleSignatureSet {
   // signatureFork for signing domain is fixed
   const signatureFork = ForkName.phase0;
   const domain = config.getDomainAtFork(signatureFork, DOMAIN_BLS_TO_EXECUTION_CHANGE);
@@ -35,7 +35,7 @@ export function getBlsToExecutionChangeSignatureSet(
 export function getBlsToExecutionChangeSignatureSets(
   config: BeaconConfig,
   signedBlock: capella.SignedBeaconBlock
-): ISignatureSet[] {
+): SingleSignatureSet[] {
   return signedBlock.message.body.blsToExecutionChanges.map((blsToExecutionChange) =>
     getBlsToExecutionChangeSignatureSet(config, blsToExecutionChange)
   );

package/src/signatureSets/executionPayloadBid.ts

@@ -0,0 +1,14 @@
+import {BeaconConfig} from "@lodestar/config";
+import {DOMAIN_BEACON_BUILDER} from "@lodestar/params";
+import {Slot, gloas, ssz} from "@lodestar/types";
+import {computeSigningRoot} from "../util/index.js";
+
+export function getExecutionPayloadBidSigningRoot(
+  config: BeaconConfig,
+  stateSlot: Slot,
+  bid: gloas.ExecutionPayloadBid
+): Uint8Array {
+  const domain = config.getDomain(stateSlot, DOMAIN_BEACON_BUILDER);
+
+  return computeSigningRoot(ssz.gloas.ExecutionPayloadBid, bid, domain);
+}

package/src/signatureSets/executionPayloadEnvelope.ts

@@ -0,0 +1,13 @@
+import {BeaconConfig} from "@lodestar/config";
+import {DOMAIN_BEACON_BUILDER} from "@lodestar/params";
+import {gloas, ssz} from "@lodestar/types";
+import {computeSigningRoot} from "../util/index.js";
+
+export function getExecutionPayloadEnvelopeSigningRoot(
+  config: BeaconConfig,
+  envelope: gloas.ExecutionPayloadEnvelope
+): Uint8Array {
+  const domain = config.getDomain(envelope.slot, DOMAIN_BEACON_BUILDER);
+
+  return computeSigningRoot(ssz.gloas.ExecutionPayloadEnvelope, envelope, domain);
+}

package/src/signatureSets/index.ts

@@ -2,7 +2,6 @@ import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq} from "@lodestar/params";
 import {IndexedAttestation, SignedBeaconBlock, altair, capella} from "@lodestar/types";
 import {getSyncCommitteeSignatureSet} from "../block/processSyncCommittee.js";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {SyncCommitteeCache} from "../cache/syncCommitteeCache.js";
 import {ISignatureSet} from "../util/index.js";
 import {getAttesterSlashingsSignatureSets} from "./attesterSlashings.js";
@@ -15,6 +14,8 @@ import {getVoluntaryExitsSignatureSets} from "./voluntaryExits.js";
 
 export * from "./attesterSlashings.js";
 export * from "./blsToExecutionChange.js";
+export * from "./executionPayloadBid.js";
+export * from "./executionPayloadEnvelope.js";
 export * from "./indexedAttestation.js";
 export * from "./indexedPayloadAttestation.js";
 export * from "./proposer.js";
@@ -28,7 +29,6 @@ export * from "./voluntaryExits.js";
  */
 export function getBlockSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   currentSyncCommitteeIndexed: SyncCommitteeCache,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[],
@@ -41,22 +41,21 @@ export function getBlockSignatureSets(
   const fork = config.getForkSeq(signedBlock.message.slot);
 
   const signatureSets = [
-    getRandaoRevealSignatureSet(config, index2pubkey, signedBlock.message),
-    ...getProposerSlashingsSignatureSets(config, index2pubkey, signedBlock),
-    ...getAttesterSlashingsSignatureSets(config, index2pubkey, signedBlock),
-    ...getAttestationsSignatureSets(config, index2pubkey, signedBlock, indexedAttestations),
-    ...getVoluntaryExitsSignatureSets(config, index2pubkey, signedBlock),
+    getRandaoRevealSignatureSet(config, signedBlock.message),
+    ...getProposerSlashingsSignatureSets(config, signedBlock),
+    ...getAttesterSlashingsSignatureSets(config, signedBlock),
+    ...getAttestationsSignatureSets(config, signedBlock, indexedAttestations),
+    ...getVoluntaryExitsSignatureSets(config, signedBlock),
   ];
 
   if (!opts?.skipProposerSignature) {
-    signatureSets.push(getBlockProposerSignatureSet(config, index2pubkey, signedBlock));
+    signatureSets.push(getBlockProposerSignatureSet(config, signedBlock));
   }
 
   // Only after altair fork, validate tSyncCommitteeSignature
   if (fork >= ForkSeq.altair) {
     const syncCommitteeSignatureSet = getSyncCommitteeSignatureSet(
       config,
-      index2pubkey,
       currentSyncCommitteeIndexed,
       (signedBlock as altair.SignedBeaconBlock).message
     );

package/src/signatureSets/indexedAttestation.ts

@@ -1,7 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_ATTESTER} from "@lodestar/params";
 import {IndexedAttestation, SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {
   ISignatureSet,
   computeSigningRoot,
@@ -22,13 +21,12 @@ export function getAttestationDataSigningRoot(
 
 export function getAttestationWithIndicesSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   attestation: Pick<phase0.Attestation, "data" | "signature">,
   attestingIndices: number[]
 ): ISignatureSet {
   return createAggregateSignatureSetFromComponents(
-    attestingIndices.map((i) => index2pubkey[i]),
+    attestingIndices,
     getAttestationDataSigningRoot(config, stateSlot, attestation.data),
     attestation.signature
   );
@@ -36,13 +34,11 @@ export function getAttestationWithIndicesSignatureSet(
 
 export function getIndexedAttestationSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   indexedAttestation: IndexedAttestation
 ): ISignatureSet {
   return getAttestationWithIndicesSignatureSet(
     config,
-    index2pubkey,
     stateSlot,
     indexedAttestation,
     indexedAttestation.attestingIndices
@@ -51,7 +47,6 @@ export function getIndexedAttestationSignatureSet(
 
 export function getAttestationsSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlock: SignedBeaconBlock,
   indexedAttestations: IndexedAttestation[]
 ): ISignatureSet[] {
@@ -64,6 +59,6 @@ export function getAttestationsSignatureSets(
   // and the same epoch when we verify blocks in batch in beacon-node. So we can safely use block.slot here.
   const blockSlot = signedBlock.message.slot;
   return indexedAttestations.map((indexedAttestation) =>
-    getIndexedAttestationSignatureSet(config, index2pubkey, blockSlot, indexedAttestation)
+    getIndexedAttestationSignatureSet(config, blockSlot, indexedAttestation)
   );
 }

package/src/signatureSets/indexedPayloadAttestation.ts

@@ -1,24 +1,26 @@
+import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_PTC_ATTESTER} from "@lodestar/params";
-import {gloas, ssz} from "@lodestar/types";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {ISignatureSet, computeSigningRoot, createAggregateSignatureSetFromComponents} from "../util/index.ts";
+import {Slot, gloas, ssz} from "@lodestar/types";
+import {CachedBeaconStateGloas} from "../types.js";
+import {ISignatureSet, computeSigningRoot, createAggregateSignatureSetFromComponents} from "../util/index.js";
 
 export function getIndexedPayloadAttestationSignatureSet(
   state: CachedBeaconStateGloas,
   indexedPayloadAttestation: gloas.IndexedPayloadAttestation
 ): ISignatureSet {
   return createAggregateSignatureSetFromComponents(
-    indexedPayloadAttestation.attestingIndices.map((i) => state.epochCtx.index2pubkey[i]),
-    getPayloadAttestationDataSigningRoot(state, indexedPayloadAttestation.data),
+    indexedPayloadAttestation.attestingIndices,
+    getPayloadAttestationDataSigningRoot(state.config, state.slot, indexedPayloadAttestation.data),
     indexedPayloadAttestation.signature
   );
 }
 
 export function getPayloadAttestationDataSigningRoot(
-  state: CachedBeaconStateGloas,
+  config: BeaconConfig,
+  stateSlot: Slot,
   data: gloas.PayloadAttestationData
 ): Uint8Array {
-  const domain = state.config.getDomain(state.slot, DOMAIN_PTC_ATTESTER);
+  const domain = config.getDomain(stateSlot, DOMAIN_PTC_ATTESTER);
 
   return computeSigningRoot(ssz.gloas.PayloadAttestationData, data, domain);
 }

package/src/signatureSets/proposer.ts

@@ -10,13 +10,12 @@ export function verifyProposerSignature(
   index2pubkey: Index2PubkeyCache,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): boolean {
-  const signatureSet = getBlockProposerSignatureSet(config, index2pubkey, signedBlock);
-  return verifySignatureSet(signatureSet);
+  const signatureSet = getBlockProposerSignatureSet(config, signedBlock);
+  return verifySignatureSet(signatureSet, index2pubkey);
 }
 
 export function getBlockProposerSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlock: SignedBeaconBlock | SignedBlindedBeaconBlock
 ): ISignatureSet {
   // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
@@ -29,8 +28,8 @@ export function getBlockProposerSignatureSet(
     : config.getForkTypes(signedBlock.message.slot).BeaconBlock;
 
   return {
-    type: SignatureSetType.single,
-    pubkey: index2pubkey[signedBlock.message.proposerIndex],
+    type: SignatureSetType.indexed,
+    index: signedBlock.message.proposerIndex,
     signingRoot: computeSigningRoot(blockType, signedBlock.message, domain),
     signature: signedBlock.signature,
   };
@@ -38,32 +37,29 @@ export function getBlockProposerSignatureSet(
 
 export function getBlockHeaderProposerSignatureSetByParentStateSlot(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   parentStateSlot: Slot,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, parentStateSlot);
+  return getBlockHeaderProposerSignatureSet(config, signedBlockHeader, parentStateSlot);
 }
 
 export function getBlockHeaderProposerSignatureSetByHeaderSlot(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlockHeader: phase0.SignedBeaconBlockHeader
 ) {
-  return getBlockHeaderProposerSignatureSet(config, index2pubkey, signedBlockHeader, signedBlockHeader.message.slot);
+  return getBlockHeaderProposerSignatureSet(config, signedBlockHeader, signedBlockHeader.message.slot);
 }
 
 function getBlockHeaderProposerSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   signedBlockHeader: phase0.SignedBeaconBlockHeader,
   domainSlot: Slot
 ): ISignatureSet {
   const domain = config.getDomain(domainSlot, DOMAIN_BEACON_PROPOSER, signedBlockHeader.message.slot);
 
   return {
-    type: SignatureSetType.single,
-    pubkey: index2pubkey[signedBlockHeader.message.proposerIndex],
+    type: SignatureSetType.indexed,
+    index: signedBlockHeader.message.proposerIndex,
     signingRoot: computeSigningRoot(ssz.phase0.BeaconBlockHeader, signedBlockHeader.message, domain),
     signature: signedBlockHeader.signature,
   };