CreatePtr Data Parsing

Author: spacesops

SUBSPACES.md

@@ -86,6 +86,12 @@ You can create an on-chain identifier that only the controller of the script pub
 $ space-cli createptr 5120d3c3196cb3ed7fa79c882ed62f8e5942e546130d5ae5983da67dbb6c9bdd2e79
 ```
 
+Optionally, you can set hex-encoded data on the created pointer using the `--data` parameter:
+
+```bash
+$ space-cli createptr 5120d3c3196cb3ed7fa79c882ed62f8e5942e546130d5ae5983da67dbb6c9bdd2e79 --data deadbeef
+```
+
 This command creates a UTXO with the same script pubkey and "mints" a space pointer (sptr) derived from it:
 
 ```

client/src/bin/space-cli.rs

@@ -24,7 +24,7 @@ use spaces_client::{
     config::{default_cookie_path, default_spaces_rpc_port, ExtendedNetwork},
     deserialize_base64,
     format::{
-        print_error_rpc_response, print_list_bidouts, print_list_spaces_response,
+        print_error_rpc_response, print_list_all_spaces, print_list_bidouts, print_list_spaces_response,
         print_list_transactions, print_list_unspent, print_list_wallets, print_server_info,
         print_wallet_balance_response, print_wallet_info, print_wallet_response, Format,
     },
@@ -157,6 +157,10 @@ enum Commands {
         /// The script public key as hex string
         spk: String,
 
+        /// Hex encoded data to set on the created ptr
+        #[arg(long)]
+        data: Option<String>,
+
         #[arg(long, short)]
         fee_rate: Option<u64>,
     },
@@ -166,6 +170,13 @@ enum Commands {
         /// The sha256 hash of the spk or the spk itself prefixed with hex:
         spk: String,
     },
+    /// Get all ptrs info (same output format as getptr)
+    #[command(name = "getallptrs")]
+    GetAllPtrs {
+        /// Only return PTRs with non-null data
+        #[arg(long)]
+        with_data: bool,
+    },
     /// Transfer ownership of spaces and/or PTRs to the given name or address
     #[command(
         name = "transfer",
@@ -425,6 +436,9 @@ enum Commands {
     /// still in auction with a winning bid
     #[command(name = "listspaces")]
     ListSpaces,
+    /// List all spaces in the chain state (not just wallet-related)
+    #[command(name = "listallspaces")]
+    ListAllSpaces,
     /// List unspent auction outputs i.e. outputs that can be
     /// auctioned off in the bidding process
     #[command(name = "listbidouts")]
@@ -672,6 +686,40 @@ async fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
+fn parse_ptr_for_json(ptr: &spaces_ptr::FullPtrOut) -> serde_json::Value {
+    use spaces_ptr::vtlv;
+    
+    let mut ptr_json = serde_json::to_value(ptr).expect("ptr should be serializable");
+    
+    // Since ptrout and sptr are flattened via serde(flatten), the data field
+    // appears directly in the JSON object, not nested. Look for "data" at the top level.
+    if let Some(obj) = ptr_json.as_object_mut() {
+        if let Some(data) = obj.remove("data") {
+            // Bytes serializes as hex string in JSON
+            if let Some(hex_str) = data.as_str() {
+                if let Ok(data_bytes) = hex::decode(hex_str) {
+                    match vtlv::parse_vtlv(&data_bytes) {
+                        Ok(parsed) => {
+                            obj.insert("parsed".to_string(), serde_json::to_value(parsed).expect("parsed should be serializable"));
+                        }
+                        Err(_) => {
+                            // If parsing fails, keep the original data
+                            obj.insert("data".to_string(), data);
+                        }
+                    }
+                } else {
+                    obj.insert("data".to_string(), data);
+                }
+            } else {
+                // Not a string, keep as-is
+                obj.insert("data".to_string(), data);
+            }
+        }
+    }
+    
+    ptr_json
+}
+
 async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), ClientError> {
     match command {
         Commands::GetRollout {
@@ -894,6 +942,9 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
                 .await?;
             } else {
                 // TODO: support set data for spaces
+                return Err(ClientError::Custom(format!(
+                    "setrawfallback: setting data for spaces is not yet supported. Use an SPTR (sptr1...) instead of a space name."
+                )));
                 // // Space fallback: use existing space script
                 // let space = normalize_space(&space_or_sptr);
                 // let space_script =
@@ -931,6 +982,11 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
             let spaces = cli.client.wallet_list_spaces(&cli.wallet).await?;
             print_list_spaces_response(tip.tip.height, spaces, cli.format);
         }
+        Commands::ListAllSpaces => {
+            let tip = cli.client.get_server_info().await?;
+            let spaces = cli.client.get_all_spaces().await?;
+            print_list_all_spaces(tip.tip.height, spaces, cli.format);
+        }
         Commands::Balance => {
             let balance = cli.client.wallet_get_balance(&cli.wallet).await?;
             print_wallet_balance_response(balance, cli.format);
@@ -1100,15 +1156,25 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
 
             println!("{}", serde_json::to_string(&event).expect("result"));
         }
-        Commands::CreatePtr { spk, fee_rate } => {
+        Commands::CreatePtr { spk, data, fee_rate } => {
             let spk = ScriptBuf::from(hex::decode(spk)
                 .map_err(|_| ClientError::Custom("Invalid spk hex".to_string()))?);
 
+            let data = match data {
+                Some(data_hex) => {
+                    Some(hex::decode(data_hex).map_err(|e| {
+                        ClientError::Custom(format!("Could not hex decode data: {}", e))
+                    })?)
+                }
+                None => None,
+            };
+
             let sptr = Sptr::from_spk::<Sha256>(spk.clone());
             println!("Creating sptr: {}", sptr);
             cli.send_request(
                 Some(RpcWalletRequest::CreatePtr(CreatePtrParams {
                     spk: hex::encode(spk.as_bytes()),
+                    data,
                 })),
                 None,
                 fee_rate,
@@ -1127,6 +1193,17 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
                 .map_err(|e| ClientError::Custom(e.to_string()))?;
             println!("{}", serde_json::to_string(&ptr).expect("result"));
         }
+        Commands::GetAllPtrs { with_data } => {
+            let ptrs = cli
+                .client
+                .get_all_ptrs(with_data)
+                .await
+                .map_err(|e| ClientError::Custom(e.to_string()))?;
+            let parsed_ptrs: Vec<serde_json::Value> = ptrs.iter()
+                .map(|ptr| parse_ptr_for_json(ptr))
+                .collect();
+            println!("{}", serde_json::to_string(&parsed_ptrs).expect("result"));
+        }
 
         Commands::GetPtrOut { outpoint } => {
             let ptrout = cli

client/src/format.rs

@@ -3,7 +3,7 @@ use colored::{Color, Colorize};
 use jsonrpsee::core::Serialize;
 use serde::Deserialize;
 use spaces_protocol::{
-    bitcoin::{Amount, Network, OutPoint}, Covenant
+    bitcoin::{Amount, Network, OutPoint}, Covenant, FullSpaceOut
 };
 use spaces_wallet::{
     address::SpaceAddress,
@@ -124,6 +124,48 @@ pub fn print_list_bidouts(bidouts: Vec<DoubleUtxo>, format: Format) {
     }
 }
 
+pub fn print_list_all_spaces(
+    _current_block: u32,
+    spaces: Vec<FullSpaceOut>,
+    format: Format,
+) {
+    match format {
+        Format::Text => {
+            #[derive(Tabled)]
+            struct AllSpaces {
+                space: String,
+                status: String,
+                value: String,
+                txid: String,
+            }
+
+            let mut table_data = Vec::new();
+            for space_out in spaces {
+                let space = space_out.spaceout.space.as_ref();
+                let space_name = space.map(|s| s.name.to_string()).unwrap_or_else(|| "unknown".to_string());
+                // All spaces returned are owned (filtered in get_all_spaces)
+                table_data.push(AllSpaces {
+                    space: space_name,
+                    status: "OWNED".to_string(),
+                    value: format!("{} sats", space_out.spaceout.value.to_sat()),
+                    txid: format!("{}", space_out.txid),
+                });
+            }
+
+            if table_data.is_empty() {
+                println!("No spaces found.");
+            } else {
+                println!("All Spaces ({} total):", table_data.len());
+                let table = Table::new(table_data);
+                println!("{}", table);
+            }
+        }
+        Format::Json => {
+            println!("{}", serde_json::to_string_pretty(&spaces).unwrap());
+        }
+    }
+}
+
 pub fn print_list_transactions(txs: Vec<TxInfo>, format: Format) {
     match format {
         Format::Text => {

client/src/rpc.rs

@@ -169,6 +169,13 @@ pub enum ChainStateCommand {
         outpoint: OutPoint,
         resp: Responder<anyhow::Result<Option<PtrOut>>>,
     },
+    GetAllSpaces {
+        resp: Responder<anyhow::Result<Vec<FullSpaceOut>>>,
+    },
+    GetAllPtrs {
+        with_data: bool,
+        resp: Responder<anyhow::Result<Vec<FullPtrOut>>>,
+    },
     GetTxMeta {
         txid: Txid,
         resp: Responder<anyhow::Result<Option<TxEntry>>>,
@@ -277,6 +284,12 @@ pub trait Rpc {
     #[method(name = "getdelegator")]
     async fn get_delegator(&self, sptr: Sptr) -> Result<Option<SLabel>, ErrorObjectOwned>;
 
+    #[method(name = "getallspaces")]
+    async fn get_all_spaces(&self) -> Result<Vec<FullSpaceOut>, ErrorObjectOwned>;
+
+    #[method(name = "getallptrs")]
+    async fn get_all_ptrs(&self, with_data: bool) -> Result<Vec<FullPtrOut>, ErrorObjectOwned>;
+
     #[method(name = "checkpackage")]
     async fn check_package(
         &self,
@@ -546,6 +559,8 @@ pub struct TransferSpacesParams {
 #[derive(Clone, Serialize, Deserialize)]
 pub struct CreatePtrParams {
     pub spk: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<Vec<u8>>,
 }
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -1075,6 +1090,19 @@ impl RpcServer for RpcServerImpl {
         Ok(delegator)
     }
 
+    async fn get_all_spaces(&self) -> Result<Vec<FullSpaceOut>, ErrorObjectOwned> {
+        let spaces = self.store.get_all_spaces()
+            .await
+            .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))?;
+        Ok(spaces)
+    }
+
+    async fn get_all_ptrs(&self, with_data: bool) -> Result<Vec<FullPtrOut>, ErrorObjectOwned> {
+        let ptrs = self.store.get_all_ptrs(with_data)
+            .await
+            .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))?;
+        Ok(ptrs)
+    }
 
     async fn check_package(
         &self,
@@ -1630,6 +1658,14 @@ impl AsyncChainState {
                     .context("could not fetch ptrouts");
                 let _ = resp.send(result);
             }
+            ChainStateCommand::GetAllSpaces { resp } => {
+                let result = get_all_spaces(state);
+                let _ = resp.send(result);
+            }
+            ChainStateCommand::GetAllPtrs { with_data, resp } => {
+                let result = get_all_ptrs(state, with_data);
+                let _ = resp.send(result);
+            }
             ChainStateCommand::GetBlockMeta {
                 height_or_hash,
                 resp,
@@ -2198,6 +2234,22 @@ impl AsyncChainState {
         resp_rx.await?
     }
 
+    pub async fn get_all_spaces(&self) -> anyhow::Result<Vec<FullSpaceOut>> {
+        let (resp, resp_rx) = oneshot::channel();
+        self.sender
+            .send(ChainStateCommand::GetAllSpaces { resp })
+            .await?;
+        resp_rx.await?
+    }
+
+    pub async fn get_all_ptrs(&self, with_data: bool) -> anyhow::Result<Vec<FullPtrOut>> {
+        let (resp, resp_rx) = oneshot::channel();
+        self.sender
+            .send(ChainStateCommand::GetAllPtrs { with_data, resp })
+            .await?;
+        resp_rx.await?
+    }
+
     pub async fn get_block_meta(
         &self,
         height_or_hash: HeightOrHash,
@@ -2310,6 +2362,14 @@ fn get_delegation(state: &mut Chain, space: SLabel) -> anyhow::Result<Option<Spt
     }
 }
 
+fn get_all_spaces(state: &mut Chain) -> anyhow::Result<Vec<FullSpaceOut>> {
+    state.get_all_spaces()
+}
+
+fn get_all_ptrs(state: &mut Chain, with_data: bool) -> anyhow::Result<Vec<FullPtrOut>> {
+    state.get_all_ptrs(with_data)
+}
+
 fn get_commitment(state: &mut Chain, space: SLabel, root: Option<Hash>) -> anyhow::Result<Option<Commitment>> {
     let root = match root {
         None => {

client/src/store/chain.rs

@@ -91,10 +91,18 @@ impl Chain {
         self.db.sp.state.get_space_info(space_hash)
     }
 
+    pub fn get_all_spaces(&mut self) -> anyhow::Result<Vec<FullSpaceOut>> {
+        self.db.sp.state.get_all_spaces()
+    }
+
     pub fn get_ptr_info(&mut self, key: &Sptr) -> anyhow::Result<Option<FullPtrOut>> {
         self.db.pt.state.get_ptr_info(key)
     }
 
+    pub fn get_all_ptrs(&mut self, with_data: bool) -> anyhow::Result<Vec<FullPtrOut>> {
+        self.db.pt.state.get_all_ptrs(with_data)
+    }
+
     pub fn load(_network: Network, genesis: ChainAnchor, ptrs_genesis: ChainAnchor, dir: &Path, index_spaces: bool, index_ptrs: bool) -> anyhow::Result<Self> {
         let proto_db_path = dir.join("protocol.sdb");
         let ptrs_db_path = dir.join("ptrs.sdb");