shim: implement block query

Author: rphmeier

sugondat/shim/src/cli.rs

@@ -151,6 +151,82 @@ pub mod query {
     pub enum Commands {
         /// Submits the given blob into a namespace.
         Submit(submit::Params),
+        /// Queries information about a block and header.
+        Block(block::Params),
+    }
+
+    pub mod block {
+        //! CLI definition for the `query block` subcommand.
+
+        use clap::Args;
+
+        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::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[..])),
+                }
+            }
+        }
+
+        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(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[..]);
+                    return Ok(BlockRef::Hash(hash));
+                }
+
+                if let Ok(n) = input.parse::<u64>() {
+                    Ok(BlockRef::Number(n))
+                } else {
+                    Err(format!("parse error. see `--help`"))
+                }
+            }
+        }
+
+        #[derive(Debug, Args)]
+        pub struct Params {
+            #[clap(flatten)]
+            pub rpc: SugondatRpcParams,
+
+            /// The block to query information about.
+            ///
+            /// Possible values: ["best", number, hash]
+            ///
+            /// "best" is the highest finalized block.
+            ///
+            /// Hashes must be 32 bytes, hex-encoded, and prefixed with "0x".
+            #[arg(default_value_t = BlockRef::Best, value_name = "BLOCK_REF")]
+            pub block: BlockRef,
+        }
     }
 
     pub mod submit {

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

@@ -0,0 +1,43 @@
+use super::connect_rpc;
+use crate::cli::query::block::{BlockRef, Params};
+
+pub async fn run(params: Params) -> anyhow::Result<()> {
+    let Params { rpc, block } = 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?;
+
+    println!("Block: #{}", block.number);
+    println!("  Hash: 0x{}", hex::encode(&block.hash[..]));
+    println!("  Parent Hash: 0x{}", hex::encode(&block.parent_hash[..]));
+    println!("  Blobs Root: 0x{}", hex::encode(&block.tree_root.root[..]));
+    println!("  Min Namespace: {}", block.tree_root.min_ns);
+    println!("  Max Namespace: {}", block.tree_root.max_ns);
+    println!("  Timestamp: {}", block.timestamp);
+    println!(
+        "  Blob Count: {} ({} bytes)",
+        block.blobs.len(),
+        block.blobs.iter().map(|b| b.data.len()).sum::<usize>(),
+    );
+    for (i, blob) in block.blobs.into_iter().enumerate() {
+        println!(" Blob #{}", i + 1);
+        println!("    Extrinsic Index: {}", blob.extrinsic_index);
+        println!("    Namespace: {}", &blob.namespace);
+        println!("    Size: {}", blob.data.len());
+    }
+
+    Ok(())
+}

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

@@ -3,11 +3,13 @@ use crate::{
     sugondat_rpc,
 };
 
+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?,
     }
     Ok(())
 }

sugondat/shim/src/dock/rollkit.rs

@@ -34,7 +34,7 @@ impl RollkitRPCServer for RollkitDock {
         );
         let namespace = parse_namespace(&namespace).map_err(|_| err::bad_namespace())?;
         let block_hash = self.client.wait_finalized_height(height).await;
-        let block = self.client.get_block_at(block_hash).await.unwrap();
+        let block = self.client.get_block_at(Some(block_hash)).await.unwrap();
         let mut blobs = vec![];
         for blob in block.blobs {
             if blob.namespace == namespace {

sugondat/shim/src/dock/sovereign.rs

@@ -34,7 +34,7 @@ impl SovereignRPCServer for SovereignDock {
     ) -> Result<Block, ErrorObjectOwned> {
         info!("get_block({})", height);
         let block_hash = self.client.wait_finalized_height(height).await;
-        let block = self.client.get_block_at(block_hash).await.unwrap();
+        let block = self.client.get_block_at(Some(block_hash)).await.unwrap();
         let proof = make_namespace_proof(&block, namespace);
         let blobs = block
             .blobs

sugondat/shim/src/sugondat_rpc/mod.rs

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::key::Keypair;
 use anyhow::Context;
-use subxt::{rpc_params, utils::H256};
+use subxt::{config::Header as _, rpc_params, utils::H256};
 use sugondat_nmt::Namespace;
 use sugondat_subxt::{
     sugondat::runtime_types::pallet_sugondat_blobs::namespace_param::UnvalidatedNamespace, Header,
@@ -103,15 +103,19 @@ impl Client {
     }
 
     /// Returns the header and the body of the block with the given hash, automatically retrying
-    /// until it succeeds.
+    /// until it succeeds. `None` indicates the best block.
     async fn get_header_and_extrinsics(
         &self,
-        block_hash: [u8; 32],
+        block_hash: Option<[u8; 32]>,
     ) -> anyhow::Result<(Header, Vec<sugondat_subxt::ExtrinsicDetails>)> {
-        let block_hash = H256::from(block_hash);
+        let block_hash = block_hash.map(H256::from);
         loop {
             let conn = self.connector.ensure_connected().await;
-            let err = match conn.subxt.blocks().at(block_hash).await {
+            let res = match block_hash {
+                Some(h) => conn.subxt.blocks().at(h).await,
+                None => conn.subxt.blocks().at_latest().await,
+            };
+            let err = match res {
                 Ok(it) => {
                     let header = it.header();
                     let body = match it.extrinsics().await {
@@ -135,15 +139,18 @@ impl Client {
 
     /// Returns the data of the block identified by the given block hash. If the block is not found
     /// returns an error.
+    ///
+    /// `None` indicates that the best block should be used.
     #[tracing::instrument(level = Level::DEBUG, skip(self))]
-    pub async fn get_block_at(&self, block_hash: [u8; 32]) -> anyhow::Result<Block> {
+    pub async fn get_block_at(&self, block_hash: Option<[u8; 32]>) -> anyhow::Result<Block> {
         let (header, extrinsics) = self.get_header_and_extrinsics(block_hash).await?;
         let tree_root = tree_root(&header).ok_or_else(err::no_tree_root)?;
         let timestamp = extract_timestamp(&extrinsics)?;
         let blobs = extract_blobs(extrinsics);
         tracing::debug!(?blobs, "found {} blobs in block", blobs.len());
         Ok(Block {
             number: header.number as u64,
+            hash: header.hash().0,
             parent_hash: header.parent_hash.0,
             tree_root,
             timestamp,
@@ -328,6 +335,7 @@ mod err {
 /// Represents a sugondat block.
 pub struct Block {
     pub number: u64,
+    pub hash: [u8; 32],
     pub parent_hash: [u8; 32],
     pub tree_root: sugondat_nmt::TreeRoot,
     pub timestamp: u64,