Require space hashes directly for some rpc calls

Author: buffrr

node/src/bin/space-cli.rs

@@ -1,6 +1,6 @@
 extern crate core;
 
-use std::{fs, path::PathBuf};
+use std::{fs, path::PathBuf, str::FromStr};
 
 use base64::{prelude::BASE64_STANDARD, Engine};
 use clap::{Parser, Subcommand};
@@ -10,7 +10,9 @@ use jsonrpsee::{
 };
 use protocol::{
     bitcoin::{Amount, FeeRate, OutPoint, Txid},
+    hasher::{KeyHasher, SpaceHash},
     opcodes::OP_SETALL,
+    sname::{NameLike, SName},
     Covenant, FullSpaceOut,
 };
 use serde::{Deserialize, Serialize};
@@ -20,6 +22,7 @@ use spaced::{
         BidParams, ExecuteParams, OpenParams, RegisterParams, RpcClient, RpcWalletRequest,
         RpcWalletTxBuilder, SendCoinsParams, TransferSpacesParams,
     },
+    store::Sha256,
     wallets::AddressKind,
 };
 
@@ -222,6 +225,12 @@ enum Commands {
     /// compatible with most bitcoin wallets
     #[command(name = "getnewaddress")]
     GetCoinAddress,
+    /// Calculate a spacehash from the specified space name
+    #[command(name = "spacehash")]
+    SpaceHash {
+        /// The space name
+        space: String,
+    },
 }
 
 struct SpaceCli {
@@ -360,6 +369,13 @@ async fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
+fn space_hash(spaceish: &str) -> anyhow::Result<String> {
+    let space = normalize_space(&spaceish);
+    let sname = SName::from_str(&space)?;
+    let spacehash = SpaceHash::from(Sha256::hash(sname.to_bytes()));
+    Ok(hex::encode(spacehash.as_slice()))
+}
+
 async fn handle_commands(
     cli: &SpaceCli,
     command: Commands,
@@ -404,8 +420,8 @@ async fn handle_commands(
             println!("{} sat", Amount::from_sat(response).to_string());
         }
         Commands::GetSpace { space } => {
-            let space = normalize_space(&space);
-            let response = cli.client.get_space(&space).await?;
+            let space_hash = space_hash(&space).map_err(|e| ClientError::Custom(e.to_string()))?;
+            let response = cli.client.get_space(&space_hash).await?;
             println!("{}", serde_json::to_string_pretty(&response)?);
         }
         Commands::GetSpaceOut { outpoint } => {
@@ -580,6 +596,12 @@ async fn handle_commands(
                 .await?;
             println!("{}", serde_json::to_string_pretty(&response)?);
         }
+        Commands::SpaceHash { space } => {
+            println!(
+                "{}",
+                space_hash(&space).map_err(|e| ClientError::Custom(e.to_string()))?
+            );
+        }
     }
 
     Ok(())

node/src/rpc.rs

@@ -23,9 +23,8 @@ use protocol::{
         OutPoint,
     },
     constants::ChainAnchor,
-    hasher::{BaseHash, KeyHasher, SpaceHash},
+    hasher::{BaseHash, SpaceHash},
     prepare::DataSource,
-    sname::{NameLike, SName},
     FullSpaceOut, SpaceOut,
 };
 use serde::{Deserialize, Serialize};
@@ -43,7 +42,7 @@ use crate::{
     config::ExtendedNetwork,
     node::ValidatedBlock,
     source::BitcoinRpc,
-    store::{ChainState, LiveSnapshot, Sha256},
+    store::{ChainState, LiveSnapshot},
     wallets::{AddressKind, JointBalance, RpcWallet, TxResponse, WalletCommand, WalletResponse},
 };
 
@@ -97,10 +96,11 @@ pub trait Rpc {
     async fn get_server_info(&self) -> Result<ServerInfo, ErrorObjectOwned>;
 
     #[method(name = "getspace")]
-    async fn get_space(&self, space: &str) -> Result<Option<FullSpaceOut>, ErrorObjectOwned>;
+    async fn get_space(&self, space_hash: &str) -> Result<Option<FullSpaceOut>, ErrorObjectOwned>;
 
     #[method(name = "getspaceowner")]
-    async fn get_space_owner(&self, space: &str) -> Result<Option<OutPoint>, ErrorObjectOwned>;
+    async fn get_space_owner(&self, space_hash: &str)
+        -> Result<Option<OutPoint>, ErrorObjectOwned>;
 
     #[method(name = "getspaceout")]
     async fn get_spaceout(&self, outpoint: OutPoint) -> Result<Option<SpaceOut>, ErrorObjectOwned>;
@@ -603,16 +603,8 @@ impl RpcServer for RpcServerImpl {
         Ok(ServerInfo { chain, tip })
     }
 
-    async fn get_space(&self, space: &str) -> Result<Option<FullSpaceOut>, ErrorObjectOwned> {
-        let space = SName::from_str(&space).map_err(|_| {
-            ErrorObjectOwned::owned(
-                -1,
-                "must be a valid canonical space name (e.g. @bitcoin)",
-                None::<String>,
-            )
-        })?;
-
-        let space_hash = SpaceHash::from(Sha256::hash(space.to_bytes()));
+    async fn get_space(&self, space_hash: &str) -> Result<Option<FullSpaceOut>, ErrorObjectOwned> {
+        let space_hash = space_hash_from_string(space_hash)?;
         let info = self
             .store
             .get_space(space_hash)
@@ -621,16 +613,11 @@ impl RpcServer for RpcServerImpl {
         Ok(info)
     }
 
-    async fn get_space_owner(&self, space: &str) -> Result<Option<OutPoint>, ErrorObjectOwned> {
-        let space = SName::from_str(space).map_err(|_| {
-            ErrorObjectOwned::owned(
-                -1,
-                "must be a valid canonical space name (e.g. @bitcoin)",
-                None::<String>,
-            )
-        })?;
-        let space_hash = SpaceHash::from(Sha256::hash(space.to_bytes()));
-
+    async fn get_space_owner(
+        &self,
+        space_hash: &str,
+    ) -> Result<Option<OutPoint>, ErrorObjectOwned> {
+        let space_hash = space_hash_from_string(space_hash)?;
         let info = self
             .store
             .get_space_outpoint(space_hash)
@@ -936,3 +923,21 @@ impl AsyncChainState {
         resp_rx.await?
     }
 }
+
+fn space_hash_from_string(space_hash: &str) -> Result<SpaceHash, ErrorObjectOwned> {
+    let mut hash = [0u8; 32];
+    hex::decode_to_slice(space_hash, &mut hash).map_err(|_| {
+        ErrorObjectOwned::owned(
+            -1,
+            "expected a 32-byte hex encoded space hash",
+            None::<String>,
+        )
+    })?;
+    SpaceHash::from_raw(hash).map_err(|_| {
+        ErrorObjectOwned::owned(
+            -1,
+            "expected a 32-byte hex encoded space hash",
+            None::<String>,
+        )
+    })
+}