Simplify rpc interface to use space names instead of hashes

For now this is sufficient and easier to use until we provide more tooling and design an interface that can be exposed publicly

Author: buffrr

node/src/bin/space-cli.rs

@@ -10,10 +10,8 @@ use jsonrpsee::{
 };
 use protocol::{
     bitcoin::{Amount, FeeRate, OutPoint, Txid},
-    hasher::{KeyHasher, SpaceHash},
     opcodes::OP_SETALL,
-    sname::{NameLike, SName},
-    Covenant,
+    Covenant, FullSpaceOut,
 };
 use serde::{Deserialize, Serialize};
 use spaced::{
@@ -22,7 +20,6 @@ use spaced::{
         BidParams, ExecuteParams, OpenParams, RegisterParams, RpcClient, RpcWalletRequest,
         RpcWalletTxBuilder, SendCoinsParams, TransferSpacesParams,
     },
-    store::Sha256,
     wallets::AddressKind,
 };
 
@@ -374,12 +371,15 @@ async fn handle_commands(
             let hashes = cli.client.get_rollout(target).await?;
             let mut spaceouts = Vec::with_capacity(hashes.len());
             for (priority, spacehash) in hashes {
-                let info = cli
+                let outpoint = cli
                     .client
-                    .get_space_info(hex::encode(spacehash.as_slice()))
+                    .get_space_owner(hex::encode(spacehash.as_slice()))
                     .await?;
-                if let Some(space) = info {
-                    spaceouts.push((priority, space));
+
+                if let Some(outpoint) = outpoint {
+                    if let Some(spaceout) = cli.client.get_spaceout(outpoint).await? {
+                        spaceouts.push((priority, FullSpaceOut { outpoint, spaceout }));
+                    }
                 }
             }
 
@@ -404,13 +404,8 @@ async fn handle_commands(
             println!("{} sat", Amount::from_sat(response).to_string());
         }
         Commands::GetSpace { space } => {
-            let space = SName::try_from(normalize_space(&space).as_str())
-                .map_err(|e| ClientError::Custom(format!("Invalid space name: {}", e)))?;
-            let spacehash = SpaceHash::from(Sha256::hash(space.to_bytes()));
-            let response = cli
-                .client
-                .get_space_info(hex::encode(spacehash.as_slice()))
-                .await?;
+            let space = normalize_space(&space);
+            let response = cli.client.get_space(space).await?;
             println!("{}", serde_json::to_string_pretty(&response)?);
         }
         Commands::GetSpaceOut { outpoint } => {

node/src/rpc.rs

@@ -23,8 +23,9 @@ use protocol::{
         OutPoint,
     },
     constants::ChainAnchor,
-    hasher::{BaseHash, SpaceHash},
+    hasher::{BaseHash, KeyHasher, SpaceHash},
     prepare::DataSource,
+    sname::{NameLike, SName},
     FullSpaceOut, SpaceOut,
 };
 use serde::{Deserialize, Serialize};
@@ -42,7 +43,7 @@ use crate::{
     config::ExtendedNetwork,
     node::ValidatedBlock,
     source::BitcoinRpc,
-    store::{ChainState, LiveSnapshot},
+    store::{ChainState, LiveSnapshot, Sha256},
     wallets::{AddressKind, JointBalance, RpcWallet, TxResponse, WalletCommand, WalletResponse},
 };
 
@@ -58,7 +59,7 @@ pub enum ChainStateCommand {
     GetTip {
         resp: Responder<anyhow::Result<ChainAnchor>>,
     },
-    GetSpaceInfo {
+    GetSpace {
         hash: SpaceHash,
         resp: Responder<anyhow::Result<Option<FullSpaceOut>>>,
     },
@@ -95,24 +96,18 @@ pub trait Rpc {
     #[method(name = "getserverinfo")]
     async fn get_server_info(&self) -> Result<ServerInfo, ErrorObjectOwned>;
 
-    #[method(name = "getspaceinfo")]
-    async fn get_space_info(
-        &self,
-        space_hash: String,
-    ) -> Result<Option<FullSpaceOut>, ErrorObjectOwned>;
+    #[method(name = "getspace")]
+    async fn get_space(&self, space: String) -> Result<Option<FullSpaceOut>, ErrorObjectOwned>;
+
+    #[method(name = "getspaceowner")]
+    async fn get_space_owner(&self, space: String) -> Result<Option<OutPoint>, ErrorObjectOwned>;
 
     #[method(name = "estimatebid")]
     async fn estimate_bid(&self, target: usize) -> Result<u64, ErrorObjectOwned>;
 
     #[method(name = "getrollout")]
     async fn get_rollout(&self, target: usize) -> Result<Vec<(u32, SpaceHash)>, ErrorObjectOwned>;
 
-    #[method(name = "getspaceowner")]
-    async fn get_space_owner(
-        &self,
-        space_hash: String,
-    ) -> Result<Option<OutPoint>, ErrorObjectOwned>;
-
     #[method(name = "getspaceout")]
     async fn get_spaceout(&self, outpoint: OutPoint) -> Result<Option<SpaceOut>, ErrorObjectOwned>;
 
@@ -615,29 +610,19 @@ impl RpcServer for RpcServerImpl {
         Ok(ServerInfo { chain, tip })
     }
 
-    async fn get_space_info(
-        &self,
-        space_hash_str: String,
-    ) -> Result<Option<FullSpaceOut>, ErrorObjectOwned> {
-        let mut space_hash = [0u8; 32];
-        hex::decode_to_slice(space_hash_str, &mut space_hash).map_err(|_| {
-            ErrorObjectOwned::owned(
-                -1,
-                "expected a 32-byte hex encoded space hash a",
-                None::<String>,
-            )
-        })?;
-        let space_hash = SpaceHash::from_raw(space_hash).map_err(|_| {
+    async fn get_space(&self, space: String) -> Result<Option<FullSpaceOut>, ErrorObjectOwned> {
+        let space = SName::from_str(&space).map_err(|_| {
             ErrorObjectOwned::owned(
                 -1,
-                "expected a 32-byte hex encoded space hash b",
+                "must be a valid canonical space name (e.g. @bitcoin)",
                 None::<String>,
             )
         })?;
 
+        let space_hash = SpaceHash::from(Sha256::hash(space.to_bytes()));
         let info = self
             .store
-            .get_space_info(space_hash)
+            .get_space(space_hash)
             .await
             .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))?;
         Ok(info)
@@ -661,25 +646,15 @@ impl RpcServer for RpcServerImpl {
         Ok(rollouts)
     }
 
-    async fn get_space_owner(
-        &self,
-        space_hash_str: String,
-    ) -> Result<Option<OutPoint>, ErrorObjectOwned> {
-        let mut space_hash = [0u8; 32];
-        hex::decode_to_slice(space_hash_str, &mut space_hash).map_err(|_| {
-            ErrorObjectOwned::owned(
-                -1,
-                "expected a 32-byte hex encoded space hash",
-                None::<String>,
-            )
-        })?;
-        let space_hash = SpaceHash::from_raw(space_hash).map_err(|_| {
+    async fn get_space_owner(&self, space: String) -> Result<Option<OutPoint>, ErrorObjectOwned> {
+        let space = SName::from_str(&space).map_err(|_| {
             ErrorObjectOwned::owned(
                 -1,
-                "expected a 32-byte hex encoded space hash",
+                "must be a valid canonical space name (e.g. @bitcoin)",
                 None::<String>,
             )
         })?;
+        let space_hash = SpaceHash::from(Sha256::hash(space.to_bytes()));
 
         let info = self
             .store
@@ -851,7 +826,7 @@ impl AsyncChainState {
                 let tip = chain_state.tip.read().expect("read meta").clone();
                 _ = resp.send(Ok(tip))
             }
-            ChainStateCommand::GetSpaceInfo { hash, resp } => {
+            ChainStateCommand::GetSpace { hash, resp } => {
                 let result = chain_state.get_space_info(&hash);
                 let _ = resp.send(result);
             }
@@ -927,10 +902,10 @@ impl AsyncChainState {
         resp_rx.await?
     }
 
-    pub async fn get_space_info(&self, hash: SpaceHash) -> anyhow::Result<Option<FullSpaceOut>> {
+    pub async fn get_space(&self, hash: SpaceHash) -> anyhow::Result<Option<FullSpaceOut>> {
         let (resp, resp_rx) = oneshot::channel();
         self.sender
-            .send(ChainStateCommand::GetSpaceInfo { hash, resp })
+            .send(ChainStateCommand::GetSpace { hash, resp })
             .await?;
         resp_rx.await?
     }