refactor: demo logs

Author: fbwoolf

beacon_node/beacon_chain/src/data_availability_checker/overflow_lru_cache.rs

@@ -15,7 +15,7 @@ use parking_lot::{MappedRwLockReadGuard, RwLock, RwLockReadGuard, RwLockWriteGua
 use std::cmp::Ordering;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
-use tracing::{Span, debug, debug_span};
+use tracing::{Span, debug, debug_span, info};
 use types::beacon_block_body::KzgCommitments;
 use types::blob_sidecar::BlobIdentifier;
 use types::{
@@ -365,6 +365,26 @@ impl<E: EthSpec> PendingComponents<E> {
                 // Not enough execution proofs yet
                 return Ok(None);
             }
+
+            // Log when minimum proofs requirement is met
+            let proof_ids: Vec<_> = self.verified_execution_proofs
+                .iter()
+                .map(|p| p.proof_id.as_u8().to_string())
+                .collect();
+
+            let slot = self.verified_execution_proofs
+                .first()
+                .map(|p| p.slot);
+
+            self.span.in_scope(|| {
+                if let Some(slot) = slot {
+                    info!("[Ethproofs] Minimum required execution proofs received: {}/{} proof_ids=[{}] slot={}",
+                          num_proofs, min_proofs, proof_ids.join(", "), slot);
+                } else {
+                    info!("[Ethproofs] Minimum required execution proofs received: {}/{} proof_ids=[{}]",
+                          num_proofs, min_proofs, proof_ids.join(", "));
+                }
+            });
         }
 
         // Block is available, construct `AvailableExecutedBlock`
@@ -396,6 +416,15 @@ impl<E: EthSpec> PendingComponents<E> {
         };
 
         self.span.in_scope(|| {
+            let proof_count = self.execution_proof_subnet_count();
+            if proof_count > 0 {
+                let slot = self.block.as_ref().map(|b| b.as_block().slot());
+                if let Some(slot) = slot {
+                    info!("[Ethproofs] Block ready for validation with {} execution proofs slot={}", proof_count, slot);
+                } else {
+                    info!("[Ethproofs] Block ready for validation with {} execution proofs", proof_count);
+                }
+            }
             debug!("Block and all data components are available");
         });
         Ok(Some(AvailableExecutedBlock::new(

beacon_node/network/src/network_beacon_processor/gossip_methods.rs

@@ -806,6 +806,16 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
 
                 self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Accept);
 
+                let gossip_verified_proof_slot = gossip_verified_proof.slot();
+                let gossip_verified_proof_subnet = gossip_verified_proof.subnet_id();
+
+                info!(
+                    %block_root,
+                    subnet_id = %gossip_verified_proof_subnet,
+                    slot = %gossip_verified_proof_slot,
+                    "[Ethproofs] Execution proof accepted and gossiped to peers"
+                );
+
                 // Process the verified proof through DA checker
                 self.process_gossip_verified_execution_proof(
                     peer_id,
@@ -1368,7 +1378,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
                     info!(
                         %block_root,
                         %subnet_id,
-                        "Gossipsub execution proof processed, imported fully available block"
+                        "[Ethproofs] Block fully available, imported with execution proofs"
                     );
                     self.chain.recompute_head_at_current_slot().await;
 

zkvm_execution_layer/src/ethproofs_demo.rs

@@ -215,21 +215,19 @@ pub fn validate_proof(proof: &ExecutionProof) -> bool {
                     match VERIFIER_STORE.get(&prover_uuid) {
                         Some(verifier_entry) => {
                             info!(
-                                slot = %proof.slot,
-                                block_hash = %proof.block_hash,
-                                verifier = verifier_entry.name,
-                                "[Ethproofs] Verification started"
+                                "[Ethproofs] Verification started: verifier={} slot={}",
+                                verifier_entry.name,
+                                proof.slot
                             );
 
                             // Run the actual cryptographic verification
                             match (verifier_entry.verify_fn)(&proof.proof_data, &vk.vk) {
                                 Ok(result) => {
                                     info!(
-                                        slot = %proof.slot,
-                                        block_hash = %proof.block_hash,
-                                        verifier = verifier_entry.name,
-                                        verification_result = result,
-                                        "[Ethproofs] Verification completed"
+                                        "[Ethproofs] Verification completed: verifier={} slot={} result={}",
+                                        verifier_entry.name,
+                                        proof.slot,
+                                        result
                                     );
                                     result
                                 }