feat: progress with top down manager

Author: karlem

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

@@ -347,13 +347,15 @@ where
         for msg in msgs {
             match fvm_ipld_encoding::from_slice::<ChainMessage>(&msg) {
                 Ok(chain_msg) => match chain_msg {
-                    ChainMessage::Ipc(IpcMessage::ParentFinalityWithProof(bundle)) => {
+                    ChainMessage::Ipc(IpcMessage::TopDownWithProof(bundle)) => {
                         // DETERMINISTIC VERIFICATION - all validators reach same decision
-                        match self.top_down_manager.verify_proof_bundle(&bundle).await {
+                        match self
+                            .top_down_manager
+                            .verify_proof_bundle_attestation(&bundle)
+                        {
                             Ok(()) => {
                                 tracing::debug!(
                                     instance = bundle.certificate.instance_id,
-                                    height = bundle.finality.height,
                                     "proof bundle verified - accepting"
                                 );
                             }
@@ -489,7 +491,7 @@ where
                 })
             }
             ChainMessage::Ipc(ipc_msg) => match ipc_msg {
-                IpcMessage::ParentFinalityWithProof(bundle) => {
+                IpcMessage::TopDownWithProof(bundle) => {
                     // NEW: Execute proof-based topdown finality (v2)
                     let applied_message = self
                         .top_down_manager

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

@@ -12,13 +12,15 @@ use fendermint_crypto::{PublicKey, SecretKey};
 use fendermint_vm_actor_interface::ipc;
 use fendermint_vm_actor_interface::{
     eam::EthAddress,
+    f3_light_client,
     init::builtin_actor_eth_addr,
     ipc::{AbiHash, ValidatorMerkleTree, GATEWAY_ACTOR_ID},
 };
 use fendermint_vm_genesis::{Collateral, Power, PowerScale, Validator, ValidatorKey};
 use fendermint_vm_message::conv::{from_eth, from_fvm};
 use fendermint_vm_message::signed::sign_secp256k1;
 use fendermint_vm_topdown::IPCParentFinality;
+use fvm_ipld_encoding::RawBytes;
 
 use ipc_actors_abis::checkpointing_facet::CheckpointingFacet;
 use ipc_actors_abis::gateway_getter_facet::GatewayGetterFacet;
@@ -385,3 +387,110 @@ fn membership_to_power_table(
 
     pt
 }
+
+/// Caller for F3 Light Client actor operations.
+///
+/// The F3 Light Client actor maintains F3 light client state including:
+/// - Current F3 instance ID
+/// - Finalized epochs chain  
+/// - Validator power table
+#[derive(Clone)]
+pub struct F3LightClientCaller {
+    actor_id: ActorID,
+}
+
+impl Default for F3LightClientCaller {
+    fn default() -> Self {
+        Self::new(f3_light_client::F3_LIGHT_CLIENT_ACTOR_ID)
+    }
+}
+
+impl F3LightClientCaller {
+    pub fn new(actor_id: ActorID) -> Self {
+        Self { actor_id }
+    }
+}
+
+impl<DB: Blockstore + Clone> F3LightClientCaller {
+    /// Get the current F3 light client state.
+    ///
+    /// Returns the instance ID, finalized epochs, and power table.
+    pub fn get_state(
+        &self,
+        state: &mut FvmExecState<DB>,
+    ) -> anyhow::Result<f3_light_client::GetStateResponse> {
+        let method_num = f3_light_client::Method::GetState as u64;
+        let params = RawBytes::default(); // No params needed for GetState
+
+        let msg = fvm_shared::message::Message {
+            from: fvm_shared::address::Address::new_id(fvm_shared::SYSTEM_ACTOR_ID),
+            to: fvm_shared::address::Address::new_id(self.actor_id),
+            sequence: 0,
+            gas_limit: 10_000_000_000,
+            method_num,
+            params,
+            value: TokenAmount::zero(),
+            version: 0,
+            gas_fee_cap: TokenAmount::zero(),
+            gas_premium: TokenAmount::zero(),
+        };
+
+        let ret = state
+            .execute_implicit(msg)
+            .context("failed to call F3LightClientActor GetState")?;
+
+        if !ret.msg_receipt.exit_code.is_success() {
+            bail!(
+                "F3LightClientActor GetState returned exit code: {:?}",
+                ret.msg_receipt.exit_code
+            );
+        }
+
+        let response: f3_light_client::GetStateResponse =
+            fvm_ipld_encoding::from_slice(&ret.msg_receipt.return_data)
+                .context("failed to decode GetStateResponse")?;
+
+        Ok(response)
+    }
+
+    /// Update the F3 light client state with a new certificate.
+    ///
+    /// This should be called after successfully executing a proof-based topdown finality message.
+    pub fn update_state(
+        &self,
+        state: &mut FvmExecState<DB>,
+        new_state: f3_light_client::LightClientState,
+    ) -> anyhow::Result<()> {
+        let method_num = f3_light_client::Method::UpdateState as u64;
+
+        let params = f3_light_client::UpdateStateParams { state: new_state };
+        let params = fvm_ipld_encoding::RawBytes::serialize(params)
+            .context("failed to serialize UpdateStateParams")?;
+
+        let msg = fvm_shared::message::Message {
+            from: fvm_shared::address::Address::new_id(fvm_shared::SYSTEM_ACTOR_ID),
+            to: fvm_shared::address::Address::new_id(self.actor_id),
+            sequence: 0,
+            gas_limit: 10_000_000_000,
+            method_num,
+            params,
+            value: TokenAmount::zero(),
+            version: 0,
+            gas_fee_cap: TokenAmount::zero(),
+            gas_premium: TokenAmount::zero(),
+        };
+
+        let ret = state
+            .execute_implicit(msg)
+            .context("failed to call F3LightClientActor UpdateState")?;
+
+        if !ret.msg_receipt.exit_code.is_success() {
+            bail!(
+                "F3LightClientActor UpdateState returned exit code: {:?}",
+                ret.msg_receipt.exit_code
+            );
+        }
+
+        Ok(())
+    }
+}