feat: add BLS verification and signing roots (PR #1)

Author: zacksfF

src/beacon_chain/containers.rs

@@ -1,7 +1,7 @@
-use crate::beacon_chain::constants::MAX_PAYLOAD_ATTESTATIONS;
 /// EIP-7732 — SSZ containers
 /// All containers directly mirror the spec definitions.
 /// Reference: https://eips.ethereum.org/EIPS/eip-7732#containers
+use crate::beacon_chain::constants::MAX_PAYLOAD_ATTESTATIONS;
 use crate::beacon_chain::types::*;
 use serde::{Deserialize, Serialize};
 

src/beacon_chain/process_payload_attestation.rs

@@ -5,10 +5,11 @@
 ///
 /// Reference: https://eips.ethereum.org/EIPS/eip-7732#beacon-chain-changes
 use crate::beacon_chain::{
-    constants::PTC_SIZE,
+    constants::{DOMAIN_PTC_ATTESTER, PTC_SIZE},
     containers::{PayloadAttestation, PayloadAttestationData},
-    types::{Slot, ValidatorIndex},
+    types::{BLSPubkey, Slot, ValidatorIndex},
 };
+use crate::utils::{crypto, ssz};
 use thiserror::Error;
 
 #[derive(Debug, Error)]
@@ -24,11 +25,15 @@ pub enum PayloadAttestationError {
 
     #[error("Attesting index {0} is not a PTC member for this slot")]
     NotPtcMember(ValidatorIndex),
+
+    #[error("PTC pubkey list length does not match committee size")]
+    MissingPubkeys,
 }
 
 pub trait BeaconStateRead {
     fn parent_slot(&self) -> Slot;
     fn get_ptc(&self, slot: Slot) -> Vec<ValidatorIndex>;
+    fn ptc_pubkeys(&self, slot: Slot) -> Vec<BLSPubkey>;
     fn parent_beacon_block_root(&self) -> [u8; 32];
 }
 
@@ -66,28 +71,40 @@ pub fn process_payload_attestation<S: BeaconStateRead>(
 
     // Get the PTC members for the attested slot
     let ptc = state.get_ptc(data.slot);
+    let ptc_pubkeys = state.ptc_pubkeys(data.slot);
+    if ptc_pubkeys.len() != ptc.len() {
+        return Err(PayloadAttestationError::MissingPubkeys);
+    }
 
-    // Collect attesting validators
-    let attesting: Vec<ValidatorIndex> = attestation
-        .aggregation_bits
-        .iter()
-        .enumerate()
-        .filter(|(_, &bit)| bit)
-        .map(|(i, _)| ptc[i])
-        .collect();
+    // Collect attesting validators and their pubkeys
+    let mut attesting_indices = Vec::new();
+    let mut attesting_pubkeys = Vec::new();
+    for (i, bit) in attestation.aggregation_bits.iter().enumerate() {
+        if *bit {
+            attesting_indices.push(ptc[i]);
+            attesting_pubkeys.push(ptc_pubkeys[i]);
+        }
+    }
 
-    // Verify aggregated signature (stub)
-    verify_aggregate_ptc_signature(&attestation.signature, data, &attesting)?;
+    // Verify aggregated signature
+    verify_aggregate_ptc_signature(
+        &attestation.signature,
+        data,
+        &attesting_indices,
+        &attesting_pubkeys,
+    )?;
 
     Ok(())
 }
 
 fn verify_aggregate_ptc_signature(
-    _signature: &[u8; 96],
-    _data: &PayloadAttestationData,
+    signature: &[u8; 96],
+    data: &PayloadAttestationData,
     _validators: &[ValidatorIndex],
+    pubkeys: &[BLSPubkey],
 ) -> Result<(), PayloadAttestationError> {
-    // TODO: aggregate public keys, compute signing_root with DOMAIN_PTC_ATTESTER,
-    //       verify with blst
-    Ok(())
+    let domain = ssz::compute_domain_simple(DOMAIN_PTC_ATTESTER);
+    let signing_root = ssz::signing_root(data, domain);
+    crypto::bls_verify_aggregate(pubkeys, &signing_root, signature)
+        .map_err(|_| PayloadAttestationError::InvalidSignature)
 }

src/beacon_chain/process_payload_bid.rs

@@ -7,9 +7,11 @@
 ///
 /// Reference: https://eips.ethereum.org/EIPS/eip-7732#beacon-chain-changes
 use crate::beacon_chain::{
+    constants::DOMAIN_BEACON_BUILDER,
     containers::{BuilderPendingPayment, BuilderPendingWithdrawal, SignedExecutionPayloadBid},
-    types::{BuilderIndex, Gwei, Slot},
+    types::{BLSPubkey, BuilderIndex, Gwei, Slot},
 };
+use crate::utils::{crypto, ssz};
 use thiserror::Error;
 
 #[derive(Debug, Error)]
@@ -28,11 +30,15 @@ pub enum PayloadBidError {
 
     #[error("Parent block hash mismatch")]
     ParentHashMismatch,
+
+    #[error("Builder pubkey missing for index {0}")]
+    MissingPubkey(BuilderIndex),
 }
 
 /// Minimal beacon state surface needed by this function.
 pub trait BeaconStateMut {
     fn builder_balance(&self, index: BuilderIndex) -> Option<Gwei>;
+    fn builder_pubkey(&self, index: BuilderIndex) -> Option<BLSPubkey>;
     fn deduct_builder_balance(&mut self, index: BuilderIndex, amount: Gwei);
     fn push_pending_payment(&mut self, payment: BuilderPendingPayment);
     fn current_slot(&self) -> Slot;
@@ -68,10 +74,7 @@ pub fn process_execution_payload_bid<S: BeaconStateMut>(
         return Err(PayloadBidError::ParentHashMismatch);
     }
 
-    // Step 3 — BLS signature (stub — wire to blst crate in full impl)
-    verify_builder_signature(signed_bid)?;
-
-    // Step 4 + 5 — balance check and deduction
+    // Step 3 — balance check
     let balance = state
         .builder_balance(bid.builder_index)
         .ok_or(PayloadBidError::BuilderNotFound(bid.builder_index))?;
@@ -83,6 +86,10 @@ pub fn process_execution_payload_bid<S: BeaconStateMut>(
         });
     }
 
+    // Step 4 — BLS signature
+    verify_builder_signature(state, signed_bid)?;
+
+    // Step 5 — deduct balance
     state.deduct_builder_balance(bid.builder_index, bid.value);
 
     // Step 6 — queue pending payment
@@ -100,9 +107,17 @@ pub fn process_execution_payload_bid<S: BeaconStateMut>(
 }
 
 /// Stub — replace with blst domain-separated BLS verify in full impl.
-fn verify_builder_signature(
-    _signed_bid: &SignedExecutionPayloadBid,
+fn verify_builder_signature<S: BeaconStateMut>(
+    state: &S,
+    signed_bid: &SignedExecutionPayloadBid,
 ) -> Result<(), PayloadBidError> {
-    // TODO: compute signing_root with DOMAIN_BEACON_BUILDER and verify
-    Ok(())
+    let message = &signed_bid.message;
+    let pk = state
+        .builder_pubkey(message.builder_index)
+        .ok_or(PayloadBidError::MissingPubkey(message.builder_index))?;
+
+    let domain = ssz::compute_domain_simple(DOMAIN_BEACON_BUILDER);
+    let signing_root = ssz::signing_root(message, domain);
+    crypto::bls_verify(&pk, &signing_root, &signed_bid.signature)
+        .map_err(|_| PayloadBidError::InvalidSignature)
 }