feat: finish implementing e2e

Author: karlem

Cargo.lock

@@ -45,8 +45,10 @@ tracing-appender = { workspace = true }
 tracing-subscriber = { workspace = true }
 literally = { workspace = true }
 url = { workspace = true }
+ethers = { workspace = true }
 
 fendermint_abci = { path = "../abci" }
+ipc_actors_abis = { path = "../../contract-bindings" }
 actors-custom-api = { path = "../actors/api" }
 fendermint_actor_f3_light_client = { path = "../actors/f3-light-client" }
 fendermint_app_options = { path = "./options" }

fendermint/app/Cargo.toml

@@ -273,6 +273,51 @@ vote_interval = 1
 # pausing the syncer, preventing new events to trigger votes.
 vote_timeout = 60
 
+# # Top-down checkpoint configuration (uncomment to enable parent syncing)
+# [ipc.topdown]
+# # Number of blocks to delay before considering a parent block final
+# chain_head_delay = 10
+# # Additional delay on top of chain_head_delay before proposing finality
+# proposal_delay = 5
+# # Maximum number of blocks to propose in a single checkpoint
+# max_proposal_range = 100
+# # Maximum number of blocks to cache (optional)
+# # max_cache_blocks = 1000
+# # Parent syncing cron period, in seconds
+# polling_interval = 30
+# # Exponential backoff retry base, in seconds
+# exponential_back_off = 5
+# # Maximum number of retries before giving up
+# exponential_retry_limit = 5
+# # Parent HTTP RPC endpoint
+# parent_http_endpoint = "http://api.calibration.node.glif.io/rpc/v1"
+# # Parent HTTP timeout (optional), in seconds
+# # parent_http_timeout = 60
+# # Bearer token for Authorization header (optional)
+# # parent_http_auth_token = "your-token-here"
+# # Parent registry address
+# parent_registry = "0x74539671a1d2f1c8f200826baba665179f53a1b7"
+# # Parent gateway address  
+# parent_gateway = "0x77aa40b105843728088c0132e43fc44348881da8"
+#
+# # F3 proof service configuration (optional - for proof-based parent finality)
+# # Requires genesis to have F3 parameters configured
+# [ipc.topdown.proof_service]
+# # Enable F3 proof-based parent finality (default: false)
+# enabled = false
+# # F3 network name - must match parent chain ("calibrationnet", "mainnet")
+# f3_network_name = "calibrationnet"
+# # How often to poll parent chain for new F3 certificates, in seconds
+# polling_interval = 30
+# # How many F3 instances ahead to pre-generate proofs (lookahead window)
+# lookahead_instances = 5
+# # How many old instances to keep after commitment (retention window)
+# retention_instances = 2
+# # Gateway actor ID on parent chain (optional - derived from genesis if not set)
+# # gateway_actor_id = 176609
+# # Or use Ethereum address (will be resolved to actor ID)
+# # gateway_eth_address = "0xE4c61299c16323C4B58376b60A77F68Aa59afC8b"
+
 # # Setting which are only allowed if the `--network` CLI parameter is `testnet`.
 # [testing]
 

fendermint/app/config/default.toml

@@ -32,3 +32,4 @@ ipc-observability = { path = "../../../ipc/observability" }
 
 fendermint_vm_encoding = { path = "../../vm/encoding" }
 fendermint_vm_topdown = { path = "../../vm/topdown" }
+fendermint_vm_topdown_proof_service = { path = "../../vm/topdown/proof-service" }

fendermint/app/settings/Cargo.toml

@@ -226,6 +226,59 @@ pub struct TopDownSettings {
     /// The parent gateway address
     #[serde(deserialize_with = "deserialize_eth_address_from_str")]
     pub parent_gateway: Address,
+    /// F3 proof service configuration (optional - for proof-based finality)
+    #[serde(default)]
+    pub proof_service: Option<ProofServiceSettings>,
+}
+
+/// F3 proof service settings for proof-based parent finality
+#[serde_as]
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ProofServiceSettings {
+    /// Enable F3 proof-based finality
+    pub enabled: bool,
+
+    /// F3 network name ("calibrationnet", "mainnet")
+    pub f3_network_name: String,
+
+    /// Polling interval for checking parent F3 certificates
+    #[serde_as(as = "DurationSeconds<u64>")]
+    pub polling_interval: Duration,
+
+    /// Instances to generate ahead (lookahead)
+    pub lookahead_instances: u64,
+
+    /// Instances to retain after commitment
+    pub retention_instances: u64,
+
+    /// Gateway actor ID on parent (optional - can derive from genesis)
+    pub gateway_actor_id: Option<u64>,
+
+    /// Gateway Ethereum address (alternative to actor ID)
+    pub gateway_eth_address: Option<String>,
+}
+
+impl ProofServiceSettings {
+    /// Convert to proof service crate's config type
+    pub fn to_proof_service_config(
+        &self,
+        parent_subnet_id: &str,
+    ) -> fendermint_vm_topdown_proof_service::ProofServiceConfig {
+        fendermint_vm_topdown_proof_service::ProofServiceConfig {
+            enabled: self.enabled,
+            polling_interval: self.polling_interval,
+            lookahead_instances: self.lookahead_instances,
+            retention_instances: self.retention_instances,
+            parent_rpc_url: String::new(), // Will be filled from topdown settings
+            parent_subnet_id: parent_subnet_id.to_string(),
+            f3_network_name: self.f3_network_name.clone(),
+            fallback_rpc_urls: vec![],
+            max_cache_size_bytes: 0,
+            gateway_actor_id: self.gateway_actor_id,
+            gateway_eth_address: self.gateway_eth_address.clone(),
+            subnet_id: None, // Will be filled from IPC settings
+        }
+    }
 }
 
 #[serde_as]

fendermint/app/settings/src/lib.rs

@@ -23,8 +23,8 @@ use fendermint_storage::{
 };
 use fendermint_vm_core::Timestamp;
 use fendermint_vm_interpreter::fvm::state::{
-    empty_state_tree, CheckStateRef, FvmExecState, FvmQueryState, FvmStateParams,
-    FvmUpdatableParams,
+    empty_state_tree, ipc::F3LightClientCaller, CheckStateRef, FvmExecState, FvmQueryState,
+    FvmStateParams, FvmUpdatableParams,
 };
 use fendermint_vm_interpreter::fvm::store::ReadOnlyBlockstore;
 use fendermint_vm_interpreter::genesis::{read_genesis_car, GenesisAppState};
@@ -36,6 +36,7 @@ use fendermint_vm_interpreter::types::{
 use fendermint_vm_interpreter::MessagesInterpreter;
 
 use crate::ipc::derive_subnet_app_hash;
+use fendermint_vm_actor_interface::f3_light_client;
 use fendermint_vm_interpreter::fvm::end_block_hook::LightClientCommitments;
 use fendermint_vm_interpreter::fvm::state::snapshot::SnapshotPayload;
 use fendermint_vm_message::query::FvmQueryHeight;
@@ -481,6 +482,61 @@ where
             .context("Validator cache is not available")?
             .get_validator(id)
     }
+
+    /// Query the F3 Light Client Actor state after genesis
+    /// Returns (instance_id, power_table) if F3 is initialized, None otherwise
+    pub async fn query_f3_state(
+        &self,
+    ) -> Result<Option<(u64, fendermint_vm_topdown_proof_service::PowerEntries)>> {
+        // Get committed state to check if genesis has been initialized
+        let state = self.committed_state()?;
+
+        // Don't try to query if state hasn't been initialized by genesis
+        if !Self::can_query_state(state.app_state.block_height, &state.app_state.state_params) {
+            return Ok(None);
+        }
+
+        // Create a read-only view of the state
+        let mut query_state = FvmQueryState::new(
+            self.state_store_clone(),
+            self.multi_engine.clone(),
+            state.app_state.block_height.try_into()?,
+            state.app_state.state_params.clone(),
+            self.check_state.clone(),
+            false, // not pending
+        )
+        .context("error creating query state")?;
+
+        // Create a temporary exec state to query the actor
+        let (_, result) = query_state
+            .with_exec_state(|exec_state| {
+                let f3_caller = F3LightClientCaller::new();
+                match f3_caller.get_state(exec_state) {
+                    Ok(state) => {
+                        // For now, we just return the instance ID and an empty power table
+                        // The proof service will fetch the actual power table from the parent chain
+                        Ok(Some((
+                            state.instance_id,
+                            fendermint_vm_topdown_proof_service::PowerEntries(vec![]),
+                        )))
+                    }
+                    Err(e) => {
+                        // F3 actor might not be deployed (non-Filecoin parent)
+                        tracing::debug!("F3 Light Client Actor not found or not accessible: {}", e);
+                        Ok(None)
+                    }
+                }
+            })
+            .await?;
+
+        Ok(result)
+    }
+
+    /// Get access to the messages interpreter
+    /// Used to access the TopDownManager for updating the proof cache
+    pub fn interpreter(&self) -> &Arc<MI> {
+        &self.messages_interpreter
+    }
 }
 
 // NOTE: The `Application` interface doesn't allow failures at the moment. The protobuf