@lodestar/state-transition 1.40.0-dev.4acd3ce568 → 1.40.0-dev.4e6ba60398

package/src/block/processWithdrawalRequest.ts

@@ -42,7 +42,7 @@ export function processWithdrawalRequest(
   }
 
   // TODO Electra: Consider caching pendingPartialWithdrawals
-  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(fork, state, validatorIndex);
+  const pendingBalanceToWithdraw = getPendingBalanceToWithdraw(state, validatorIndex);
   const validatorBalance = state.balances.get(validatorIndex);
 
   if (isFullExitRequest) {

package/src/block/processWithdrawals.ts

@@ -132,6 +132,9 @@ function getBuilderWithdrawals(
   builderBalanceAfterWithdrawals: Map<number, number>
 ): {builderWithdrawals: capella.Withdrawal[]; withdrawalIndex: number; processedCount: number} {
   const withdrawalsLimit = MAX_WITHDRAWALS_PER_PAYLOAD - 1;
+  if (priorWithdrawals.length > withdrawalsLimit) {
+    throw Error(`Prior withdrawals exceed limit: ${priorWithdrawals.length} > ${withdrawalsLimit}`);
+  }
   const builderWithdrawals: capella.Withdrawal[] = [];
   const allBuilderPendingWithdrawals =
     state.builderPendingWithdrawals.length <= MAX_WITHDRAWALS_PER_PAYLOAD
@@ -182,6 +185,9 @@ function getBuildersSweepWithdrawals(
   builderBalanceAfterWithdrawals: Map<number, number>
 ): {buildersSweepWithdrawals: capella.Withdrawal[]; withdrawalIndex: number; processedCount: number} {
   const withdrawalsLimit = MAX_WITHDRAWALS_PER_PAYLOAD - 1;
+  if (numPriorWithdrawal > withdrawalsLimit) {
+    throw Error(`Prior withdrawals exceed limit: ${numPriorWithdrawal} > ${withdrawalsLimit}`);
+  }
   const buildersSweepWithdrawals: capella.Withdrawal[] = [];
   const epoch = state.epochCtx.epoch;
   const builders = state.builders;

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,
   };

package/src/signatureSets/proposerSlashings.ts

@@ -1,7 +1,6 @@
 import {BeaconConfig} from "@lodestar/config";
 import {DOMAIN_BEACON_PROPOSER} from "@lodestar/params";
 import {SignedBeaconBlock, Slot, phase0, ssz} from "@lodestar/types";
-import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index.js";
 
 /**
@@ -9,11 +8,10 @@ import {ISignatureSet, SignatureSetType, computeSigningRoot} from "../util/index
  */
 export function getProposerSlashingSignatureSets(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   proposerSlashing: phase0.ProposerSlashing
 ): ISignatureSet[] {
-  const pubkey = index2pubkey[proposerSlashing.signedHeader1.message.proposerIndex];
+  const proposerIndex = proposerSlashing.signedHeader1.message.proposerIndex;
 
   // In state transition, ProposerSlashing headers are only partially validated. Their slot could be higher than the
   // clock and the slashing would still be valid. Must use bigint variants to hash correctly to all possible values
@@ -21,8 +19,8 @@ export function getProposerSlashingSignatureSets(
     const domain = config.getDomain(stateSlot, DOMAIN_BEACON_PROPOSER, Number(signedHeader.message.slot as bigint));
 
     return {
-      type: SignatureSetType.single,
-      pubkey,
+      type: SignatureSetType.indexed,
+      index: proposerIndex,
       signingRoot: computeSigningRoot(ssz.phase0.BeaconBlockHeaderBigint, signedHeader.message, domain),
       signature: signedHeader.signature,
     };
@@ -31,13 +29,12 @@ export function getProposerSlashingSignatureSets(
 
 export function getProposerSlashingsSignatureSets(
   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.proposerSlashings.flatMap((proposerSlashing) =>
-    getProposerSlashingSignatureSets(config, index2pubkey, blockSlot, proposerSlashing)
+    getProposerSlashingSignatureSets(config, blockSlot, proposerSlashing)
   );
 }

package/src/signatureSets/randao.ts

@@ -15,17 +15,13 @@ export function verifyRandaoSignature(
   index2pubkey: Index2PubkeyCache,
   block: BeaconBlock
 ): boolean {
-  return verifySignatureSet(getRandaoRevealSignatureSet(config, index2pubkey, block));
+  return verifySignatureSet(getRandaoRevealSignatureSet(config, block), index2pubkey);
 }
 
 /**
  * Extract signatures to allow validating all block signatures at once
  */
-export function getRandaoRevealSignatureSet(
-  config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
-  block: BeaconBlock
-): ISignatureSet {
+export function getRandaoRevealSignatureSet(config: BeaconConfig, block: BeaconBlock): ISignatureSet {
   // should not get epoch from epochCtx
   const epoch = computeEpochAtSlot(block.slot);
   // the getDomain() api requires the state slot as 1st param, however it's the same to block.slot in state-transition
@@ -33,8 +29,8 @@ export function getRandaoRevealSignatureSet(
   const domain = config.getDomain(block.slot, DOMAIN_RANDAO, block.slot);
 
   return {
-    type: SignatureSetType.single,
-    pubkey: index2pubkey[block.proposerIndex],
+    type: SignatureSetType.indexed,
+    index: block.proposerIndex,
     signingRoot: computeSigningRoot(ssz.Epoch, epoch, domain),
     signature: block.body.randaoReveal,
   };

package/src/signatureSets/voluntaryExits.ts

@@ -15,7 +15,7 @@ export function verifyVoluntaryExitSignature(
   stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): boolean {
-  return verifySignatureSet(getVoluntaryExitSignatureSet(config, index2pubkey, stateSlot, signedVoluntaryExit));
+  return verifySignatureSet(getVoluntaryExitSignatureSet(config, stateSlot, signedVoluntaryExit), index2pubkey);
 }
 
 /**
@@ -23,7 +23,6 @@ export function verifyVoluntaryExitSignature(
  */
 export function getVoluntaryExitSignatureSet(
   config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
   stateSlot: Slot,
   signedVoluntaryExit: phase0.SignedVoluntaryExit
 ): ISignatureSet {
@@ -31,22 +30,18 @@ export function getVoluntaryExitSignatureSet(
   const domain = config.getDomainForVoluntaryExit(stateSlot, messageSlot);
 
   return {
-    type: SignatureSetType.single,
-    pubkey: index2pubkey[signedVoluntaryExit.message.validatorIndex],
+    type: SignatureSetType.indexed,
+    index: signedVoluntaryExit.message.validatorIndex,
     signingRoot: computeSigningRoot(ssz.phase0.VoluntaryExit, signedVoluntaryExit.message, domain),
     signature: signedVoluntaryExit.signature,
   };
 }
 
-export function getVoluntaryExitsSignatureSets(
-  config: BeaconConfig,
-  index2pubkey: Index2PubkeyCache,
-  signedBlock: SignedBeaconBlock
-): ISignatureSet[] {
+export function getVoluntaryExitsSignatureSets(config: BeaconConfig, 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.voluntaryExits.map((voluntaryExit) =>
-    getVoluntaryExitSignatureSet(config, index2pubkey, blockSlot, voluntaryExit)
+    getVoluntaryExitSignatureSet(config, blockSlot, voluntaryExit)
   );
 }

package/src/util/gloas.ts

@@ -9,11 +9,12 @@ import {
   MIN_DEPOSIT_AMOUNT,
   SLOTS_PER_EPOCH,
 } from "@lodestar/params";
+import {BuilderIndex, Epoch, ValidatorIndex, gloas} from "@lodestar/types";
 import {AttestationData} from "@lodestar/types/phase0";
-import {CachedBeaconStateGloas} from "../types.ts";
-import {getBlockRootAtSlot} from "./blockRoot.ts";
-import {computeEpochAtSlot} from "./epoch.ts";
-import {RootCache} from "./rootCache.ts";
+import {CachedBeaconStateGloas} from "../types.js";
+import {getBlockRootAtSlot} from "./blockRoot.js";
+import {computeEpochAtSlot} from "./epoch.js";
+import {RootCache} from "./rootCache.js";
 
 export function isBuilderWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
   return withdrawalCredentials[0] === BUILDER_WITHDRAWAL_PREFIX;
@@ -39,7 +40,7 @@ export function isBuilderIndex(validatorIndex: number): boolean {
  * Convert a builder index to a flagged validator index for use in Withdrawal containers.
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-convert_builder_index_to_validator_index
  */
-export function convertBuilderIndexToValidatorIndex(builderIndex: number): number {
+export function convertBuilderIndexToValidatorIndex(builderIndex: BuilderIndex): ValidatorIndex {
   return builderIndex | BUILDER_INDEX_FLAG;
 }
 
@@ -47,7 +48,7 @@ export function convertBuilderIndexToValidatorIndex(builderIndex: number): numbe
  * Convert a flagged validator index back to a builder index.
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-convert_validator_index_to_builder_index
  */
-export function convertValidatorIndexToBuilderIndex(validatorIndex: number): number {
+export function convertValidatorIndexToBuilderIndex(validatorIndex: ValidatorIndex): BuilderIndex {
   return validatorIndex & ~BUILDER_INDEX_FLAG;
 }
 
@@ -55,10 +56,7 @@ export function convertValidatorIndexToBuilderIndex(validatorIndex: number): num
  * Check if a builder is active (deposited and not yet withdrawable).
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#isactivebuilder
  */
-export function isActiveBuilder(state: CachedBeaconStateGloas, builderIndex: number): boolean {
-  const builder = state.builders.getReadonly(builderIndex);
-  const finalizedEpoch = state.finalizedCheckpoint.epoch;
-
+export function isActiveBuilder(builder: gloas.Builder, finalizedEpoch: Epoch): boolean {
   return builder.depositEpoch < finalizedEpoch && builder.withdrawableEpoch === FAR_FUTURE_EPOCH;
 }
 
@@ -66,7 +64,10 @@ export function isActiveBuilder(state: CachedBeaconStateGloas, builderIndex: num
  * Get the total pending balance to withdraw for a builder (from withdrawals + payments).
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-get_pending_balance_to_withdraw_for_builder
  */
-export function getPendingBalanceToWithdrawForBuilder(state: CachedBeaconStateGloas, builderIndex: number): number {
+export function getPendingBalanceToWithdrawForBuilder(
+  state: CachedBeaconStateGloas,
+  builderIndex: BuilderIndex
+): number {
   let pendingBalance = 0;
 
   // Sum pending withdrawals
@@ -92,7 +93,11 @@ export function getPendingBalanceToWithdrawForBuilder(state: CachedBeaconStateGl
  * Check if a builder has sufficient balance to cover a bid amount.
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-can_builder_cover_bid
  */
-export function canBuilderCoverBid(state: CachedBeaconStateGloas, builderIndex: number, bidAmount: number): boolean {
+export function canBuilderCoverBid(
+  state: CachedBeaconStateGloas,
+  builderIndex: BuilderIndex,
+  bidAmount: number
+): boolean {
   const builder = state.builders.getReadonly(builderIndex);
   const pendingBalance = getPendingBalanceToWithdrawForBuilder(state, builderIndex);
   const minBalance = MIN_DEPOSIT_AMOUNT + pendingBalance;
@@ -108,7 +113,7 @@ export function canBuilderCoverBid(state: CachedBeaconStateGloas, builderIndex:
  * Initiate a builder exit by setting their withdrawable epoch.
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-initiate_builder_exit
  */
-export function initiateBuilderExit(state: CachedBeaconStateGloas, builderIndex: number): void {
+export function initiateBuilderExit(state: CachedBeaconStateGloas, builderIndex: BuilderIndex): void {
   const builder = state.builders.get(builderIndex);
 
   // Return if builder already initiated exit
@@ -127,7 +132,7 @@ export function initiateBuilderExit(state: CachedBeaconStateGloas, builderIndex:
  *
  * May consider builder pubkey cache if performance becomes an issue.
  */
-export function findBuilderIndexByPubkey(state: CachedBeaconStateGloas, pubkey: Uint8Array): number | null {
+export function findBuilderIndexByPubkey(state: CachedBeaconStateGloas, pubkey: Uint8Array): BuilderIndex | null {
   for (let i = 0; i < state.builders.length; i++) {
     if (byteArrayEquals(state.builders.getReadonly(i).pubkey, pubkey)) {
       return i;

package/src/util/index.ts

@@ -15,6 +15,7 @@ export * from "./epochShuffling.js";
 export * from "./execution.js";
 export * from "./finality.js";
 export * from "./genesis.js";
+export * from "./gloas.js";
 export * from "./interop.js";
 export * from "./loadState/index.js";
 export * from "./rootCache.js";

package/src/util/interop.ts

@@ -1,4 +1,4 @@
-import {toBufferBE} from "bigint-buffer";
+import {toBufferBE} from "@vekexasia/bigint-buffer2";
 import {digest} from "@chainsafe/as-sha256";
 import {SecretKey} from "@chainsafe/blst";
 import {bytesToBigInt, intToBytes} from "@lodestar/utils";