integrate into sovereign-sdk adapter

Author: rphmeier

sugondat-shim/src/adapters/sovereign.rs

@@ -2,15 +2,16 @@ use jsonrpsee::types::ErrorObjectOwned;
 use sugondat_shim_common_sovereign::{Block, SovereignRPCServer};
 use tracing::info;
 
-use crate::sugondat_rpc;
+use crate::{key::Keypair, sugondat_rpc};
 
 pub struct SovereignAdapter {
     client: sugondat_rpc::Client,
+    submit_key: Option<Keypair>,
 }
 
 impl SovereignAdapter {
-    pub fn new(client: sugondat_rpc::Client) -> Self {
-        Self { client }
+    pub fn new(client: sugondat_rpc::Client, submit_key: Option<Keypair>) -> Self {
+        Self { client, submit_key }
     }
 }
 
@@ -50,7 +51,17 @@ impl SovereignRPCServer for SovereignAdapter {
         namespace: sugondat_nmt::Namespace,
     ) -> Result<(), ErrorObjectOwned> {
         info!("submit_blob({}, {:?})", blob.len(), namespace);
-        self.client.submit_blob(blob, namespace).await.unwrap();
+
+        let submit_key = match self.submit_key.as_ref() {
+            Some(k) => k.clone(),
+            None => return Err(ErrorObjectOwned::owned(
+                jsonrpsee::types::error::INTERNAL_ERROR_CODE,
+                "Internal Error: no key for signing blobs",
+                None::<()>,
+            )),
+        };
+
+        self.client.submit_blob(blob, namespace, submit_key).await.unwrap();
         Ok(())
     }
 }

sugondat-shim/src/cli.rs

@@ -37,9 +37,12 @@ pub struct Cli {
     pub command: Commands,
 }
 
-/// Common parameters for key management subcommand.
+/// Common parameters for key management in a subcommand.
+// TODO: for adapters, this should not be required and for query submit it should
+// be. Unfortunately, clap doesn't support this easily so it is handled manually
+// within the command execution for submit.
 #[derive(clap::Args, Debug)]
-#[group(required = true, multiple = false)]
+#[group(multiple = false)]
 pub struct KeyManagementParams {
     /// Use the Alice development key to sign blob transactions.
     ///
@@ -60,9 +63,6 @@ pub struct KeyManagementParams {
 /// Common parameters for the adapter subcommands.
 #[derive(clap::Args, Debug)]
 pub struct AdapterServerParams {
-    #[clap(flatten)]
-    pub key_management: KeyManagementParams,
-
     /// The address on which the shim should listen for incoming connections from the rollup nodes.
     #[clap(short, long, default_value = "127.0.0.1", group = "listen")]
     pub address: String,
@@ -108,7 +108,7 @@ pub enum Commands {
 pub mod serve {
     //! CLI definition for the `serve` subcommand.
 
-    use super::{AdapterServerParams, SugondatRpcParams};
+    use super::{AdapterServerParams, KeyManagementParams, SugondatRpcParams};
     use clap::Args;
 
     #[derive(Debug, Args)]
@@ -118,6 +118,9 @@ pub mod serve {
 
         #[clap(flatten)]
         pub adapter: AdapterServerParams,
+
+        #[clap(flatten)]
+        pub key_management: KeyManagementParams,
     }
 }
 

sugondat-shim/src/cmd/mod.rs

@@ -31,15 +31,12 @@ fn init_logging() -> anyhow::Result<()> {
     Ok(())
 }
 
-fn fetch_key(params: crate::cli::KeyManagementParams) -> anyhow::Result<key::Keypair> {
+fn load_key(params: crate::cli::KeyManagementParams) -> anyhow::Result<Option<key::Keypair>> {
     if params.submit_dev_alice {
-        return Ok(key::alice())
+        Ok(Some(key::alice()))
+    } else if let Some(path) = params.submit_private_key {
+        Ok(Some(key::load(path)?))
+    } else {
+        Ok(None)
     }
-
-    if let Some(path) = params.submit_private_key {
-        return key::load(path)
-    }
-
-    // sanity: clap is supposed to prevent this
-    return Err(anyhow::anyhow!("No blob submission key specified. See --help"))
 }

sugondat-shim/src/cmd/query/submit.rs

@@ -12,10 +12,15 @@ pub async fn run(params: Params) -> anyhow::Result<()> {
     } = params;
     let blob = read_blob(&blob_path)
         .with_context(|| format!("cannot read blob file path '{}'", blob_path))?;
+
+    let key = crate::cmd::load_key(key_management)
+        .with_context(|| format!("cannot load submission signing key"))?
+        .ok_or_else(|| anyhow::anyhow!("submission signing key required"))?;
+
     let namespace = read_namespace(&namespace)?;
     let client = connect_rpc(rpc).await?;
     tracing::info!("submitting blob to namespace {}", namespace);
-    let block_hash = client.submit_blob(blob, namespace).await?;
+    let block_hash = client.submit_blob(blob, namespace, key).await?;
     tracing::info!("submitted blob to block hash 0x{}", hex::encode(block_hash));
     Ok(())
 }

sugondat-shim/src/cmd/serve.rs

@@ -1,6 +1,7 @@
 use crate::{
     adapters::sovereign::SovereignAdapter,
     cli::{serve::Params, AdapterServerParams},
+    key::Keypair,
     sugondat_rpc::Client,
 };
 
@@ -14,9 +15,10 @@ pub async fn run(params: Params) -> anyhow::Result<()> {
         params.adapter.address, params.adapter.port
     );
     let listen_on = (params.adapter.address.as_str(), params.adapter.port);
+    let maybe_key = crate::cmd::load_key(params.key_management)?;
     let server = Server::builder().build(listen_on).await?;
     let client = connect_client(&params.rpc.node_url).await?;
-    let handle = server.start(init_adapters(client, &params.adapter));
+    let handle = server.start(init_adapters(client, &params.adapter, maybe_key));
     handle.stopped().await;
     Ok(())
 }
@@ -26,11 +28,15 @@ async fn connect_client(url: &str) -> anyhow::Result<Client> {
     Ok(client)
 }
 
-fn init_adapters(client: Client, adapter: &AdapterServerParams) -> Methods {
+fn init_adapters(
+    client: Client, 
+    adapter: &AdapterServerParams,
+    maybe_key: Option<Keypair>,
+) -> Methods {
     let mut methods = Methods::new();
     if adapter.enable_sovereign() {
         debug!("enabling sovereign adapter");
-        let adapter = SovereignAdapter::new(client.clone());
+        let adapter = SovereignAdapter::new(client.clone(), maybe_key);
         methods.merge(adapter.into_rpc()).unwrap();
     }
     methods

sugondat-shim/src/sugondat_rpc.rs

@@ -4,6 +4,7 @@ use sugondat_nmt::Namespace;
 use sugondat_subxt::{
     sugondat::runtime_types::bounded_collections::bounded_vec::BoundedVec, Header,
 };
+use crate::key::Keypair;
 
 // NOTE: we specifically avoid prolifiration of subxt types around the codebase. To that end, we
 //       avoid returning H256 and instead return [u8; 32] directly.
@@ -79,25 +80,24 @@ impl Client {
         })
     }
 
-    /// Submit a blob with the given namespace. Returns a block hash in which the extrinsic was
-    /// included.
+    /// Submit a blob with the given namespace and signed with the given key.
+    ///
+    /// Returns a block hash in which the extrinsic was included.
     pub async fn submit_blob(
         &self,
         blob: Vec<u8>,
         namespace: sugondat_nmt::Namespace,
+        key: Keypair,
     ) -> anyhow::Result<[u8; 32]> {
-        use subxt_signer::sr25519::dev;
-
         let namespace_id = namespace.namespace_id();
         let extrinsic = sugondat_subxt::sugondat::tx()
             .blob()
             .submit_blob(namespace_id, BoundedVec(blob));
 
-        let from = dev::alice();
         let signed = self
             .subxt
             .tx()
-            .create_signed(&extrinsic, &from, Default::default())
+            .create_signed(&extrinsic, &key, Default::default())
             .await
             .with_context(|| format!("failed to validate or sign extrinsic with dev key pair"))?;