Accept either space name or its hash. Closes #23

Author: buffrr

node/src/bin/space-cli.rs

@@ -9,7 +9,7 @@ use jsonrpsee::{
 };
 use protocol::{
     bitcoin::{Amount, FeeRate, OutPoint, Txid},
-    hasher::{KeyHasher, SpaceKey},
+    hasher::{KeyHasher},
     slabel::SLabel,
     Covenant, FullSpaceOut,
 };
@@ -216,19 +216,18 @@ 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,
-    },
     /// Force spend an output owned by wallet (for testing only)
     #[command(name = "forcespend")]
     ForceSpend {
         outpoint: OutPoint,
         #[arg(long, short)]
         fee_rate: u64,
     },
+    /// DNS encodes the space and calculates the SHA-256 hash
+    #[command(name = "hashspace")]
+    HashSpace {
+        space: String,
+    },
 }
 
 struct SpaceCli {
@@ -367,11 +366,10 @@ async fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
-fn space_hash(spaceish: &str) -> anyhow::Result<String> {
+fn hash_space(spaceish: &str) -> anyhow::Result<String> {
     let space = normalize_space(&spaceish);
     let sname = SLabel::from_str(&space)?;
-    let spacehash = SpaceKey::from(Sha256::hash(sname.as_ref()));
-    Ok(hex::encode(spacehash.as_slice()))
+    Ok(hex::encode(Sha256::hash(sname.as_ref())))
 }
 
 async fn handle_commands(
@@ -424,7 +422,7 @@ async fn handle_commands(
             println!("{} sat", Amount::from_sat(response).to_string());
         }
         Commands::GetSpace { space } => {
-            let space_hash = space_hash(&space).map_err(|e| ClientError::Custom(e.to_string()))?;
+            let space_hash = hash_space(&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)?);
         }
@@ -603,12 +601,6 @@ 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()))?
-            );
-        }
         Commands::ForceSpend { outpoint, fee_rate } => {
             let result = cli
                 .client
@@ -620,6 +612,12 @@ async fn handle_commands(
                 .await?;
             println!("{}", serde_json::to_string_pretty(&result).expect("result"));
         }
+        Commands::HashSpace { space } => {
+            println!(
+                "{}",
+                hash_space(&space).map_err(|e| ClientError::Custom(e.to_string()))?
+            );
+        }
     }
 
     Ok(())

node/src/rpc.rs

@@ -32,6 +32,8 @@ use tokio::{
     sync::{broadcast, mpsc, oneshot, RwLock},
     task::JoinSet,
 };
+use protocol::hasher::KeyHasher;
+use protocol::slabel::SLabel;
 use wallet::{
     bdk_wallet as bdk, bdk_wallet::template::Bip86, bitcoin::hashes::Hash, export::WalletExport,
     DoubleUtxo, SpacesWallet, WalletConfig, WalletDescriptors, WalletInfo,
@@ -46,6 +48,7 @@ use crate::{
         AddressKind, Balance, RpcWallet, TxResponse, WalletCommand, WalletOutput, WalletResponse,
     },
 };
+use crate::store::Sha256;
 
 pub(crate) type Responder<T> = oneshot::Sender<T>;
 
@@ -101,11 +104,11 @@ pub trait Rpc {
     async fn get_server_info(&self) -> Result<ServerInfo, ErrorObjectOwned>;
 
     #[method(name = "getspace")]
-    async fn get_space(&self, space_hash: &str) -> Result<Option<FullSpaceOut>, ErrorObjectOwned>;
+    async fn get_space(&self, space_or_hash: &str) -> Result<Option<FullSpaceOut>, ErrorObjectOwned>;
 
     #[method(name = "getspaceowner")]
-    async fn get_space_owner(&self, space_hash: &str)
-        -> Result<Option<OutPoint>, ErrorObjectOwned>;
+    async fn get_space_owner(&self, space_or_hash: &str)
+                             -> Result<Option<OutPoint>, ErrorObjectOwned>;
 
     #[method(name = "getspaceout")]
     async fn get_spaceout(&self, outpoint: OutPoint) -> Result<Option<SpaceOut>, ErrorObjectOwned>;
@@ -172,7 +175,7 @@ pub trait Rpc {
 
     #[method(name = "walletlistspaces")]
     async fn wallet_list_spaces(&self, wallet: &str)
-        -> Result<Vec<WalletOutput>, ErrorObjectOwned>;
+                                -> Result<Vec<WalletOutput>, ErrorObjectOwned>;
 
     #[method(name = "walletlistunspent")]
     async fn wallet_list_unspent(
@@ -567,8 +570,9 @@ impl RpcServer for RpcServerImpl {
         Ok(ServerInfo { chain, tip })
     }
 
-    async fn get_space(&self, space_hash: &str) -> Result<Option<FullSpaceOut>, ErrorObjectOwned> {
-        let space_hash = space_hash_from_string(space_hash)?;
+    async fn get_space(&self, space_or_hash: &str) -> Result<Option<FullSpaceOut>, ErrorObjectOwned> {
+        let space_hash = get_space_key(space_or_hash)?;
+
         let info = self
             .store
             .get_space(space_hash)
@@ -579,9 +583,9 @@ impl RpcServer for RpcServerImpl {
 
     async fn get_space_owner(
         &self,
-        space_hash: &str,
+        space_or_hash: &str,
     ) -> Result<Option<OutPoint>, ErrorObjectOwned> {
-        let space_hash = space_hash_from_string(space_hash)?;
+        let space_hash = get_space_key(space_or_hash)?;
         let info = self
             .store
             .get_space_outpoint(space_hash)
@@ -983,20 +987,29 @@ impl AsyncChainState {
     }
 }
 
-fn space_hash_from_string(space_hash: &str) -> Result<SpaceKey, ErrorObjectOwned> {
+fn get_space_key(space_or_hash: &str) -> Result<SpaceKey, ErrorObjectOwned> {
+    if space_or_hash.len() != 64 {
+        return Ok(
+            SpaceKey::from(
+                Sha256::hash(SLabel::try_from(space_or_hash).map_err(|_| {
+                    ErrorObjectOwned::owned(
+                        -1,
+                        "expected a space name prefixed with @ or a hex encoded space hash",
+                        None::<String>,
+                    )
+                })?.as_ref())
+            )
+        );
+    }
+
     let mut hash = [0u8; 32];
-    hex::decode_to_slice(space_hash, &mut hash).map_err(|_| {
+    hex::decode_to_slice(space_or_hash, &mut hash).map_err(|_| {
         ErrorObjectOwned::owned(
             -1,
-            "expected a 32-byte hex encoded space hash",
+            "expected a space name prefixed with @ or a hex encoded space hash",
             None::<String>,
         )
     })?;
-    SpaceKey::from_raw(hash).map_err(|_| {
-        ErrorObjectOwned::owned(
-            -1,
-            "expected a 32-byte hex encoded space hash",
-            None::<String>,
-        )
-    })
+
+    Ok(SpaceKey::from(hash))
 }