feat: rebase cache

Author: karlem

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

@@ -224,266 +224,3 @@ async fn run_service(
         println!("Press Ctrl+C to stop...");
     }
 }
-
-fn inspect_cache(db_path: &PathBuf) -> anyhow::Result<()> {
-    use fendermint_vm_topdown_proof_service::persistence::ProofCachePersistence;
-
-    println!("=== Cache Inspection ===");
-    println!("Database: {}", db_path.display());
-    println!();
-
-    let persistence = ProofCachePersistence::open(db_path)?;
-
-    // Load last committed
-    let last_committed = persistence.load_last_committed()?;
-    println!(
-        "Last Committed Instance: {}",
-        last_committed.map_or("None".to_string(), |i| i.to_string())
-    );
-    println!();
-
-    // Load all entries
-    let entries = persistence.load_all_entries()?;
-    println!("Total Entries: {}", entries.len());
-    println!();
-
-    if entries.is_empty() {
-        println!("Cache is empty.");
-        return Ok(());
-    }
-
-    println!("Entries:");
-    println!(
-        "{:<12} {:<20} {:<15} {:<15}",
-        "Instance ID", "Epochs", "Proof Size", "Signers"
-    );
-    println!("{}", "-".repeat(70));
-
-    for entry in &entries {
-        let epochs_str = format!("[{:?}]", entry.finalized_epochs);
-        let epochs_display = if epochs_str.len() > 18 {
-            format!("{}...", &epochs_str[..15])
-        } else {
-            epochs_str
-        };
-
-        // Serialize proof bundle to get size
-        let proof_bundle_size = fvm_ipld_encoding::to_vec(&entry.proof_bundle)
-            .map(|v| v.len())
-            .unwrap_or(0);
-
-        println!(
-            "{:<12} {:<20} {:<15} {:<15}",
-            entry.instance_id,
-            epochs_display,
-            format!("{} bytes", proof_bundle_size),
-            format!("{} signers", entry.certificate.signers.len())
-        );
-    }
-
-    Ok(())
-}
-
-fn show_stats(db_path: &PathBuf) -> anyhow::Result<()> {
-    use fendermint_vm_topdown_proof_service::persistence::ProofCachePersistence;
-
-    println!("=== Cache Statistics ===");
-    println!("Database: {}", db_path.display());
-    println!();
-
-    let persistence = ProofCachePersistence::open(db_path)?;
-
-    let last_committed = persistence.load_last_committed()?;
-    let entries = persistence.load_all_entries()?;
-
-    println!("General:");
-    println!(
-        "  Last Committed: {}",
-        last_committed.map_or("None".to_string(), |i| i.to_string())
-    );
-    println!("  Total Entries: {}", entries.len());
-    println!();
-
-    if !entries.is_empty() {
-        let min_instance = entries.iter().map(|e| e.instance_id).min().unwrap();
-        let max_instance = entries.iter().map(|e| e.instance_id).max().unwrap();
-        let total_proof_size: usize = entries
-            .iter()
-            .map(|e| {
-                fvm_ipld_encoding::to_vec(&e.proof_bundle)
-                    .map(|v| v.len())
-                    .unwrap_or(0)
-            })
-            .sum();
-        let avg_proof_size = total_proof_size / entries.len();
-
-        println!("Instances:");
-        println!("  Min Instance ID: {}", min_instance);
-        println!("  Max Instance ID: {}", max_instance);
-        println!("  Range: {}", max_instance - min_instance + 1);
-        println!();
-
-        println!("Proof Bundles:");
-        println!(
-            "  Total Size: {} bytes ({:.2} KB)",
-            total_proof_size,
-            total_proof_size as f64 / 1024.0
-        );
-        println!("  Average Size: {} bytes", avg_proof_size);
-        println!(
-            "  Min Size: {} bytes",
-            entries
-                .iter()
-                .map(|e| fvm_ipld_encoding::to_vec(&e.proof_bundle)
-                    .map(|v| v.len())
-                    .unwrap_or(0))
-                .min()
-                .unwrap()
-        );
-        println!(
-            "  Max Size: {} bytes",
-            entries
-                .iter()
-                .map(|e| fvm_ipld_encoding::to_vec(&e.proof_bundle)
-                    .map(|v| v.len())
-                    .unwrap_or(0))
-                .max()
-                .unwrap()
-        );
-        println!();
-
-        println!("Epochs:");
-        let total_epochs: usize = entries.iter().map(|e| e.finalized_epochs.len()).sum();
-        println!("  Total Finalized Epochs: {}", total_epochs);
-        println!(
-            "  Avg Epochs per Instance: {:.1}",
-            total_epochs as f64 / entries.len() as f64
-        );
-    }
-
-    Ok(())
-}
-
-fn get_proof(db_path: &PathBuf, instance_id: u64) -> anyhow::Result<()> {
-    use fendermint_vm_topdown_proof_service::config::CacheConfig;
-
-    println!("=== Get Proof ===");
-    println!("Database: {}", db_path.display());
-    println!("Instance ID: {}", instance_id);
-    println!();
-
-    // Load cache with persistence
-    let cache_config = CacheConfig {
-        lookahead_instances: 10,
-        retention_epochs: 2,
-    };
-
-    let cache = ProofCache::new_with_persistence(cache_config, db_path, 0)?;
-
-    match cache.get(instance_id) {
-        Some(entry) => {
-            println!("Found proof for instance {}", instance_id);
-            println!();
-            println!("Details:");
-            println!("  Instance ID: {}", entry.instance_id);
-            println!("  Finalized Epochs: {:?}", entry.finalized_epochs);
-            let proof_bundle_size = fvm_ipld_encoding::to_vec(&entry.proof_bundle)
-                .map(|v| v.len())
-                .unwrap_or(0);
-            println!("  Proof Bundle Size: {} bytes", proof_bundle_size);
-            println!(
-                "    - Storage Proofs: {}",
-                entry.proof_bundle.storage_proofs.len()
-            );
-            println!(
-                "    - Event Proofs: {}",
-                entry.proof_bundle.event_proofs.len()
-            );
-            println!("    - Witness Blocks: {}", entry.proof_bundle.blocks.len());
-            println!("  Generated At: {:?}", entry.generated_at);
-            println!("  Source RPC: {}", entry.source_rpc);
-            println!();
-            println!("Certificate:");
-            println!("  Instance ID: {}", entry.certificate.instance_id);
-            println!(
-                "  Finalized Epochs: {:?}",
-                entry.certificate.finalized_epochs
-            );
-            println!("  Power Table CID: {}", entry.certificate.power_table_cid);
-            println!(
-                "  BLS Signature: {} bytes",
-                entry.certificate.signature.len()
-            );
-            println!("  Signers: {} validators", entry.certificate.signers.len());
-            println!();
-
-            // Proof Bundle Summary
-            println!("═══ Proof Bundle Summary ═══");
-            let proof_bundle_size = fvm_ipld_encoding::to_vec(&entry.proof_bundle)
-                .map(|v| v.len())
-                .unwrap_or(0);
-            println!(
-                "  Total Size: {} bytes ({:.2} KB)",
-                proof_bundle_size,
-                proof_bundle_size as f64 / 1024.0
-            );
-            println!(
-                "  Storage Proofs: {}",
-                entry.proof_bundle.storage_proofs.len()
-            );
-            println!("  Event Proofs: {}", entry.proof_bundle.event_proofs.len());
-            println!("  Witness Blocks: {}", entry.proof_bundle.blocks.len());
-            println!();
-
-            // Proof Bundle Details - show structure
-            println!("═══ Detailed Proof Structure ═══");
-            println!(
-                "Storage Proofs ({}):",
-                entry.proof_bundle.storage_proofs.len()
-            );
-            for (i, sp) in entry.proof_bundle.storage_proofs.iter().enumerate() {
-                println!("  [{}] {:?}", i, sp);
-            }
-            println!();
-
-            println!("Event Proofs ({}):", entry.proof_bundle.event_proofs.len());
-            for (i, ep) in entry.proof_bundle.event_proofs.iter().enumerate() {
-                println!("  [{}] {:?}", i, ep);
-            }
-            println!();
-
-            println!("Witness Blocks ({}):", entry.proof_bundle.blocks.len());
-            println!("  (First and last blocks shown)");
-            for (i, block) in entry.proof_bundle.blocks.iter().enumerate() {
-                if i < 2 || i >= entry.proof_bundle.blocks.len() - 2 {
-                    println!("  [{}] {:?}", i, block);
-                } else if i == 2 {
-                    println!(
-                        "  ... ({} more blocks)",
-                        entry.proof_bundle.blocks.len() - 4
-                    );
-                }
-            }
-            println!();
-
-            // Metadata
-            println!("═══ Metadata ═══");
-            println!("  Generated At: {:?}", entry.generated_at);
-            println!("  Source RPC: {}", entry.source_rpc);
-            println!();
-
-            // Full JSON dump
-            println!("═══ Full Proof Bundle (JSON) ═══");
-            if let Ok(json) = serde_json::to_string_pretty(&entry.proof_bundle) {
-                println!("{}", json);
-            }
-        }
-        None => {
-            println!("No proof found for instance {}", instance_id);
-            println!();
-            println!("Available instances: {:?}", cache.cached_instances());
-        }
-    }
-
-    Ok(())
-}

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

@@ -17,9 +17,6 @@
 //! This avoids duplicating certificates when multiple epochs reference
 //! the same certificate.
 
-// Re-export commonly used types
-pub use filecoin_f3_gpbft::powertable::{PowerEntries, PowerEntry};
-
 pub mod assembler;
 pub mod cache;
 pub mod config;
@@ -28,6 +25,7 @@ pub mod observe;
 pub mod persistence;
 pub mod service;
 pub mod types;
+pub mod verifier;
 
 // Re-export main types for convenience
 pub use cache::ProofCache;
@@ -55,7 +53,6 @@ use std::sync::Arc;
 /// * `initial_instance` - The last committed F3 instance (from F3CertManager actor)
 /// * `initial_power_table` - Initial power table (from F3CertManager actor)
 /// * `db_path` - Optional database path for persistence
-/// * `initial_committed_instance` - The last committed F3 instance (from actor)
 ///
 /// # Returns
 /// * `Arc<ProofCache>` - Shared cache that proposers can query
@@ -154,6 +151,7 @@ mod tests {
     #[tokio::test]
     async fn test_launch_service_enabled() {
         use crate::config::GatewayId;
+        use filecoin_f3_gpbft::PowerEntries;
 
         let config = ProofServiceConfig {
             enabled: true,
@@ -171,8 +169,5 @@ mod tests {
 
         let (_cache, handle) = result.unwrap().unwrap();
         handle.abort();
-
-        // Check cache state
-        assert_eq!(cache.last_committed_instance(), 100);
     }
 }