add macros to generate clap commands and args for modules in runtime

adapters/celestia/src/celestia.rs

@@ -1,4 +1,5 @@
 use std::fmt::{Display, Formatter};
+use std::str::FromStr;
 use std::{cell::RefCell, ops::Range};
 
 use borsh::{BorshDeserialize, BorshSerialize};
@@ -335,6 +336,22 @@ impl From<[u8; 32]> for H160 {
     }
 }
 
+impl FromStr for H160 {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Remove the "0x" prefix, if it exists.
+        let s = s.strip_prefix("0x").unwrap_or(s);
+        let bytes = hex::decode(s)?;
+        if bytes.len() != 20 {
+            return Err(anyhow::anyhow!("Invalid address length"));
+        }
+        let mut array = [0; 20];
+        array.copy_from_slice(&bytes);
+        Ok(H160(array))
+    }
+}
+
 impl Display for H160 {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "0x{}", hex::encode(self.0))

adapters/celestia/src/verifier/address.rs

@@ -2,6 +2,7 @@ use borsh::{BorshDeserialize, BorshSerialize};
 use serde::{Deserialize, Serialize};
 use sov_rollup_interface::traits::AddressTrait;
 use std::fmt::{Display, Formatter};
+use std::str::FromStr;
 
 #[derive(Debug, PartialEq, Clone, Eq, Serialize, Deserialize, BorshDeserialize, BorshSerialize)]
 pub struct CelestiaAddress(pub Vec<u8>);
@@ -32,4 +33,15 @@ impl Display for CelestiaAddress {
     }
 }
 
+impl FromStr for CelestiaAddress {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Remove the "0x" prefix, if it exists.
+        let s = s.strip_prefix("0x").unwrap_or(s);
+        let bytes = hex::decode(s)?;
+        Ok(CelestiaAddress(bytes))
+    }
+}
+
 impl AddressTrait for CelestiaAddress {}

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

@@ -6,6 +6,7 @@ use sov_rollup_interface::{
 
 use sov_rollup_interface::traits::AddressTrait;
 use std::fmt::Display;
+use std::str::FromStr;
 
 #[derive(PartialEq, Debug, Clone, Eq, serde::Serialize, serde::Deserialize)]
 pub struct DaAddress {
@@ -26,6 +27,13 @@ impl From<[u8; 32]> for DaAddress {
     }
 }
 
+impl FromStr for DaAddress {
+    type Err = anyhow::Error;
+    fn from_str(_s: &str) -> Result<Self, Self::Err> {
+        unimplemented!()
+    }
+}
+
 impl<'a> TryFrom<&'a [u8]> for DaAddress {
     type Error = anyhow::Error;
 

examples/demo-stf/Cargo.toml

@@ -10,17 +10,16 @@ publish = false
 [[bin]]
 name = "sov-cli"
 path = "src/sov-cli/main.rs"
-required-features = ["native"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 anyhow = { workspace = true}
 borsh = { workspace = true }
 serde = { workspace = true }
-serde_json = { workspace = true, optional = true }
+serde_json = { workspace = true}
 sha2 = { workspace = true }
-clap = { workspace = true, optional = true }
+clap = { workspace = true}
 toml = { workspace = true, optional = true }
 jsonrpsee = { workspace = true, features = ["http-client", "server"], optional = true }
 hex = { workspace = true }
@@ -58,8 +57,6 @@ native = [
 	"sov-value-setter/native",
 	"sov-modules-api/native",
 	"sov-rollup-interface/mocks",
-	"clap",
-	"serde_json",
 	"jsonrpsee",
 	"toml"]
 verifier = []

examples/demo-stf/src/app.rs

@@ -26,7 +26,7 @@ use sov_state::ProverStorage;
 use sov_state::Storage;
 use sov_state::ZkStorage;
 
-pub struct DemoAppRunner<C: Context, Vm: Zkvm> {
+pub struct DemoAppRunner<C: Context + 'static, Vm: Zkvm> {
     pub stf: DemoApp<C, Vm>,
     pub batch_builder: Option<FiFoStrictBatchBuilder<Runtime<C>, C>>,
 }

examples/demo-stf/src/runtime.rs

@@ -5,6 +5,8 @@ use sov_modules_api::Context;
 use sov_modules_macros::{cli_parser, expose_rpc};
 use sov_modules_macros::{DefaultRuntime, DispatchCall, Genesis, MessageCodec};
 
+#[cfg(feature = "native")]
+use clap::Parser;
 #[cfg(feature = "native")]
 use sov_accounts::query::{AccountsRpcImpl, AccountsRpcServer};
 #[cfg(feature = "native")]
@@ -53,12 +55,13 @@ use sov_value_setter::query::{ValueSetterRpcImpl, ValueSetterRpcServer};
 
 #[cfg_attr(
     feature = "native",
-    cli_parser(DefaultContext),
+    cli_parser(DefaultContext, "sequencer"),
     expose_rpc(DefaultContext)
 )]
 #[derive(Genesis, DispatchCall, MessageCodec, DefaultRuntime)]
 #[serialization(borsh::BorshDeserialize, borsh::BorshSerialize)]
 pub struct Runtime<C: Context> {
+    // #[cli_skip]
     pub sequencer: sov_sequencer_registry::Sequencer<C>,
     pub bank: sov_bank::Bank<C>,
     pub election: sov_election::Election<C>,