add support for actor events.

fvm/src/call_manager/default.rs

@@ -4,6 +4,7 @@ use fvm_ipld_encoding::{to_vec, RawBytes, DAG_CBOR};
 use fvm_shared::address::{Address, Payload};
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::{ErrorNumber, ExitCode};
+use fvm_shared::event::StampedEvent;
 use fvm_shared::sys::BlockId;
 use fvm_shared::{ActorID, MethodNum, METHOD_SEND};
 use num_traits::Zero;
@@ -48,6 +49,8 @@ pub struct InnerDefaultCallManager<M> {
     exec_trace: ExecutionTrace,
     /// Number of actors that have been invoked in this message execution.
     invocation_count: u64,
+    /// Accumulator for events emitted in this call stack.
+    events: Vec<StampedEvent>,
 }
 
 #[doc(hidden)]
@@ -93,6 +96,7 @@ where
             backtrace: Backtrace::default(),
             exec_trace: vec![],
             invocation_count: 0,
+            events: Vec::with_capacity(8),
         })))
     }
 
@@ -186,6 +190,7 @@ where
             backtrace,
             mut gas_tracker,
             mut exec_trace,
+            events,
             ..
         } = *self.0.take().expect("call manager is poisoned");
 
@@ -202,6 +207,7 @@ where
                 gas_used,
                 backtrace,
                 exec_trace,
+                events,
             },
             machine,
         )
@@ -246,6 +252,10 @@ where
     fn invocation_count(&self) -> u64 {
         self.invocation_count
     }
+
+    fn append_event(&mut self, evt: StampedEvent) {
+        self.events.push(evt)
+    }
 }
 
 impl<M> DefaultCallManager<M>

fvm/src/call_manager/mod.rs

@@ -16,6 +16,7 @@ pub use backtrace::Backtrace;
 mod default;
 
 pub use default::DefaultCallManager;
+use fvm_shared::event::StampedEvent;
 
 use crate::trace::ExecutionTrace;
 
@@ -127,6 +128,9 @@ pub trait CallManager: 'static {
         self.gas_tracker_mut().apply_charge(charge)?;
         Ok(())
     }
+
+    /// Appends an event to the event accumulator.
+    fn append_event(&mut self, evt: StampedEvent);
 }
 
 /// The result of a method invocation.
@@ -160,4 +164,5 @@ pub struct FinishRet {
     pub gas_used: i64,
     pub backtrace: Backtrace,
     pub exec_trace: ExecutionTrace,
+    pub events: Vec<StampedEvent>,
 }

fvm/src/executor/default.rs

@@ -9,6 +9,7 @@ use fvm_shared::address::Address;
 use fvm_shared::address::Payload;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::{ErrorNumber, ExitCode};
+use fvm_shared::event::StampedEvent;
 use fvm_shared::message::Message;
 use fvm_shared::receipt::Receipt;
 use fvm_shared::ActorID;
@@ -19,13 +20,14 @@ use crate::call_manager::{backtrace, CallManager, InvocationResult};
 use crate::gas::{Gas, GasCharge, GasOutputs};
 use crate::kernel::{Block, ClassifyResult, Context as _, ExecutionError, Kernel};
 use crate::machine::{Machine, BURNT_FUNDS_ACTOR_ADDR, REWARD_ACTOR_ADDR};
+use crate::trace::ExecutionTrace;
 
 /// The default [`Executor`].
 ///
 /// # Warning
 ///
 /// Message execution might run out of stack and crash (the entire process) if it doesn't have at
-/// least 64MiB of stacks space. If you can't guarantee 64MiB of stack space, wrap this executor in
+/// least 64MiB of stack space. If you can't guarantee 64MiB of stack space, wrap this executor in
 /// a [`ThreadedExecutor`][super::ThreadedExecutor].
 // If the inner value is `None` it means the machine got poisoned and is unusable.
 #[repr(transparent)]
@@ -66,46 +68,62 @@ where
             };
 
         // Apply the message.
-        let (res, gas_used, mut backtrace, exec_trace) = self.map_machine(|machine| {
-            // We're processing a chain message, so the sender is the origin of the call stack.
-            let mut cm = K::CallManager::new(
-                machine,
-                msg.gas_limit,
-                sender_id,
-                msg.sequence,
-                msg.gas_premium.clone(),
-            );
-            // This error is fatal because it should have already been accounted for inside
-            // preflight_message.
-            if let Err(e) = cm.charge_gas(inclusion_cost) {
-                return (Err(e), cm.finish().1);
-            }
-
-            let params = if msg.params.is_empty() {
-                None
-            } else {
-                Some(Block::new(DAG_CBOR, msg.params.bytes()))
-            };
+        let (res, gas_used, mut backtrace, exec_trace, events_root, events) =
+            self.map_machine(|machine| {
+                // We're processing a chain message, so the sender is the origin of the call stack.
+                let mut cm = K::CallManager::new(
+                    machine,
+                    msg.gas_limit,
+                    sender_id,
+                    msg.sequence,
+                    msg.gas_premium.clone(),
+                );
+                // This error is fatal because it should have already been accounted for inside
+                // preflight_message.
+                if let Err(e) = cm.charge_gas(inclusion_cost) {
+                    return (Err(e), cm.finish().1);
+                }
 
-            let result = cm.with_transaction(|cm| {
-                // Invoke the message.
-                let ret = cm.send::<K>(sender_id, msg.to, msg.method_num, params, &msg.value)?;
+                let params = if msg.params.is_empty() {
+                    None
+                } else {
+                    Some(Block::new(DAG_CBOR, msg.params.bytes()))
+                };
 
-                // Charge for including the result (before we end the transaction).
-                if let InvocationResult::Return(value) = &ret {
-                    cm.charge_gas(cm.context().price_list.on_chain_return_value(
-                        value.as_ref().map(|v| v.size() as usize).unwrap_or(0),
-                    ))?;
-                }
+                let result = cm.with_transaction(|cm| {
+                    // Invoke the message.
+                    let ret =
+                        cm.send::<K>(sender_id, msg.to, msg.method_num, params, &msg.value)?;
+
+                    // Charge for including the result (before we end the transaction).
+                    if let InvocationResult::Return(value) = &ret {
+                        cm.charge_gas(cm.context().price_list.on_chain_return_value(
+                            value.as_ref().map(|v| v.size() as usize).unwrap_or(0),
+                        ))?;
+                    }
+
+                    Ok(ret)
+                });
+                let (res, machine) = cm.finish();
+
+                // Flush all events to the store.
+                let events_root = match machine.commit_events(res.events.as_slice()) {
+                    Ok(cid) => cid,
+                    Err(e) => return (Err(e), machine),
+                };
 
-                Ok(ret)
-            });
-            let (res, machine) = cm.finish();
-            (
-                Ok((result, res.gas_used, res.backtrace, res.exec_trace)),
-                machine,
-            )
-        })?;
+                (
+                    Ok((
+                        result,
+                        res.gas_used,
+                        res.backtrace,
+                        res.exec_trace,
+                        events_root,
+                        res.events,
+                    )),
+                    machine,
+                )
+            })?;
 
         // Extract the exit code and build the result of the message application.
         let receipt = match res {
@@ -121,6 +139,7 @@ where
                     exit_code: ExitCode::OK,
                     return_data,
                     gas_used,
+                    events_root,
                 }
             }
             Ok(InvocationResult::Failure(exit_code)) => {
@@ -131,12 +150,14 @@ where
                     exit_code,
                     return_data: Default::default(),
                     gas_used,
+                    events_root,
                 }
             }
             Err(ExecutionError::OutOfGas) => Receipt {
                 exit_code: ExitCode::SYS_OUT_OF_GAS,
                 return_data: Default::default(),
                 gas_used,
+                events_root,
             },
             Err(ExecutionError::Syscall(err)) => {
                 // Errors indicate the message couldn't be dispatched at all
@@ -153,6 +174,7 @@ where
                     exit_code,
                     return_data: Default::default(),
                     gas_used,
+                    events_root,
                 }
             }
             Err(ExecutionError::Fatal(err)) => {
@@ -177,6 +199,7 @@ where
                     exit_code: ExitCode::SYS_ASSERTION_FAILED,
                     return_data: Default::default(),
                     gas_used: msg.gas_limit,
+                    events_root,
                 }
             }
         };
@@ -188,12 +211,9 @@ where
         };
 
         match apply_kind {
-            ApplyKind::Explicit => self
-                .finish_message(msg, receipt, failure_info, gas_cost)
-                .map(|mut apply_ret| {
-                    apply_ret.exec_trace = exec_trace;
-                    apply_ret
-                }),
+            ApplyKind::Explicit => {
+                self.finish_message(msg, receipt, failure_info, gas_cost, exec_trace, events)
+            }
             ApplyKind::Implicit => Ok(ApplyRet {
                 msg_receipt: receipt,
                 penalty: TokenAmount::zero(),
@@ -205,6 +225,7 @@ where
                 gas_burned: 0,
                 failure_info,
                 exec_trace,
+                events,
             }),
         }
     }
@@ -367,6 +388,8 @@ where
         receipt: Receipt,
         failure_info: Option<ApplyFailure>,
         gas_cost: TokenAmount,
+        exec_trace: ExecutionTrace,
+        events: Vec<StampedEvent>,
     ) -> anyhow::Result<ApplyRet> {
         // NOTE: we don't support old network versions in the FVM, so we always burn.
         let GasOutputs {
@@ -425,7 +448,8 @@ where
             gas_refund,
             gas_burned,
             failure_info,
-            exec_trace: vec![],
+            exec_trace,
+            events,
         })
     }
 

fvm/src/executor/mod.rs

@@ -8,6 +8,7 @@ pub use default::DefaultExecutor;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::ExitCode;
+use fvm_shared::event::StampedEvent;
 use fvm_shared::message::Message;
 use fvm_shared::receipt::Receipt;
 use num_traits::Zero;
@@ -88,6 +89,8 @@ pub struct ApplyRet {
     pub failure_info: Option<ApplyFailure>,
     /// Execution trace information, for debugging.
     pub exec_trace: ExecutionTrace,
+    /// Events generated while applying the message.
+    pub events: Vec<StampedEvent>,
 }
 
 impl ApplyRet {
@@ -102,6 +105,7 @@ impl ApplyRet {
                 exit_code: code,
                 return_data: RawBytes::default(),
                 gas_used: 0,
+                events_root: None,
             },
             penalty: miner_penalty,
             miner_tip: TokenAmount::zero(),
@@ -112,6 +116,7 @@ impl ApplyRet {
             gas_burned: 0,
             failure_info: Some(ApplyFailure::PreValidation(message.into())),
             exec_trace: vec![],
+            events: vec![],
         }
     }
 }