feat: makes changes after rebase

Author: karlem

fendermint/vm/interpreter/src/fvm/interpreter.rs

@@ -358,14 +358,14 @@ where
                         {
                             Ok(()) => {
                                 tracing::debug!(
-                                    instance = bundle.certificate.instance_id,
+                                    instance = bundle.certificate.gpbft_instance,
                                     "storage/event proofs verified"
                                 );
                             }
                             Err(e) => {
                                 tracing::warn!(
                                     error = %e,
-                                    instance = bundle.certificate.instance_id,
+                                    instance = bundle.certificate.gpbft_instance,
                                     "proof bundle verification failed - rejecting block"
                                 );
                                 return Ok(AttestMessagesResponse::Reject);
@@ -375,27 +375,27 @@ where
                         // STEP 2: Check if we have this certificate in our local cache
                         let has_locally = self
                             .top_down_manager
-                            .has_certificate_in_cache(bundle.certificate.instance_id)
+                            .has_certificate_in_cache(bundle.certificate.gpbft_instance)
                             .await;
 
                         if !has_locally {
                             // STEP 3: Validate F3 certificate if not in our cache
                             // This means we're behind or just started
                             tracing::info!(
-                                instance = bundle.certificate.instance_id,
+                                instance = bundle.certificate.gpbft_instance,
                                 "Certificate not in local cache - performing F3 validation"
                             );
-                            
+
                             // We need to validate during execution phase where we have state access
                             // During attestation, we can't access FVM state, so we flag for validation
                             // The actual validation happens in verify_proof_bundle_with_state during execution
                             tracing::debug!(
-                                instance = bundle.certificate.instance_id,
+                                instance = bundle.certificate.gpbft_instance,
                                 "F3 validation will occur during execution phase"
                             );
                         } else {
                             tracing::debug!(
-                                instance = bundle.certificate.instance_id,
+                                instance = bundle.certificate.gpbft_instance,
                                 "Certificate found in local cache - already validated by our F3 client"
                             );
                         }

fendermint/vm/interpreter/src/fvm/topdown.rs

@@ -168,8 +168,8 @@ where
         let entry = cache.get_next_uncommitted()?;
 
         tracing::debug!(
-            instance_id = entry.instance_id,
-            epochs = ?entry.finalized_epochs,
+            instance_id = entry.certificate.gpbft_instance,
+            epochs = ?entry.certificate.finalized_epochs,
             "found proof in cache for proposal"
         );
 
@@ -193,7 +193,8 @@ where
         &self,
         bundle: &fendermint_vm_message::ipc::TopDownProofBundle,
     ) -> anyhow::Result<()> {
-        use fendermint_vm_topdown_proof_service::verify_proof_bundle;
+        // TODO Karel - implement this
+        use fendermint_vm_topdown_proof_service::verifier::ProofsVerifier;
 
         // Verify cryptographic proofs (storage + events)
         verify_proof_bundle(&bundle.proof_bundle, &bundle.certificate)
@@ -225,17 +226,17 @@ where
             .context("failed to query F3LightClientActor state")?;
 
         // Ensure bundle.certificate.instance_id == last_committed + 1
-        if bundle.certificate.instance_id != f3_state.instance_id + 1 {
+        if bundle.certificate.gpbft_instance != f3_state.instance_id + 1 {
             bail!(
                 "Certificate instance ID {} is not sequential (expected {})",
-                bundle.certificate.instance_id,
+                bundle.certificate.gpbft_instance,
                 f3_state.instance_id + 1
             );
         }
 
         tracing::debug!(
             current_instance = f3_state.instance_id,
-            new_instance = bundle.certificate.instance_id,
+            new_instance = bundle.certificate.gpbft_instance,
             "verified certificate chain continuity"
         );
 
@@ -248,30 +249,30 @@ where
         // Note: Using blocking try_read since this is not an async function
         if let Ok(guard) = self.proof_cache.try_read() {
             if let Some(cache) = guard.as_ref() {
-                if cache.contains(bundle.certificate.instance_id) {
+                if cache.contains(bundle.certificate.gpbft_instance) {
                     tracing::debug!(
-                        instance = bundle.certificate.instance_id,
+                        instance = bundle.certificate.gpbft_instance,
                         "Certificate found in local cache - already validated by our F3 client"
                     );
                     // We validated this ourselves, trust it
                     return Ok(());
                 }
             }
         }
-        
+
         // Certificate not in our cache - this means we're behind
         // However, the certificate has already passed storage/event proof verification
         // which cryptographically proves it's valid for the parent state
         tracing::info!(
-            instance = bundle.certificate.instance_id,
+            instance = bundle.certificate.gpbft_instance,
             "Certificate not in local cache - validator is behind but certificate is proven valid via storage/event proofs"
         );
-        
+
         // The storage and event proofs already guarantee:
         // 1. The certificate was used to finalize the parent chain
         // 2. The topdown messages and validator changes are correct
         // 3. The state transition is valid
-        // 
+        //
         // We don't need to re-validate F3 signatures since the proofs already
         // demonstrate the certificate was accepted by the parent chain
         Ok(())
@@ -307,7 +308,7 @@ where
         }
 
         tracing::debug!(
-            instance = bundle.certificate.instance_id,
+            instance = bundle.certificate.gpbft_instance,
             "executing proof-based topdown finality"
         );
 
@@ -376,7 +377,7 @@ where
 
         let new_light_client_state =
             fendermint_vm_actor_interface::f3_light_client::LightClientState {
-                instance_id: bundle.certificate.instance_id,
+                instance_id: bundle.certificate.gpbft_instance,
                 finalized_epochs: bundle.certificate.finalized_epochs.clone(),
                 power_table,
             };
@@ -386,24 +387,24 @@ where
             .context("failed to update F3LightClientActor state")?;
 
         tracing::debug!(
-            instance = bundle.certificate.instance_id,
+            instance = bundle.certificate.gpbft_instance,
             "updated F3LightClientActor state"
         );
 
         // Step 7: Mark instance as committed in cache
         {
             let guard = self.proof_cache.read().await;
             if let Some(cache) = guard.as_ref() {
-                cache.mark_committed(bundle.certificate.instance_id);
+                cache.mark_committed(bundle.certificate.gpbft_instance);
                 tracing::debug!(
-                    instance = bundle.certificate.instance_id,
+                    instance = bundle.certificate.gpbft_instance,
                     "marked instance as committed in cache"
                 );
             }
         }
 
         tracing::info!(
-            instance = bundle.certificate.instance_id,
+            instance = bundle.certificate.gpbft_instance,
             height = finality.height,
             "proof-based topdown finality executed successfully"
         );

fendermint/vm/topdown/proof-service/src/assembler.rs

@@ -80,7 +80,7 @@ impl ProofAssembler {
 
     /// Create a Lotus client for requests
     fn create_client(&self) -> Result<LotusClient> {
-        Ok(LotusClient::new(Url::parse(&self.rpc_url)?, None))
+        Ok(LotusClient::new(self.rpc_url.clone(), None))
     }
 
     /// Generate proof bundle for a certificate
@@ -118,7 +118,7 @@ impl ProofAssembler {
         //
         // The F3 certificate contains only the tipset CID and epoch, not the full tipset data.
         // We fetch the actual tipsets here to extract block headers, state roots, and receipts.
-        let client = self.create_client();
+        let client = self.create_client()?;
 
         let parent_tipset = client
             .request(
@@ -203,7 +203,7 @@ impl ProofAssembler {
         );
 
         // Create LotusClient for this request (not stored due to Rc/RefCell)
-        let lotus_client = self.create_client();
+        let lotus_client = self.create_client()?;
 
         // Generate proof bundle in blocking task
         // CRITICAL: The proofs library uses Rc/RefCell internally making LotusClient and

fendermint/vm/topdown/proof-service/src/cache.rs

@@ -91,6 +91,8 @@ impl ProofCache {
     /// Returns the proof for (last_committed + 1)
     pub fn get_next_uncommitted(&self) -> Option<CacheEntry> {
         let last_committed = self.last_committed_instance.load(Ordering::Acquire);
+        let next_instance = last_committed + 1;
+
         let result = self.entries.read().get(&next_instance).cloned();
 
         // Record cache hit/miss
@@ -281,28 +283,44 @@ impl ProofCache {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::SerializableF3Certificate;
+    use crate::types::{
+        CacheEntry, SerializableCacheEntry, SerializableECChainEntry, SerializableF3Certificate,
+        SerializablePowerEntries, SerializablePowerEntry, SerializableSupplementalData,
+    };
     use proofs::proofs::common::bundle::UnifiedProofBundle;
     use std::time::SystemTime;
 
     fn create_test_entry(instance_id: u64, epochs: Vec<i64>) -> CacheEntry {
-        CacheEntry {
-            instance_id,
-            finalized_epochs: epochs.clone(),
-            proof_bundle: UnifiedProofBundle {
+        use multihash_codetable::{Code, MultihashDigest};
+
+        let power_table_cid = cid::Cid::new_v1(0x55, Code::Blake2b256.digest(b"test")).to_string();
+
+        let ec_chain = epochs
+            .into_iter()
+            .map(|epoch| SerializableECChainEntry {
+                epoch,
+                key: vec!["0".to_string()],
+                power_table: power_table_cid.clone(),
+                commitments: vec![0u8; 32],
+            })
+            .collect();
+
+        let serializable = SerializableCacheEntry {
+            proof_bundle: Some(UnifiedProofBundle {
                 storage_proofs: vec![],
                 event_proofs: vec![],
                 blocks: vec![],
-            },
+            }),
             certificate: SerializableF3Certificate {
-                instance_id,
-                finalized_epochs: epochs,
-                power_table_cid: {
-                    use multihash_codetable::{Code, MultihashDigest};
-                    cid::Cid::new_v1(0x55, Code::Blake2b256.digest(b"test")).to_string()
+                gpbft_instance: instance_id,
+                ec_chain,
+                supplemental_data: SerializableSupplementalData {
+                    power_table: power_table_cid.clone(),
+                    commitments: vec![0u8; 32],
                 },
+                signers: vec![0],
                 signature: vec![],
-                signers: vec![],
+                power_table_delta: vec![],
             },
             power_table: SerializablePowerEntries(vec![SerializablePowerEntry {
                 id: 1,

fendermint/vm/topdown/proof-service/src/lib.rs

@@ -25,8 +25,7 @@ pub mod verifier;
 pub use cache::ProofCache;
 pub use config::{CacheConfig, ProofServiceConfig};
 pub use service::ProofGeneratorService;
-pub use types::{CacheEntry, SerializableF3Certificate, ValidatedCertificate};
-pub use verifier::verify_proof_bundle;
+pub use types::{CacheEntry, SerializableF3Certificate};
 
 use anyhow::{Context, Result};
 use std::sync::Arc;
@@ -103,15 +102,15 @@ pub async fn launch_service(
     let cache_clone = cache.clone();
     let power_table_clone = initial_power_table.clone();
 
-    // Clone what we need for the background task
-    let config_clone = config.clone();
-    let cache_clone = cache.clone();
-    let power_table_clone = power_table.clone();
-
     // Spawn background task
     let handle = tokio::spawn(async move {
-        match ProofGeneratorService::new(config_clone, cache_clone, initial_committed_instance)
-            .await
+        match ProofGeneratorService::new(
+            config_clone,
+            cache_clone,
+            initial_committed_instance,
+            power_table_clone,
+        )
+        .await
         {
             Ok(service) => service.run().await,
             Err(e) => {
@@ -130,8 +129,6 @@ mod tests {
 
     #[tokio::test]
     async fn test_launch_service_disabled() {
-        use filecoin_f3_gpbft::PowerEntries;
-
         let config = ProofServiceConfig {
             enabled: false,
             ..Default::default()
@@ -146,7 +143,6 @@ mod tests {
     #[tokio::test]
     async fn test_launch_service_enabled() {
         use crate::config::GatewayId;
-        use filecoin_f3_gpbft::PowerEntries;
 
         let config = ProofServiceConfig {
             enabled: true,