@lodestar/state-transition 1.39.1 → 1.40.0-dev.1020f27ca9

package/package.json

@@ -11,7 +11,7 @@
   "bugs": {
     "url": "https://github.com/ChainSafe/lodestar/issues"
   },
-  "version": "1.39.1",
+  "version": "1.40.0-dev.1020f27ca9",
   "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.39.1",
-    "@lodestar/params": "^1.39.1",
-    "@lodestar/types": "^1.39.1",
-    "@lodestar/utils": "^1.39.1",
-    "bigint-buffer": "^1.1.5"
+    "@lodestar/config": "^1.40.0-dev.1020f27ca9",
+    "@lodestar/params": "^1.40.0-dev.1020f27ca9",
+    "@lodestar/types": "^1.40.0-dev.1020f27ca9",
+    "@lodestar/utils": "^1.40.0-dev.1020f27ca9",
+    "@vekexasia/bigint-buffer2": "^1.0.4"
   },
   "devDependencies": {
-    "@lodestar/api": "^1.39.1"
+    "@lodestar/api": "^1.40.0-dev.1020f27ca9"
   },
   "keywords": [
     "ethereum",
@@ -77,5 +77,5 @@
     "beacon",
     "blockchain"
   ],
-  "gitHead": "bc422a01a15970001ba5c94a36d09d6afd498483"
+  "gitHead": "48125446bbfccfe4301299cece757d92692a1a2a"
 }

package/src/block/index.ts

@@ -38,6 +38,7 @@ export {
 export * from "./externalData.js";
 export * from "./initiateValidatorExit.js";
 export * from "./isValidIndexedAttestation.js";
+export * from "./processDepositRequest.js";
 export * from "./processOperations.js";
 
 export function processBlock(

package/src/block/isValidIndexedAttestation.ts

@@ -1,9 +1,8 @@
 import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq, MAX_COMMITTEES_PER_SLOT, MAX_VALIDATORS_PER_COMMITTEE} from "@lodestar/params";
-import {IndexedAttestation, IndexedAttestationBigint} from "@lodestar/types";
+import {IndexedAttestation, IndexedAttestationBigint, Slot} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {getIndexedAttestationBigintSignatureSet, getIndexedAttestationSignatureSet} from "../signatureSets/index.js";
-import {CachedBeaconStateAllForks} from "../types.js";
 import {verifySignatureSet} from "../util/index.js";
 
 /**
@@ -12,16 +11,17 @@ import {verifySignatureSet} from "../util/index.js";
 export function isValidIndexedAttestation(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
+  validatorsLen: number,
   indexedAttestation: IndexedAttestation,
   verifySignature: boolean
 ): boolean {
-  if (!isValidIndexedAttestationIndices(state, indexedAttestation.attestingIndices)) {
+  if (!isValidIndexedAttestationIndices(config, stateSlot, validatorsLen, indexedAttestation.attestingIndices)) {
     return false;
   }
 
   if (verifySignature) {
-    return verifySignatureSet(getIndexedAttestationSignatureSet(config, index2pubkey, state.slot, indexedAttestation));
+    return verifySignatureSet(getIndexedAttestationSignatureSet(config, stateSlot, indexedAttestation), index2pubkey);
   }
   return true;
 }
@@ -29,17 +29,19 @@ export function isValidIndexedAttestation(
 export function isValidIndexedAttestationBigint(
   config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
+  validatorsLen: number,
   indexedAttestation: IndexedAttestationBigint,
   verifySignature: boolean
 ): boolean {
-  if (!isValidIndexedAttestationIndices(state, indexedAttestation.attestingIndices)) {
+  if (!isValidIndexedAttestationIndices(config, stateSlot, validatorsLen, indexedAttestation.attestingIndices)) {
     return false;
   }
 
   if (verifySignature) {
     return verifySignatureSet(
-      getIndexedAttestationBigintSignatureSet(config, index2pubkey, state.slot, indexedAttestation)
+      getIndexedAttestationBigintSignatureSet(config, stateSlot, indexedAttestation),
+      index2pubkey
     );
   }
   return true;
@@ -48,10 +50,15 @@ export function isValidIndexedAttestationBigint(
 /**
  * Check if `indexedAttestation` has sorted and unique indices and a valid aggregate signature.
  */
-export function isValidIndexedAttestationIndices(state: CachedBeaconStateAllForks, indices: number[]): boolean {
+export function isValidIndexedAttestationIndices(
+  config: BeaconConfig,
+  stateSlot: Slot,
+  validatorsLen: number,
+  indices: number[]
+): boolean {
   // verify max number of indices
   const maxIndices =
-    state.config.getForkSeq(state.slot) >= ForkSeq.electra
+    config.getForkSeq(stateSlot) >= ForkSeq.electra
       ? MAX_VALIDATORS_PER_COMMITTEE * MAX_COMMITTEES_PER_SLOT
       : MAX_VALIDATORS_PER_COMMITTEE;
   if (!(indices.length > 0 && indices.length <= maxIndices)) {
@@ -68,9 +75,8 @@ export function isValidIndexedAttestationIndices(state: CachedBeaconStateAllFork
   }
 
   // check if indices are out of bounds, by checking the highest index (since it is sorted)
-  // TODO - SLOW CODE - Does this .length check the tree and is expensive?
   const lastIndex = indices.at(-1);
-  if (lastIndex && lastIndex >= state.validators.length) {
+  if (lastIndex && lastIndex >= validatorsLen) {
     return false;
   }
 

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/processAttestationPhase0.ts

@@ -54,7 +54,8 @@ export function processAttestationPhase0(
     !isValidIndexedAttestation(
       state.config,
       epochCtx.index2pubkey,
-      state,
+      state.slot,
+      state.validators.length,
       epochCtx.getIndexedAttestation(ForkSeq.phase0, attestation),
       verifySignature
     )

package/src/block/processAttestationsAltair.ts

@@ -64,14 +64,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/processAttesterSlashing.ts

@@ -1,5 +1,6 @@
+import {BeaconConfig} from "@lodestar/config";
 import {ForkSeq} from "@lodestar/params";
-import {AttesterSlashing} from "@lodestar/types";
+import {AttesterSlashing, Slot} from "@lodestar/types";
 import {Index2PubkeyCache} from "../cache/pubkeyCache.js";
 import {CachedBeaconStateAllForks} from "../types.js";
 import {getAttesterSlashableIndices, isSlashableAttestationData, isSlashableValidator} from "../util/index.js";
@@ -19,7 +20,14 @@ export function processAttesterSlashing(
   verifySignatures = true
 ): void {
   const {epochCtx} = state;
-  assertValidAttesterSlashing(epochCtx.index2pubkey, state, attesterSlashing, verifySignatures);
+  assertValidAttesterSlashing(
+    state.config,
+    epochCtx.index2pubkey,
+    state.slot,
+    state.validators.length,
+    attesterSlashing,
+    verifySignatures
+  );
 
   const intersectingIndices = getAttesterSlashableIndices(attesterSlashing);
 
@@ -39,8 +47,10 @@ export function processAttesterSlashing(
 }
 
 export function assertValidAttesterSlashing(
+  config: BeaconConfig,
   index2pubkey: Index2PubkeyCache,
-  state: CachedBeaconStateAllForks,
+  stateSlot: Slot,
+  validatorsLen: number,
   attesterSlashing: AttesterSlashing,
   verifySignatures = true
 ): void {
@@ -55,7 +65,9 @@ export function assertValidAttesterSlashing(
   // be higher than the clock and the slashing would still be valid. Same applies to attestation data index, which
   // can be any arbitrary value. Must use bigint variants to hash correctly to all possible values
   for (const [i, attestation] of [attestation1, attestation2].entries()) {
-    if (!isValidIndexedAttestationBigint(state.config, index2pubkey, state, attestation, verifySignatures)) {
+    if (
+      !isValidIndexedAttestationBigint(config, index2pubkey, stateSlot, validatorsLen, attestation, verifySignatures)
+    ) {
       throw new Error(`AttesterSlashing attestation${i} is invalid`);
     }
   }

package/src/block/processBlsToExecutionChange.ts

@@ -1,7 +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 {verifyBlsToExecutionChangeSignature} from "../signatureSets/index.js";
 import {CachedBeaconStateCapella} from "../types.js";
@@ -12,12 +14,18 @@ export function processBlsToExecutionChange(
 ): void {
   const addressChange = signedBlsToExecutionChange.message;
 
-  const validation = isValidBlsToExecutionChange(state, signedBlsToExecutionChange, true);
+  if (addressChange.validatorIndex >= state.validators.length) {
+    throw Error(
+      `withdrawalValidatorIndex ${addressChange.validatorIndex} >= state.validators len ${state.validators.length}`
+    );
+  }
+
+  const validator = state.validators.get(addressChange.validatorIndex);
+  const validation = isValidBlsToExecutionChange(state.config, validator, signedBlsToExecutionChange, true);
   if (!validation.valid) {
     throw validation.error;
   }
 
-  const validator = state.validators.get(addressChange.validatorIndex);
   const newWithdrawalCredentials = new Uint8Array(32);
   newWithdrawalCredentials[0] = ETH1_ADDRESS_WITHDRAWAL_PREFIX;
   newWithdrawalCredentials.set(addressChange.toExecutionAddress, 12);
@@ -27,22 +35,13 @@ export function processBlsToExecutionChange(
 }
 
 export function isValidBlsToExecutionChange(
-  state: CachedBeaconStateCapella,
+  config: BeaconConfig,
+  validator: Validator,
   signedBLSToExecutionChange: capella.SignedBLSToExecutionChange,
   verifySignature = true
 ): {valid: true} | {valid: false; error: Error} {
   const addressChange = signedBLSToExecutionChange.message;
 
-  if (addressChange.validatorIndex >= state.validators.length) {
-    return {
-      valid: false,
-      error: Error(
-        `withdrawalValidatorIndex ${addressChange.validatorIndex} > state.validators len ${state.validators.length}`
-      ),
-    };
-  }
-
-  const validator = state.validators.getReadonly(addressChange.validatorIndex);
   const {withdrawalCredentials} = validator;
   if (withdrawalCredentials[0] !== BLS_WITHDRAWAL_PREFIX) {
     return {
@@ -65,7 +64,7 @@ export function isValidBlsToExecutionChange(
     };
   }
 
-  if (verifySignature && !verifyBlsToExecutionChangeSignature(state, signedBLSToExecutionChange)) {
+  if (verifySignature && !verifyBlsToExecutionChangeSignature(config, signedBLSToExecutionChange)) {
     return {
       valid: false,
       error: Error(

package/src/block/processConsolidationRequest.ts

@@ -1,4 +1,4 @@
-import {FAR_FUTURE_EPOCH, ForkSeq, MIN_ACTIVATION_BALANCE, PENDING_CONSOLIDATIONS_LIMIT} from "@lodestar/params";
+import {FAR_FUTURE_EPOCH, MIN_ACTIVATION_BALANCE, PENDING_CONSOLIDATIONS_LIMIT} from "@lodestar/params";
 import {electra, ssz} from "@lodestar/types";
 import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
 import {hasEth1WithdrawalCredential} from "../util/capella.js";
@@ -13,7 +13,6 @@ import {getConsolidationChurnLimit, getPendingBalanceToWithdraw, isActiveValidat
 
 // TODO Electra: Clean up necessary as there is a lot of overlap with isValidSwitchToCompoundRequest
 export function processConsolidationRequest(
-  fork: ForkSeq,
   state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   consolidationRequest: electra.ConsolidationRequest
 ): void {
@@ -83,7 +82,7 @@ export function processConsolidationRequest(
   }
 
   // Verify the source has no pending withdrawals in the queue
-  if (getPendingBalanceToWithdraw(fork, state, sourceIndex) > 0) {
+  if (getPendingBalanceToWithdraw(state, sourceIndex) > 0) {
     return;
   }
 

package/src/block/processDepositRequest.ts

@@ -1,21 +1,114 @@
-import {UNSET_DEPOSIT_REQUESTS_START_INDEX} from "@lodestar/params";
-import {electra, ssz} from "@lodestar/types";
+import {FAR_FUTURE_EPOCH, ForkSeq, UNSET_DEPOSIT_REQUESTS_START_INDEX} from "@lodestar/params";
+import {BLSPubkey, Bytes32, UintNum64, electra, ssz} from "@lodestar/types";
 import {CachedBeaconStateElectra, CachedBeaconStateGloas} from "../types.js";
+import {findBuilderIndexByPubkey, isBuilderWithdrawalCredential} from "../util/gloas.js";
+import {computeEpochAtSlot, isValidatorKnown} from "../util/index.js";
+import {isValidDepositSignature} from "./processDeposit.js";
+
+/**
+ * Apply a deposit for a builder. Either increases balance for existing builder or adds new builder to registry.
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-apply_deposit_for_builder
+ */
+export function applyDepositForBuilder(
+  state: CachedBeaconStateGloas,
+  pubkey: BLSPubkey,
+  withdrawalCredentials: Bytes32,
+  amount: UintNum64,
+  signature: Bytes32
+): void {
+  const builderIndex = findBuilderIndexByPubkey(state, pubkey);
+
+  if (builderIndex !== null) {
+    // Existing builder - increase balance
+    const builder = state.builders.get(builderIndex);
+    builder.balance += amount;
+  } else {
+    // New builder - verify signature and add to registry
+    if (isValidDepositSignature(state.config, pubkey, withdrawalCredentials, amount, signature)) {
+      addBuilderToRegistry(state, pubkey, withdrawalCredentials, amount);
+    }
+  }
+}
+
+/**
+ * Add a new builder to the builders registry.
+ * Reuses slots from exited and fully withdrawn builders if available.
+ */
+function addBuilderToRegistry(
+  state: CachedBeaconStateGloas,
+  pubkey: BLSPubkey,
+  withdrawalCredentials: Bytes32,
+  amount: UintNum64
+): void {
+  const currentEpoch = computeEpochAtSlot(state.slot);
+
+  // Try to find a reusable slot from an exited builder with zero balance
+  let builderIndex = state.builders.length;
+  for (let i = 0; i < state.builders.length; i++) {
+    const builder = state.builders.getReadonly(i);
+    if (builder.withdrawableEpoch <= currentEpoch && builder.balance === 0) {
+      builderIndex = i;
+      break;
+    }
+  }
+
+  // Create new builder
+  const newBuilder = ssz.gloas.Builder.toViewDU({
+    pubkey,
+    version: withdrawalCredentials[0],
+    executionAddress: withdrawalCredentials.subarray(12),
+    balance: amount,
+    depositEpoch: currentEpoch,
+    withdrawableEpoch: FAR_FUTURE_EPOCH,
+  });
+
+  if (builderIndex < state.builders.length) {
+    // Reuse existing slot
+    state.builders.set(builderIndex, newBuilder);
+  } else {
+    // Append to end
+    state.builders.push(newBuilder);
+  }
+}
 
 export function processDepositRequest(
+  fork: ForkSeq,
   state: CachedBeaconStateElectra | CachedBeaconStateGloas,
   depositRequest: electra.DepositRequest
 ): void {
-  if (state.depositRequestsStartIndex === UNSET_DEPOSIT_REQUESTS_START_INDEX) {
+  const {pubkey, withdrawalCredentials, amount, signature} = depositRequest;
+
+  // Check if this is a builder or validator deposit
+  if (fork >= ForkSeq.gloas) {
+    const stateGloas = state as CachedBeaconStateGloas;
+    const builderIndex = findBuilderIndexByPubkey(stateGloas, pubkey);
+    const validatorIndex = state.epochCtx.getValidatorIndex(pubkey);
+
+    // Regardless of the withdrawal credentials prefix, if a builder/validator
+    // already exists with this pubkey, apply the deposit to their balance
+    const isBuilder = builderIndex !== null;
+    const isValidator = isValidatorKnown(state, validatorIndex);
+    const isBuilderPrefix = isBuilderWithdrawalCredential(withdrawalCredentials);
+
+    // Route to builder if it's an existing builder OR has builder prefix and is not a validator
+    if (isBuilder || (isBuilderPrefix && !isValidator)) {
+      // Apply builder deposits immediately
+      applyDepositForBuilder(stateGloas, pubkey, withdrawalCredentials, amount, signature);
+      return;
+    }
+  }
+
+  // Only set deposit_requests_start_index in Electra fork, not Gloas
+  if (fork < ForkSeq.gloas && state.depositRequestsStartIndex === UNSET_DEPOSIT_REQUESTS_START_INDEX) {
     state.depositRequestsStartIndex = depositRequest.index;
   }
 
-  // Create pending deposit
+  // Add validator deposits to the queue
   const pendingDeposit = ssz.electra.PendingDeposit.toViewDU({
-    pubkey: depositRequest.pubkey,
-    withdrawalCredentials: depositRequest.withdrawalCredentials,
-    amount: depositRequest.amount,
-    signature: depositRequest.signature,
+    pubkey,
+    withdrawalCredentials,
+    amount,
+    signature,
     slot: state.slot,
   });
   state.pendingDeposits.push(pendingDeposit);

package/src/block/processExecutionPayloadBid.ts

@@ -1,68 +1,48 @@
 import {PublicKey, Signature, verify} from "@chainsafe/blst";
 import {byteArrayEquals} from "@chainsafe/ssz";
-import {
-  DOMAIN_BEACON_BUILDER,
-  FAR_FUTURE_EPOCH,
-  ForkPostGloas,
-  MIN_ACTIVATION_BALANCE,
-  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 {G2_POINT_AT_INFINITY} from "../constants/constants.ts";
+import {getExecutionPayloadBidSigningRoot} from "../signatureSets/executionPayloadBid.js";
 import {CachedBeaconStateGloas} from "../types.ts";
-import {hasBuilderWithdrawalCredential} from "../util/gloas.ts";
-import {computeSigningRoot, getCurrentEpoch, getRandaoMix, isActiveValidator} from "../util/index.ts";
+import {canBuilderCoverBid, isActiveBuilder} from "../util/gloas.ts";
+import {getCurrentEpoch, getRandaoMix} from "../util/index.ts";
 
 export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block: BeaconBlock<ForkPostGloas>): void {
   const signedBid = block.body.signedExecutionPayloadBid;
   const bid = signedBid.message;
   const {builderIndex, value: amount} = bid;
-  const builder = state.validators.getReadonly(builderIndex);
 
   // For self-builds, amount must be zero regardless of withdrawal credential prefix
-  if (builderIndex === block.proposerIndex) {
+  if (builderIndex === BUILDER_INDEX_SELF_BUILD) {
     if (amount !== 0) {
       throw Error(`Invalid execution payload bid: self-build with non-zero amount ${amount}`);
     }
     if (!byteArrayEquals(signedBid.signature, G2_POINT_AT_INFINITY)) {
       throw Error("Invalid execution payload bid: self-build with non-zero signature");
     }
-    // Non-self builds require builder withdrawal credential
-  } else {
-    if (!hasBuilderWithdrawalCredential(builder.withdrawalCredentials)) {
-      throw Error(`Invalid execution payload bid: builder ${builderIndex} does not have builder withdrawal credential`);
+  }
+  // Non-self builds require active builder with valid signature
+  else {
+    const builder = state.builders.getReadonly(builderIndex);
+
+    // Verify that the builder is active
+    if (!isActiveBuilder(builder, state.finalizedCheckpoint.epoch)) {
+      throw Error(`Invalid execution payload bid: builder ${builderIndex} is not active`);
+    }
+
+    // Verify that the builder has funds to cover the bid
+    if (!canBuilderCoverBid(state, builderIndex, amount)) {
+      throw Error(`Invalid execution payload bid: builder ${builderIndex} has insufficient balance`);
     }
 
+    // Verify that the bid signature is valid
     if (!verifyExecutionPayloadBidSignature(state, builder.pubkey, signedBid)) {
       throw Error(`Invalid execution payload bid: invalid signature for builder ${builderIndex}`);
     }
   }
 
-  if (!isActiveValidator(builder, getCurrentEpoch(state))) {
-    throw Error(`Invalid execution payload bid: builder ${builderIndex} is not active`);
-  }
-
-  if (builder.slashed) {
-    throw Error(`Invalid execution payload bid: builder ${builderIndex} is slashed`);
-  }
-
-  const pendingPayments = state.builderPendingPayments
-    .getAllReadonly()
-    .filter((payment) => payment.withdrawal.builderIndex === builderIndex)
-    .reduce((acc, payment) => acc + payment.withdrawal.amount, 0);
-  const pendingWithdrawals = state.builderPendingWithdrawals
-    .getAllReadonly()
-    .filter((withdrawal) => withdrawal.builderIndex === builderIndex)
-    .reduce((acc, withdrawal) => acc + withdrawal.amount, 0);
-
-  if (
-    amount !== 0 &&
-    state.balances.get(builderIndex) < amount + pendingPayments + pendingWithdrawals + MIN_ACTIVATION_BALANCE
-  ) {
-    throw Error("Insufficient builder balance");
-  }
-
   if (bid.slot !== block.slot) {
     throw Error(`Bid slot ${bid.slot} does not match block slot ${block.slot}`);
   }
@@ -91,7 +71,6 @@ export function processExecutionPayloadBid(state: CachedBeaconStateGloas, block:
         feeRecipient: bid.feeRecipient,
         amount,
         builderIndex,
-        withdrawableEpoch: FAR_FUTURE_EPOCH,
       }),
     });
 
@@ -106,8 +85,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);