Support setrawfallback for sptrs in space-cli

buffrr · buffrr · commit 7aef424c9191 · 2025-11-24T19:40:34.000+01:00
diff --git a/client/src/bin/space-cli.rs b/client/src/bin/space-cli.rs
@@ -35,7 +35,7 @@ use spaces_client::{
     serialize_base64,
     wallets::{AddressKind, WalletResponse},
 };
-use spaces_client::rpc::{CommitParams, CreatePtrParams, DelegateParams, TransferPtrParams};
+use spaces_client::rpc::{CommitParams, CreatePtrParams, DelegateParams, SetPtrDataParams, TransferPtrParams};
 use spaces_client::store::Sha256;
 use spaces_protocol::bitcoin::{Amount, FeeRate, OutPoint, Txid};
 use spaces_protocol::slabel::SLabel;
@@ -415,11 +415,11 @@ enum Commands {
         #[arg(default_value = "0")]
         target_interval: usize,
     },
-    /// Associate on-chain record data with a space as a fallback to P2P options like Fabric.
+    /// Associate on-chain record data with a space/sptr as a fallback to P2P options like Fabric.
     #[command(name = "setrawfallback")]
     SetRawFallback {
-        /// Space name
-        space: String,
+        /// Space name or SPTR identifier
+        space_or_sptr: String,
         /// Hex encoded data
         data: String,
         /// Fee rate to use in sat/vB
@@ -846,11 +846,10 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
             .await?
         }
         Commands::SetRawFallback {
-            mut space,
+            space_or_sptr,
             data,
             fee_rate,
         } => {
-            space = normalize_space(&space);
             let data = match hex::decode(data) {
                 Ok(data) => data,
                 Err(e) => {
@@ -861,19 +860,35 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
                 }
             };
 
-            let space_script =
-                spaces_protocol::script::SpaceScript::create_set_fallback(data.as_slice());
+            // Check if it's an SPTR (starts with "sptr1")
+            if space_or_sptr.starts_with("sptr1") {
+                let sptr = Sptr::from_str(&space_or_sptr).map_err(|e| {
+                    ClientError::Custom(format!("Invalid SPTR: {}", e))
+                })?;
+                cli.send_request(
+                    Some(RpcWalletRequest::SetPtrData(SetPtrDataParams { sptr, data })),
+                    None,
+                    fee_rate,
+                    false,
+                )
+                .await?;
+            } else {
+                // Space fallback: use existing space script
+                let space = normalize_space(&space_or_sptr);
+                let space_script =
+                    spaces_protocol::script::SpaceScript::create_set_fallback(data.as_slice());
 
-            cli.send_request(
-                Some(RpcWalletRequest::Execute(ExecuteParams {
-                    context: vec![space],
-                    space_script,
-                })),
-                None,
-                fee_rate,
-                false,
-            )
-            .await?;
+                cli.send_request(
+                    Some(RpcWalletRequest::Execute(ExecuteParams {
+                        context: vec![space],
+                        space_script,
+                    })),
+                    None,
+                    fee_rate,
+                    false,
+                )
+                .await?;
+            }
         }
         Commands::ListUnspent => {
             let utxos = cli.client.wallet_list_unspent(&cli.wallet).await?;
diff --git a/client/src/rpc.rs b/client/src/rpc.rs
@@ -489,6 +489,8 @@ pub enum RpcWalletRequest {
     Delegate(DelegateParams),
     #[serde(rename = "commit")]
     Commit(CommitParams),
+    #[serde(rename = "setptrdata")]
+    SetPtrData(SetPtrDataParams),
     #[serde(rename = "send")]
     SendCoins(SendCoinsParams),
 }
@@ -523,6 +525,11 @@ pub struct CommitParams {
     pub root: Option<sha256::Hash>,
 }
 
+#[derive(Clone, Serialize, Deserialize)]
+pub struct SetPtrDataParams {
+    pub sptr: Sptr,
+    pub data: Vec<u8>,
+}
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct SendCoinsParams {
diff --git a/client/src/wallets.rs b/client/src/wallets.rs
@@ -1367,6 +1367,31 @@ impl RpcWallet {
                         create_ptr: true,
                     });
                 }
+                RpcWalletRequest::SetPtrData(params) => {
+                    // Find the PTR UTXO
+                    let ptr_info = match chain.get_ptr_info(&params.sptr)? {
+                        None => return Err(anyhow!("setptrdata: PTR '{}' not found", params.sptr)),
+                        Some(ptr) if !wallet.is_mine(ptr.ptrout.script_pubkey.clone()) => {
+                            return Err(anyhow!("setptrdata: you don't own '{}'", params.sptr))
+                        }
+                        Some(ptr) if wallet.get_utxo(OutPoint::new(ptr.txid, ptr.ptrout.n as u32)).is_none() => {
+                            return Err(anyhow!(
+                                "setptrdata '{}': wallet already has a pending tx for this PTR",
+                                params.sptr
+                            ))
+                        }
+                        Some(ptr) => ptr,
+                    };
+
+                    // Transfer PTR to self with data
+                    let recipient = wallet.reveal_next_space_address();
+                    builder = builder
+                        .add_ptr_transfer(PtrTransfer {
+                            ptr: ptr_info,
+                            recipient,
+                        })
+                        .add_ptr_data(params.data);
+                }
             }
         }
 
diff --git a/client/tests/ptr_tests.rs b/client/tests/ptr_tests.rs
@@ -7,7 +7,7 @@ use spaces_client::{
     },
     wallets::{AddressKind, WalletResponse},
 };
-use spaces_client::rpc::{CommitParams, CreatePtrParams, DelegateParams, TransferPtrParams, TransferSpacesParams};
+use spaces_client::rpc::{CommitParams, CreatePtrParams, DelegateParams, SetPtrDataParams, TransferPtrParams, TransferSpacesParams};
 use spaces_client::store::Sha256;
 use spaces_protocol::{bitcoin, bitcoin::{FeeRate}};
 use spaces_protocol::bitcoin::hashes::{sha256, Hash};
@@ -184,7 +184,7 @@ async fn it_should_commit_and_rollback(rig: &TestRig) -> anyhow::Result<()> {
     mine_and_sync(rig, 1).await?;
 
     // Verify delegation is set up
-    let sptr = rig.spaced.client.get_delegation(space_name.clone()).await?
+    rig.spaced.client.get_delegation(space_name.clone()).await?
         .expect("delegation should be established");
 
     // Test 1: Make initial commitment [1u8;32]
@@ -633,6 +633,122 @@ async fn it_should_reject_duplicate_sptr_delegations(rig: &TestRig) -> anyhow::R
     Ok(())
 }
 
+// ============== Test: PTR Data ==============
+
+async fn it_should_set_and_persist_ptr_data(rig: &TestRig) -> anyhow::Result<()> {
+    sync_all(rig).await?;
+
+    // Test 1: Create a PTR
+    println!("Test 1: Create PTR");
+    let addr0 = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Coin).await?;
+    let addr0_spk = bitcoin::address::Address::from_str(&addr0)?
+        .assume_checked()
+        .script_pubkey();
+    let addr0_spk_string = hex::encode(addr0_spk.as_bytes());
+
+    wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::CreatePtr(CreatePtrParams {
+            spk: addr0_spk_string,
+        })],
+        false,
+    ).await?;
+    mine_and_sync(rig, 1).await?;
+
+    let sptr = Sptr::from_spk::<Sha256>(addr0_spk.clone());
+    println!("SPTR created: {}", sptr);
+
+    // Verify PTR exists with no data
+    let ptr_initial = rig.spaced.client.get_ptr(sptr).await?
+        .expect("ptr should exist");
+    assert_eq!(ptr_initial.ptrout.sptr.as_ref().unwrap().data, None, "PTR should have no data initially");
+
+    // Test 2: Set data on the PTR
+    println!("\nTest 2: Set data on PTR");
+    let test_data = b"Hello, PTR data!".to_vec();
+    let set_data = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::SetPtrData(SetPtrDataParams {
+            sptr,
+            data: test_data.clone(),
+        })],
+        false,
+    ).await?;
+    assert!(wallet_res_err(&set_data).is_ok(), "SetPtrData should succeed");
+    mine_and_sync(rig, 1).await?;
+
+    // Verify data was set
+    let ptr_with_data = rig.spaced.client.get_ptr(sptr).await?
+        .expect("ptr should exist");
+    assert_eq!(ptr_with_data.ptrout.sptr.as_ref().unwrap().data, Some(test_data.clone()), "PTR data should be set");
+    println!("✓ PTR data set successfully: {:?}", String::from_utf8_lossy(&test_data));
+
+    // Test 3: Transfer PTR without data - data should persist
+    println!("\nTest 3: Transfer PTR without setting new data - data should persist");
+    let bob_addr = rig.spaced.client.wallet_get_new_address(BOB, AddressKind::Space).await?;
+    let transfer = wallet_do(
+        rig,
+        ALICE,
+        vec![RpcWalletRequest::TransferPtr(TransferPtrParams {
+            ptrs: vec![sptr],
+            to: bob_addr.clone(),
+        })],
+        false,
+    ).await?;
+    assert!(wallet_res_err(&transfer).is_ok(), "TransferPtr should succeed");
+    mine_and_sync(rig, 1).await?;
+
+    let ptr_after_transfer = rig.spaced.client.get_ptr(sptr).await?
+        .expect("ptr should exist after transfer");
+    assert_eq!(ptr_after_transfer.ptrout.sptr.as_ref().unwrap().data, Some(test_data.clone()),
+        "PTR data should persist after transfer without new data");
+    println!("✓ PTR data persisted after transfer");
+
+    // Test 4: Update data with new value
+    println!("\nTest 4: Update PTR data with new value");
+    let new_data = b"Updated data!".to_vec();
+    let update_data = wallet_do(
+        rig,
+        BOB,
+        vec![RpcWalletRequest::SetPtrData(SetPtrDataParams {
+            sptr,
+            data: new_data.clone(),
+        })],
+        false,
+    ).await?;
+    assert!(wallet_res_err(&update_data).is_ok(), "SetPtrData should succeed");
+    mine_and_sync(rig, 1).await?;
+
+    let ptr_updated = rig.spaced.client.get_ptr(sptr).await?
+        .expect("ptr should exist");
+    assert_eq!(ptr_updated.ptrout.sptr.as_ref().unwrap().data, Some(new_data.clone()), "PTR data should be updated");
+    println!("✓ PTR data updated successfully: {:?}", String::from_utf8_lossy(&new_data));
+
+    // Test 5: Set empty data
+    println!("\nTest 5: Set empty data");
+    let empty_data = Vec::new();
+    let set_empty = wallet_do(
+        rig,
+        BOB,
+        vec![RpcWalletRequest::SetPtrData(SetPtrDataParams {
+            sptr,
+            data: empty_data.clone(),
+        })],
+        false,
+    ).await?;
+    assert!(wallet_res_err(&set_empty).is_ok(), "SetPtrData with empty data should succeed");
+    mine_and_sync(rig, 1).await?;
+
+    let ptr_empty = rig.spaced.client.get_ptr(sptr).await?
+        .expect("ptr should exist");
+    assert_eq!(ptr_empty.ptrout.sptr.as_ref().unwrap().data, Some(empty_data), "PTR data should be set to empty");
+    println!("✓ PTR data set to empty successfully");
+
+    Ok(())
+}
+
 // ============== Main Test Runner ==============
 
 #[tokio::test]
@@ -666,6 +782,9 @@ async fn run_ptr_tests() -> anyhow::Result<()> {
     println!("\n=== Running PTR n→n Transfer Rule Tests ===");
     it_should_transfer_ptr_with_n_to_n_rule(&rig).await?;
 
+    println!("\n=== Running PTR Data Tests ===");
+    it_should_set_and_persist_ptr_data(&rig).await?;
+
     println!("\n=== All tests passed! ===");
     Ok(())
 }
diff --git a/ptr/src/lib.rs b/ptr/src/lib.rs
@@ -679,12 +679,8 @@ pub fn parse_ptr_op(tx: &Transaction) -> Option<PtrOp> {
                     Some(PtrOp::Commitment(CommitmentOp::Commit(commitments)))
                 }
                 x if x == PtrOpType::Data as u8 => {
-                    // Data: marker + payload
+                    // Data: marker + payload (payload can be empty)
                     let payload = &bytes[1..];
-                    if payload.is_empty() {
-                        return None;
-                    }
-
                     Some(PtrOp::Data(payload.as_bytes().to_vec()))
                 }
                 _ => None,
diff --git a/wallet/src/builder.rs b/wallet/src/builder.rs
@@ -27,7 +27,7 @@ use spaces_protocol::{
     Covenant, FullSpaceOut, Space,
 };
 use spaces_protocol::hasher::Hash;
-use spaces_ptr::{create_commitment_script, CommitmentOp, FullPtrOut};
+use spaces_ptr::{create_commitment_script, create_data_script, CommitmentOp, FullPtrOut};
 use crate::{
     address::SpaceAddress, tx_event::TxRecord, DoubleUtxo, FullTxOut, SpaceScriptSigningInfo,
     SpacesWallet,
@@ -50,6 +50,9 @@ pub struct Builder {
     /// e.g. opens for name that already exist ... etc.
     /// enable only for testing purposes!
     force: bool,
+
+    /// Optional data to attach to PTR transfers via OP_RETURN
+    ptr_data: Option<Vec<u8>>,
 }
 
 pub struct BuilderIterator<'a> {
@@ -168,6 +171,7 @@ pub struct PtrParams {
     transfers: Vec<PtrTransfer>,
     binds: Vec<PtrRequest>,
     commitments: Vec<CommitmentRequest>,
+    data: Option<Vec<u8>>,
 }
 
 #[derive(Clone, Debug)]
@@ -717,6 +721,7 @@ impl Builder {
             fee_rate: None,
             bidouts: None,
             force: false,
+            ptr_data: None,
         }
     }
 
@@ -771,6 +776,11 @@ impl Builder {
         self
     }
 
+    pub fn add_ptr_data(mut self, data: Vec<u8>) -> Self {
+        self.ptr_data = Some(data);
+        self
+    }
+
     pub fn add_ptr(mut self, request: PtrRequest) -> Self {
         self.requests.push(StackRequest::Ptr(request));
         self
@@ -913,6 +923,7 @@ impl Builder {
                 transfers: ptr_transfers,
                 binds: ptrs,
                 commitments,
+                data: self.ptr_data.clone(),
             };
             stack.push(StackOp::Ptr(params))
         }
@@ -981,6 +992,8 @@ impl Builder {
             return Ok(signed);
         }
 
+        let has_transfers = !params.transfers.is_empty();
+
         // Handle transfers:
         for transfer in params.transfers {
             let outpoint = OutPoint {
@@ -1003,6 +1016,14 @@ impl Builder {
             );
         }
 
+        // Add data OP_RETURN if present (only makes sense with transfers)
+        if let Some(data) = params.data {
+            if has_transfers {
+                let script = create_data_script(&data);
+                builder.add_recipient(script, Amount::from_sat(0));
+            }
+        }
+
         let psbt = builder.finish()?;
         let signed = w.sign(psbt, None)?;
         Ok(signed)

Original file line number	Diff line number	Diff line change
`@@ -679,12 +679,8 @@ pub fn parse_ptr_op(tx: &Transaction) -> Option<PtrOp> {`
`679`	`679`	`Some(PtrOp::Commitment(CommitmentOp::Commit(commitments)))`
`680`	`680`	`}`
`681`	`681`	`x if x == PtrOpType::Data as u8 => {`
`682`		`- // Data: marker + payload`
	`682`	`+ // Data: marker + payload (payload can be empty)`
`683`	`683`	`let payload = &bytes[1..];`
`684`		`- if payload.is_empty() {`
`685`		`- return None;`
`686`		`- }`
`687`		`-`
`688`	`684`	`Some(PtrOp::Data(payload.as_bytes().to_vec()))`
`689`	`685`	`}`
`690`	`686`	`_ => None,`