Merge pull request #6 from buffrr/spacehash-rpc

Simplify some RPC methods

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,27 +96,21 @@ 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 = "getspaceout")]
+    async fn get_spaceout(&self, outpoint: OutPoint) -> Result<Option<SpaceOut>, 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>;
-
     #[method(name = "getblockdata")]
     async fn get_block_data(
         &self,
@@ -615,71 +610,33 @@ 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)
     }
 
-    async fn estimate_bid(&self, target: usize) -> Result<u64, ErrorObjectOwned> {
-        let info = self
-            .store
-            .estimate_bid(target)
-            .await
-            .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))?;
-        Ok(info)
-    }
-
-    async fn get_rollout(&self, target: usize) -> Result<Vec<(u32, SpaceHash)>, ErrorObjectOwned> {
-        let rollouts = self
-            .store
-            .get_rollout(target)
-            .await
-            .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))?;
-        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(|_| {
+    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",
-                None::<String>,
-            )
-        })?;
-        let space_hash = SpaceHash::from_raw(space_hash).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
@@ -699,6 +656,24 @@ impl RpcServer for RpcServerImpl {
         Ok(spaceout)
     }
 
+    async fn estimate_bid(&self, target: usize) -> Result<u64, ErrorObjectOwned> {
+        let info = self
+            .store
+            .estimate_bid(target)
+            .await
+            .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))?;
+        Ok(info)
+    }
+
+    async fn get_rollout(&self, target: usize) -> Result<Vec<(u32, SpaceHash)>, ErrorObjectOwned> {
+        let rollouts = self
+            .store
+            .get_rollout(target)
+            .await
+            .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))?;
+        Ok(rollouts)
+    }
+
     async fn get_block_data(
         &self,
         block_hash: BlockHash,
@@ -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?
     }

protocol/src/hasher.rs

@@ -1,10 +1,11 @@
-use crate::alloc::string::ToString;
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};
 use bitcoin::{Amount, OutPoint};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use crate::alloc::string::ToString;
+
 pub type Hash = [u8; 32];
 
 pub trait KeyHasher {

protocol/src/lib.rs

@@ -5,8 +5,7 @@ extern crate core;
 
 pub extern crate bitcoin;
 
-use alloc::vec;
-use alloc::vec::Vec;
+use alloc::{vec, vec::Vec};
 
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};

protocol/src/script.rs

@@ -1,5 +1,4 @@
-use alloc::collections::btree_map::BTreeMap;
-use alloc::vec::Vec;
+use alloc::{collections::btree_map::BTreeMap, vec::Vec};
 
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};

protocol/src/validate.rs

@@ -1,6 +1,4 @@
-use alloc::collections::btree_map::BTreeMap;
-use alloc::vec;
-use alloc::vec::Vec;
+use alloc::{collections::btree_map::BTreeMap, vec, vec::Vec};
 
 #[cfg(feature = "bincode")]
 use bincode::{Decode, Encode};