shim: blob query

Author: rphmeier

sugondat/shim/src/cli.rs

@@ -133,11 +133,6 @@ pub mod serve {
 pub mod query {
     //! CLI definition for the `query` subcommand.
 
-    // TODO: I envision several subcommands here. For example:
-    // - query block <block_hash/number> — returns the information about a block and header.
-    // - query blob <id> - returns the blob for a given key. The key here is the same sense as
-    //   described here https://github.com/thrumdev/blobs/issues/9#issuecomment-1814005570.
-
     use super::{KeyManagementParams, SugondatRpcParams, ENV_SUGONDAT_NAMESPACE};
     use clap::{Args, Subcommand};
 
@@ -153,64 +148,105 @@ pub mod query {
         Submit(submit::Params),
         /// Queries information about a block and header.
         Block(block::Params),
+        /// Queries information about a specific blob.
+        Blob(blob::Params),
     }
 
-    pub mod block {
-        //! CLI definition for the `query block` subcommand.
+    /// A reference to a block to query.
+    #[derive(Debug, Clone)]
+    pub enum BlockRef {
+        /// The current best finalized block known by the node.
+        Best,
+        /// The number of the block to query.
+        Number(u64),
+        /// The hex-encoded hash of the block to query, prefixed with "0x".
+        Hash([u8; 32]),
+    }
 
-        use clap::Args;
+    impl std::fmt::Display for BlockRef {
+        fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+            match *self {
+                BlockRef::Best => write!(f, "best"),
+                BlockRef::Number(n) => write!(f, "{}", n),
+                BlockRef::Hash(h) => write!(f, "0x{}", hex::encode(&h[..])),
+            }
+        }
+    }
 
-        use super::SugondatRpcParams;
-
-        /// A reference to a block to query.
-        #[derive(Debug, Clone)]
-        pub enum BlockRef {
-            /// The current best finalized block known by the node.
-            Best,
-            /// The number of the block to query.
-            Number(u64),
-            /// The hex-encoded hash of the block to query, prefixed with "0x".
-            Hash([u8; 32]),
+    impl std::str::FromStr for BlockRef {
+        type Err = String;
+
+        fn from_str(input: &str) -> Result<Self, Self::Err> {
+            if input == "best" {
+                return Ok(BlockRef::Best);
+            }
+
+            if let Some(hash) = decode_hash(input)? {
+                return Ok(BlockRef::Hash(hash));
+            }
+
+            if let Ok(n) = input.parse::<u64>() {
+                Ok(BlockRef::Number(n))
+            } else {
+                Err(format!("parse error. see `--help`"))
+            }
         }
+    }
 
-        impl std::fmt::Display for BlockRef {
-            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-                match *self {
-                    BlockRef::Best => write!(f, "best"),
-                    BlockRef::Number(n) => write!(f, "{}", n),
-                    BlockRef::Hash(h) => write!(f, "0x{}", hex::encode(&h[..])),
-                }
+    fn decode_hash(input: &str) -> Result<Option<[u8; 32]>, String> {
+        if let Some(s) = input.strip_prefix("0x") {
+            let bytes =
+                hex::decode(s).map_err(|_| "Invalid parameter: not hex encoded".to_owned())?;
+
+            let mut hash = [0u8; 32];
+            if bytes.len() != 32 {
+                return Err("Invalid parameter: hash not 32 bytes".to_owned());
             }
+
+            hash.copy_from_slice(&bytes[..]);
+            Ok(Some(hash))
+        } else {
+            Ok(None)
         }
+    }
 
-        impl std::str::FromStr for BlockRef {
-            type Err = String;
+    pub mod blob {
+        use clap::Args;
 
-            fn from_str(input: &str) -> Result<Self, Self::Err> {
-                if input == "best" {
-                    return Ok(BlockRef::Best);
-                }
+        use super::{BlockRef, SugondatRpcParams};
 
-                if let Some(s) = input.strip_prefix("0x") {
-                    let bytes = hex::decode(s)
-                        .map_err(|_| "Invalid parameter: not hex encoded".to_owned())?;
+        #[derive(Debug, Args)]
+        pub struct Params {
+            #[clap(flatten)]
+            pub rpc: SugondatRpcParams,
 
-                    let mut hash = [0u8; 32];
-                    if bytes.len() != 32 {
-                        return Err("Invalid parameter: hash not 32 bytes".to_owned());
-                    }
+            /// The block containing the blob to query.
+            ///
+            /// Possible values: ["best", number, hash]
+            ///
+            /// "best" is the highest finalized block.
+            ///
+            /// Hashes must be 32 bytes, hex-encoded, and prefixed with "0x".
+            #[arg(value_name = "BLOCK_REF")]
+            pub block: BlockRef,
 
-                    hash.copy_from_slice(&bytes[..]);
-                    return Ok(BlockRef::Hash(hash));
-                }
+            /// The index of the extrinsic (transaction) containing the blob.
+            #[arg(value_name = "INDEX")]
+            pub index: u32,
 
-                if let Ok(n) = input.parse::<u64>() {
-                    Ok(BlockRef::Number(n))
-                } else {
-                    Err(format!("parse error. see `--help`"))
-                }
-            }
+            /// Output the blob data as binary to stdout rather than hex, and omits
+            /// any other details intended for human consumption.
+            #[arg(long)]
+            pub raw: bool,
         }
+    }
+
+    pub mod block {
+        //! CLI definition for the `query block` subcommand.
+
+        use clap::Args;
+
+        use super::{BlockRef, SugondatRpcParams};
 
         #[derive(Debug, Args)]
         pub struct Params {

sugondat/shim/src/cmd/query/blob.rs

@@ -0,0 +1,50 @@
+use super::connect_rpc;
+use crate::cli::query::{blob::Params, BlockRef};
+
+use std::io::Write;
+
+pub async fn run(params: Params) -> anyhow::Result<()> {
+    let Params {
+        rpc,
+        block,
+        index,
+        raw,
+    } = params;
+
+    let client = connect_rpc(rpc).await?;
+
+    let maybe_hash = match block {
+        BlockRef::Best => None,
+        BlockRef::Hash(h) => Some(h),
+        BlockRef::Number(n) => Some(
+            client
+                .block_hash(n)
+                .await?
+                .ok_or_else(|| anyhow::anyhow!("No block with number {}", n))?
+                .0,
+        ),
+    };
+
+    let block = client.get_block_at(maybe_hash).await?;
+
+    let i = block
+        .blobs
+        .binary_search_by_key(&index, |b| b.extrinsic_index)
+        .map_err(|_| anyhow::anyhow!("No blob with extrinsic index {}", index))?;
+
+    let blob = block.blobs.get(i).expect("verified to exist above; qed");
+
+    if raw {
+        std::io::stdout().write_all(&blob.data)?;
+    } else {
+        println!(
+            " Blob #{}, Namespace {}, {} bytes",
+            i + 1,
+            &blob.namespace,
+            blob.data.len()
+        );
+        println!("{}", hex::encode(&blob.data));
+    }
+
+    Ok(())
+}

sugondat/shim/src/cmd/query/block.rs

@@ -1,5 +1,5 @@
 use super::connect_rpc;
-use crate::cli::query::block::{BlockRef, Params};
+use crate::cli::query::{block::Params, BlockRef};
 
 pub async fn run(params: Params) -> anyhow::Result<()> {
     let Params { rpc, block } = params;

sugondat/shim/src/cmd/query/mod.rs

@@ -3,13 +3,15 @@ use crate::{
     sugondat_rpc,
 };
 
+mod blob;
 mod block;
 mod submit;
 
 pub async fn run(params: Params) -> anyhow::Result<()> {
     match params.command {
         Commands::Submit(params) => submit::run(params).await?,
         Commands::Block(params) => block::run(params).await?,
+        Commands::Blob(params) => blob::run(params).await?,
     }
     Ok(())
 }