Sorting modules by dependencies

adapters/celestia/src/celestia.rs

@@ -339,6 +339,12 @@ impl Display for H160 {
     }
 }
 
+impl std::hash::Hash for H160 {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.as_ref().hash(state);
+    }
+}
+
 impl AddressTrait for H160 {}
 
 pub fn parse_pfb_namespace(

adapters/celestia/src/verifier/address.rs

@@ -55,6 +55,12 @@ impl FromStr for CelestiaAddress {
     }
 }
 
+impl std::hash::Hash for CelestiaAddress {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
+    }
+}
+
 impl AddressTrait for CelestiaAddress {}
 
 #[cfg(test)]

examples/demo-simple-stf/tests/stf_test.rs

@@ -43,6 +43,12 @@ impl Display for DaAddress {
     }
 }
 
+impl std::hash::Hash for DaAddress {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.addr.hash(state);
+    }
+}
+
 #[test]
 fn test_stf() {
     let address = DaAddress { addr: [1; 32] };

module-system/sov-modules-api/src/lib.rs

@@ -26,6 +26,7 @@ pub use sov_rollup_interface::crypto::SimpleHasher as Hasher;
 pub use sov_rollup_interface::AddressTrait;
 use sov_state::{Storage, Witness, WorkingSet};
 use thiserror::Error;
+use std::collections::{HashMap, HashSet};
 
 pub use crate::bech32::AddressBech32;
 
@@ -35,6 +36,12 @@ impl AsRef<[u8]> for Address {
     }
 }
 
+impl std::hash::Hash for Address {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.addr.hash(state);        
+    }
+}
+
 impl AddressTrait for Address {}
 
 #[cfg_attr(feature = "native", derive(schemars::JsonSchema))]
@@ -252,11 +259,14 @@ pub trait ModuleCallJsonSchema: Module {
 }
 
 /// Every module has to implement this trait.
-pub trait ModuleInfo: Default {
+pub trait ModuleInfo {
     type Context: Context;
 
     /// Returns address of the module.
     fn address(&self) -> &<Self::Context as Spec>::Address;
+
+    /// Returns addresses of all the other modules this module is dependent on
+    fn dependencies(&self) -> Vec<&<Self::Context as Spec>::Address>;
 }
 
 /// A StateTransitionRunner needs to implement this if
@@ -265,3 +275,44 @@ pub trait RpcRunner {
     type Context: Context;
     fn get_storage(&self) -> <Self::Context as Spec>::Storage;
 }
+
+/// Sorts ModuleInfo objects by their dependencies
+pub fn sort_by_dependencies<C: Context>(
+    modules: Vec<&dyn ModuleInfo<Context = C>>,
+) -> Result<Vec<&dyn ModuleInfo<Context = C>>, anyhow::Error> {
+
+    fn visit_module<'a, C: Context>(
+        module: &'a dyn ModuleInfo<Context = C>,
+        visited: &mut HashSet<&'a C::Address>,
+        sorted_modules: &mut std::vec::Vec<&'a (dyn ModuleInfo<Context = C> + 'a)>,
+        module_map: &HashMap<&<C as Spec>::Address, &'a (dyn ModuleInfo<Context = C> + 'a)>
+    ) -> Result<(), anyhow::Error> {
+        let address = module.address();
+        if visited.insert(address) {
+            for dependency_address in module.dependencies() {
+                let dependency_module = *module_map.get(dependency_address)
+                    .ok_or_else(|| anyhow::Error::msg(format!("Module not found: {:?}", dependency_address)))?;
+                visit_module(dependency_module, visited, sorted_modules, module_map)?;
+            }
+
+            sorted_modules.push(module);
+        }
+
+        Ok(())
+    }
+
+    let mut module_map = HashMap::new();
+
+    for module in &modules {
+        let address = module.address();        
+        module_map.insert(address, *module);
+    }
+
+    let mut sorted_modules = Vec::new();
+    let mut visited = HashSet::new();
+    for module in modules {
+        visit_module(module, &mut visited, &mut sorted_modules, &module_map)?;
+    }
+
+    Ok(sorted_modules)
+}

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

@@ -95,6 +95,7 @@ impl<'a> StructDef<'a> {
 
         let mut impl_self_init = Vec::default();
         let mut impl_self_body = Vec::default();
+        let mut modules = Vec::default();
 
         let mut module_address = None;
         for field in fields.iter() {
@@ -106,6 +107,7 @@ impl<'a> StructDef<'a> {
                 FieldKind::Module(field) => {
                     impl_self_init.push(make_init_module(field)?);
                     impl_self_body.push(&field.ident);
+                    modules.push(&field.ident);
                 }
                 FieldKind::Address(field) => {
                     impl_self_init.push(make_init_address(
@@ -127,6 +129,7 @@ impl<'a> StructDef<'a> {
         let where_clause = self.where_clause;
 
         let fn_address = make_fn_address(module_address)?;
+        let fn_dependencies = make_fn_dependencies(modules);
 
         Ok(quote::quote! {
             use ::sov_modules_api::AddressTrait;
@@ -145,6 +148,8 @@ impl<'a> StructDef<'a> {
                 type Context = #generic_param;
 
                 #fn_address
+
+                #fn_dependencies
             }
         })
     }
@@ -238,7 +243,7 @@ fn make_fn_address(
 ) -> Result<proc_macro2::TokenStream, syn::Error> {
     match address_ident {
         Some(address_ident) => Ok(quote::quote! {
-            fn address(&self) -> &<Self::Context as sov_modules_api::Spec>::Address{
+            fn address(&self) -> &<Self::Context as sov_modules_api::Spec>::Address {
                &self.#address_ident
             }
         }),
@@ -249,6 +254,19 @@ fn make_fn_address(
     }
 }
 
+fn make_fn_dependencies(modules: Vec<&proc_macro2::Ident>) -> proc_macro2::TokenStream {
+    let address_tokens = modules.iter().map(|ident| {
+        quote::quote! {
+            &self.#ident.address()
+        }
+    });
+
+    quote::quote! {
+        fn dependencies(&self) -> Vec<&<Self::Context as sov_modules_api::Spec>::Address> {
+            vec![#(#address_tokens),*]
+        }
+    }
+}
 fn make_init_state(field: &StructNamedField) -> Result<proc_macro2::TokenStream, syn::Error> {
     let prefix_fun = prefix_func_ident(&field.ident);
     let field_ident = &field.ident;

module-system/sov-modules-macros/tests/module_info/mod_and_state.rs

@@ -2,6 +2,7 @@ use sov_modules_api::default_context::ZkDefaultContext;
 use sov_modules_api::Context;
 use sov_modules_macros::ModuleInfo;
 use sov_state::StateMap;
+use sov_modules_api::ModuleInfo;
 
 pub mod first_test_module {
     use super::*;
@@ -70,4 +71,6 @@ fn main() {
         )
         .into()
     );
+
+    assert_eq!(second_test_struct.dependencies(), [second_test_struct.module_in_second_struct_1.address()]);
 }

rollup-interface/src/state_machine/mocks.rs

@@ -139,6 +139,12 @@ impl Display for MockAddress {
     }
 }
 
+impl std::hash::Hash for MockAddress {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.addr.hash(state);
+    }
+}
+
 impl AddressTrait for MockAddress {}
 
 #[derive(

rollup-interface/src/state_machine/mod.rs

@@ -26,5 +26,6 @@ pub trait AddressTrait:
     + Send
     + Sync
     + core::fmt::Display
+    + std::hash::Hash
 {
 }