feat: support flush_all_blocks, handle new ipld operations in traces (#512)

rvagg · web-flow · commit f520d390f72e · 2025-04-14T13:14:10.000+10:00
* feat: support DumpCache, handle Logs in traces Ref: filecoin-project/ref-fvm#2101 * feat(fvm): add flush_all_blocks option to also write intermediate blocks * feat: add ipld section to execution trace
diff --git a/cgo/fvm.go b/cgo/fvm.go
@@ -8,7 +8,7 @@ package cgo
 */
 import "C"
 
-func CreateFvmMachine(fvmVersion FvmRegisteredVersion, chainEpoch, chainTimestamp, chainId, baseFeeHi, baseFeeLo, baseCircSupplyHi, baseCircSupplyLo, networkVersion uint64, stateRoot SliceRefUint8, tracing bool, blockstoreId, externsId uint64) (*FvmMachine, error) {
+func CreateFvmMachine(fvmVersion FvmRegisteredVersion, chainEpoch, chainTimestamp, chainId, baseFeeHi, baseFeeLo, baseCircSupplyHi, baseCircSupplyLo, networkVersion uint64, stateRoot SliceRefUint8, tracing, flushAllBlocks bool, blockstoreId, externsId uint64) (*FvmMachine, error) {
 	resp := (*resultFvmMachine)(C.create_fvm_machine(
 		(C.FvmRegisteredVersion_t)(fvmVersion),
 		C.uint64_t(chainEpoch),
@@ -21,6 +21,7 @@ func CreateFvmMachine(fvmVersion FvmRegisteredVersion, chainEpoch, chainTimestam
 		C.uint32_t(networkVersion),
 		(C.slice_ref_uint8_t)(stateRoot),
 		C.bool(tracing),
+		C.bool(flushAllBlocks),
 		C.uint64_t(blockstoreId),
 		C.uint64_t(externsId),
 	))
@@ -36,7 +37,7 @@ func CreateFvmMachine(fvmVersion FvmRegisteredVersion, chainEpoch, chainTimestam
 	return executor, nil
 }
 
-func CreateFvmDebugMachine(fvmVersion FvmRegisteredVersion, chainEpoch, chainTimestamp, chainId, baseFeeHi, baseFeeLo, baseCircSupplyHi, baseCircSupplyLo, networkVersion uint64, stateRoot SliceRefUint8, actorRedirect SliceRefUint8, tracing bool, blockstoreId, externsId uint64) (*FvmMachine, error) {
+func CreateFvmDebugMachine(fvmVersion FvmRegisteredVersion, chainEpoch, chainTimestamp, chainId, baseFeeHi, baseFeeLo, baseCircSupplyHi, baseCircSupplyLo, networkVersion uint64, stateRoot SliceRefUint8, actorRedirect SliceRefUint8, tracing, flushAllBlocks bool, blockstoreId, externsId uint64) (*FvmMachine, error) {
 	resp := (*resultFvmMachine)(C.create_fvm_debug_machine(
 		(C.FvmRegisteredVersion_t)(fvmVersion),
 		C.uint64_t(chainEpoch),
@@ -50,6 +51,7 @@ func CreateFvmDebugMachine(fvmVersion FvmRegisteredVersion, chainEpoch, chainTim
 		(C.slice_ref_uint8_t)(stateRoot),
 		(C.slice_ref_uint8_t)(actorRedirect),
 		C.bool(tracing),
+		C.bool(flushAllBlocks),
 		C.uint64_t(blockstoreId),
 		C.uint64_t(externsId),
 	))
diff --git a/fvm.go b/fvm.go
@@ -44,6 +44,7 @@ type FVMOpts struct {
 	NetworkVersion network.Version
 	StateBase      cid.Cid
 	Tracing        bool
+	FlushAllBlocks bool
 
 	Debug         bool
 	ActorRedirect cid.Cid
@@ -74,6 +75,7 @@ func CreateFVM(opts *FVMOpts) (*FVM, error) {
 			uint64(opts.NetworkVersion),
 			cgo.AsSliceRefUint8(opts.StateBase.Bytes()),
 			opts.Tracing,
+			opts.FlushAllBlocks,
 			exHandle, exHandle,
 		)
 	} else {
@@ -89,6 +91,7 @@ func CreateFVM(opts *FVMOpts) (*FVM, error) {
 			cgo.AsSliceRefUint8(opts.StateBase.Bytes()),
 			cgo.AsSliceRefUint8(opts.ActorRedirect.Bytes()),
 			true,
+			opts.FlushAllBlocks,
 			exHandle, exHandle,
 		)
 	}
diff --git a/rust/src/fvm/engine.rs b/rust/src/fvm/engine.rs
@@ -16,7 +16,7 @@ use super::blockstore::CgoBlockstore;
 use super::externs::CgoExterns;
 use super::types::*;
 
-// Generic executor; uses the current (v3) engine types
+// Generic executor; uses the current engine types
 pub trait CgoExecutor: Send {
     fn execute_message(
         &mut self,
@@ -39,6 +39,7 @@ pub struct Config {
     pub tracing: bool,
     pub actor_debugging: bool,
     pub actor_redirect: Vec<(Cid, Cid)>,
+    pub flush_all_blocks: bool,
 }
 
 // The generic engine interface
@@ -178,6 +179,9 @@ mod v4 {
             if cfg.tracing {
                 machine_context.enable_tracing();
             }
+            if cfg.flush_all_blocks {
+                machine_context.enable_flush_all_blocks();
+            }
             let engine = self.get(&network_config)?;
             let machine = CgoMachine4::new(&machine_context, blockstore, externs)?;
             Ok(InnerFvmMachine {
diff --git a/rust/src/fvm/machine.rs b/rust/src/fvm/machine.rs
@@ -93,6 +93,7 @@ fn create_fvm_machine_generic(
     actor_redirect: Option<c_slice::Ref<'_, u8>>,
     actor_debugging: bool,
     tracing: bool,
+    flush_all_blocks: bool,
     blockstore_id: u64,
     externs_id: u64,
 ) -> repr_c::Box<Result<FvmMachine>> {
@@ -137,6 +138,7 @@ fn create_fvm_machine_generic(
                 tracing,
                 actor_debugging,
                 actor_redirect,
+                flush_all_blocks,
             };
 
             let externs = CgoExterns::new(externs_id);
@@ -166,6 +168,7 @@ fn create_fvm_machine(
     network_version: u32,
     state_root: c_slice::Ref<'_, u8>,
     tracing: bool,
+    flush_all_blocks: bool,
     blockstore_id: u64,
     externs_id: u64,
 ) -> repr_c::Box<Result<FvmMachine>> {
@@ -183,6 +186,7 @@ fn create_fvm_machine(
         None,
         false,
         tracing,
+        flush_all_blocks,
         blockstore_id,
         externs_id,
     )
@@ -202,6 +206,7 @@ fn create_fvm_debug_machine(
     state_root: c_slice::Ref<'_, u8>,
     actor_redirect: c_slice::Ref<'_, u8>,
     tracing: bool,
+    flush_all_blocks: bool,
     blockstore_id: u64,
     externs_id: u64,
 ) -> repr_c::Box<Result<FvmMachine>> {
@@ -223,6 +228,7 @@ fn create_fvm_debug_machine(
         },
         true,
         tracing,
+        flush_all_blocks,
         blockstore_id,
         externs_id,
     )
@@ -432,13 +438,22 @@ struct LotusGasCharge {
     pub duration_nanos: u64,
 }
 
+#[derive(Clone, Debug, Serialize_tuple, Deserialize_tuple)]
+struct TraceIpld {
+    pub op: u64,
+    pub cid: Cid,
+    pub size: usize,
+}
+
 #[derive(Clone, Debug, Serialize_tuple, Deserialize_tuple)]
 struct Trace {
     pub msg: TraceMessage,
     pub msg_ret: TraceReturn,
     pub msg_invoked: Option<TraceActor>,
     pub gas_charges: Vec<LotusGasCharge>,
     pub subcalls: Vec<Trace>,
+    pub logs: Vec<String>,
+    pub ipld: Vec<TraceIpld>,
 }
 
 #[derive(Serialize_tuple, Deserialize_tuple, Debug, PartialEq, Eq, Clone)]
@@ -499,6 +514,8 @@ fn build_lotus_trace(
         },
         gas_charges: vec![],
         subcalls: vec![],
+        logs: vec![],
+        ipld: vec![],
     };
 
     while let Some(trace) = trace_iter.next() {
@@ -568,6 +585,16 @@ fn build_lotus_trace(
                         .unwrap_or(u64::MAX),
                 });
             }
+            ExecutionEvent::Log(s) => {
+                new_trace.logs.push(s);
+            }
+            ExecutionEvent::Ipld { op, cid, size } => {
+                new_trace.ipld.push(TraceIpld {
+                    op: op as u64,
+                    cid,
+                    size,
+                });
+            }
             _ => (), // ignore unknown events.
         };
     }
@@ -605,10 +632,12 @@ mod test {
             ExecutionEvent::GasCharge(initial_gas_charge.clone()),
             call_event.clone(),
             return_result.clone(),
+            ExecutionEvent::Log("something happened".to_string()),
             call_event.clone(),
             call_event,
             return_result.clone(),
             return_result.clone(),
+            ExecutionEvent::Log("something else happened".to_string()),
             return_result,
         ];
 
@@ -648,5 +677,8 @@ mod test {
         assert_eq!(lotus_trace.subcalls[0].subcalls.len(), 0);
         assert_eq!(lotus_trace.subcalls[1].subcalls.len(), 1);
         assert_eq!(lotus_trace.subcalls[1].subcalls[0].subcalls.len(), 0);
+        assert_eq!(lotus_trace.logs.len(), 2);
+        assert_eq!(lotus_trace.logs[0], "something happened");
+        assert_eq!(lotus_trace.logs[1], "something else happened");
     }
 }
