Add get_key_string method to RuntimeEvent

examples/demo-rollup/stf/src/runtime.rs

@@ -50,7 +50,7 @@ use sov_modules_api::macros::DefaultRuntime;
 use sov_modules_api::macros::{expose_rpc, CliWallet};
 #[cfg(feature = "native")]
 use sov_modules_api::Spec;
-use sov_modules_api::{Context, DispatchCall, Genesis, MessageCodec};
+use sov_modules_api::{Context, DispatchCall, Event, Genesis, MessageCodec};
 #[cfg(feature = "native")]
 use sov_nft_module::{NonFungibleTokenRpcImpl, NonFungibleTokenRpcServer};
 use sov_rollup_interface::da::DaSpec;
@@ -64,7 +64,7 @@ use crate::genesis_config::GenesisPaths;
 
 /// The `demo-stf runtime`.
 #[cfg_attr(feature = "native", derive(CliWallet), expose_rpc)]
-#[derive(Genesis, DispatchCall, MessageCodec, DefaultRuntime)]
+#[derive(Genesis, DispatchCall, Event, MessageCodec, DefaultRuntime)]
 #[serialization(borsh::BorshDeserialize, borsh::BorshSerialize)]
 #[cfg_attr(
     feature = "native",

module-system/module-implementations/examples/sov-value-setter/src/call.rs

@@ -25,6 +25,21 @@ pub enum CallMessage {
     ),
 }
 
+/// This enumeration represents the available events that result from interacting with the `sov-value-setter` module.
+#[cfg_attr(
+    feature = "native",
+    derive(serde::Serialize),
+    derive(serde::Deserialize)
+)]
+#[derive(borsh::BorshDeserialize, borsh::BorshSerialize, Debug, PartialEq, Clone)]
+pub enum Event {
+    /// Value set
+    ValueSet(
+        /// new value
+        u32,
+    ),
+}
+
 /// Example of a custom error.
 #[derive(Debug, Error)]
 enum SetValueError {
@@ -50,6 +65,7 @@ impl<C: sov_modules_api::Context> ValueSetter<C> {
 
         // This is how we set a new value:
         self.value.set(&new_value, working_set);
+        // TODO: replace add event functionality to be similar to self.event.add()
         working_set.add_event("set", &format!("value_set: {new_value:?}"));
 
         Ok(CallResponse::default())

module-system/module-implementations/examples/sov-value-setter/src/lib.rs

@@ -42,7 +42,7 @@ impl<C: sov_modules_api::Context> sov_modules_api::Module for ValueSetter<C> {
 
     type CallMessage = call::CallMessage;
 
-    type Event = ();
+    type Event = call::Event;
 
     fn genesis(&self, config: &Self::Config, working_set: &mut WorkingSet<C>) -> Result<(), Error> {
         // The initialization logic

module-system/sov-modules-macros/src/event.rs

@@ -26,6 +26,44 @@ impl<'a> StructDef<'a> {
             })
             .collect()
     }
+
+    fn create_get_key_string_impl(&self) -> proc_macro2::TokenStream {
+        let enum_ident = self.enum_ident(EVENT);
+
+        let match_legs: Vec<proc_macro2::TokenStream> = self
+            .fields
+            .iter()
+            .map(|field| {
+                let module_name = &field.ident;
+                let module_name_str = &field.ident.to_string();
+                quote::quote!(
+                    #enum_ident::#module_name(inner)=>{
+                        let enum_name: String = format!("{:?}", inner)
+                        .split('(')
+                        .collect::<Vec<&str>>()[0].to_string();
+                        format!("{}-{}", #module_name_str, enum_name)
+                    },
+                )
+            })
+            .collect();
+
+        let impl_generics = &self.impl_generics;
+        let enum_ident = self.enum_ident(EVENT);
+        let where_clause = &self.where_clause;
+        let ty_generics = &self.type_generics;
+
+        quote::quote! {
+            impl #impl_generics #enum_ident #ty_generics #where_clause {
+
+                /// Returns a string that identifies both the module and the event type
+                pub fn get_key_string(&self) -> String {
+                    match self {
+                       #(#match_legs)*
+                    }
+                }
+            }
+        }
+    }
 }
 
 impl EventMacro {
@@ -62,12 +100,15 @@ impl EventMacro {
             where_clause,
         );
 
-        let event_enum_legs = struct_def.create_event_enum_legs();
-        let event_enum = struct_def.create_enum(&event_enum_legs, EVENT, &serialization_methods);
+        let enum_legs = struct_def.create_event_enum_legs();
+        let event_enum = struct_def.create_enum(&enum_legs, EVENT, &serialization_methods);
+        let get_key_string_impl = struct_def.create_get_key_string_impl();
 
         Ok(quote::quote! {
             #[doc="This enum is generated from the underlying Runtime, the variants correspond to events from the relevant modules"]
             #event_enum
+
+            #get_key_string_impl
         }
             .into())
     }

module-system/sov-modules-macros/tests/dispatch/derive_event.rs

@@ -1,5 +1,5 @@
 mod modules;
-use modules::{first_test_module, second_test_module};
+use modules::{first_test_module, second_test_module, third_test_module};
 use sov_modules_api::default_context::DefaultContext;
 use sov_modules_api::macros::DefaultRuntime;
 use sov_modules_api::{
@@ -12,12 +12,35 @@ struct Runtime<C: Context>
 {
     pub first: first_test_module::FirstTestStruct<C>,
     pub second: second_test_module::SecondTestStruct<C>,
+    pub third: third_test_module::ThirdTestStruct<C, u32>,
 }
 
 fn main() {
     // Check to see if the runtime events are getting initialized correctly
-    let _event = RuntimeEvent::<DefaultContext>::first(first_test_module::Event::FirstModuleEnum1(10));
-    let _event = RuntimeEvent::<DefaultContext>::first(first_test_module::Event::FirstModuleEnum2);
-    let _event = RuntimeEvent::<DefaultContext>::first(first_test_module::Event::FirstModuleEnum3(vec![1;3]));
-    let _event = RuntimeEvent::<DefaultContext>::second(second_test_module::Event::SecondModuleEnum);
+    {
+        let event = RuntimeEvent::<DefaultContext>::first(first_test_module::Event::FirstModuleEnum1(10));
+        assert_eq!(event.get_key_string(), "first-FirstModuleEnum1");
+    }
+
+    {
+        let event = RuntimeEvent::<DefaultContext>::first(first_test_module::Event::FirstModuleEnum2);
+        assert_eq!(event.get_key_string(), "first-FirstModuleEnum2");
+    }
+
+    {
+        let event = RuntimeEvent::<DefaultContext>::first(first_test_module::Event::FirstModuleEnum3(vec![1; 3]));
+        assert_eq!(event.get_key_string(), "first-FirstModuleEnum3");
+    }
+
+    {
+        let event = RuntimeEvent::<DefaultContext>::second(second_test_module::Event::SecondModuleEnum);
+        assert_eq!(event.get_key_string(), "second-SecondModuleEnum");
+    }
+
+    {
+        // Not sure if this is how we'd want to keep this. But wanted to highlight this edge case.
+        let event = RuntimeEvent::<DefaultContext>::third(());
+        assert_eq!(event.get_key_string(), "third-");
+    }
+
 }