Use spk directly for create ptrs and other fixes

Author: buffrr

client/src/bin/space-cli.rs

@@ -38,10 +38,9 @@ use spaces_client::{
 use spaces_client::rpc::{CommitParams, CreatePtrParams, TransferPtrParams};
 use spaces_client::store::Sha256;
 use spaces_protocol::bitcoin::{Amount, FeeRate, OutPoint, Txid};
-use spaces_protocol::bitcoin::params::Params;
 use spaces_protocol::slabel::SLabel;
 use spaces_ptr::sptr::Sptr;
-use spaces_wallet::{bitcoin, bitcoin::secp256k1::schnorr::Signature, export::WalletExport, nostr::{NostrEvent, NostrTag}, Listing};
+use spaces_wallet::{bitcoin::secp256k1::schnorr::Signature, export::WalletExport, nostr::{NostrEvent, NostrTag}, Listing};
 use spaces_wallet::address::SpaceAddress;
 use spaces_wallet::bitcoin::hashes::sha256;
 use spaces_wallet::bitcoin::ScriptBuf;
@@ -1062,15 +1061,11 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
             let spk = ScriptBuf::from(hex::decode(spk)
                 .map_err(|_| ClientError::Custom("Invalid spk hex".to_string()))?);
 
-            let addr = bitcoin::address::Address::from_script(spk.as_script(),
-                                                              Params::new(cli.network.fallback_network()))
-                .map_err(|_| ClientError::Custom("Invalid spk".to_string()))?;
-
-            let sptr = Sptr::from_spk::<Sha256>(spk);
+            let sptr = Sptr::from_spk::<Sha256>(spk.clone());
             println!("Creating sptr: {}", sptr);
             cli.send_request(
                 Some(RpcWalletRequest::CreatePtr(CreatePtrParams {
-                    address: addr.to_string(),
+                    spk: hex::encode(spk.as_bytes()),
                 })),
                 None,
                 fee_rate,
@@ -1129,26 +1124,27 @@ async fn handle_commands(cli: &SpaceCli, command: Commands) -> Result<(), Client
                 return Err(ClientError::Custom("space is already operational".to_string()));
             }
 
-            let sptr_addr = cli.client.wallet_get_new_address(&cli.wallet, AddressKind::Space).await?;
-            let sptr = Sptr::from_spk::<Sha256>(SpaceAddress::from_str(&sptr_addr)
-                .expect("valid").script_pubkey());
+            let address = cli.client.wallet_get_new_address(&cli.wallet, AddressKind::Space).await?;
+            let address = SpaceAddress::from_str(&address)
+                .expect("valid");
+            let spk = address.script_pubkey();
+            let sptr = Sptr::from_spk::<Sha256>(spk.clone());
 
             println!("Assigning space to sptr {}", sptr);
             cli.send_request(
                 Some(RpcWalletRequest::Transfer(TransferSpacesParams {
                     spaces: vec![space],
-                    to: Some(sptr_addr.clone()),
+                    to: Some(address.to_string()),
                 })),
                 None,
                 fee_rate,
                 false,
             )
                 .await?;
-            let addr = SpaceAddress::from_str(&sptr_addr).expect("valid");
             println!("Creating UTXO for sptr {}", sptr);
             cli.send_request(
                 Some(RpcWalletRequest::CreatePtr(CreatePtrParams {
-                    address: addr.0.to_string(),
+                    spk: hex::encode(spk.as_bytes()),
                 })),
                 None,
                 fee_rate,

client/src/client.rs

@@ -286,6 +286,7 @@ impl Client {
                             },
                         });
                     }
+
                     self.apply_ptrs_tx(chain, tx, ptrs_validated);
                 }
             }

client/src/rpc.rs

@@ -448,7 +448,7 @@ pub struct TransferPtrParams {
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct CreatePtrParams {
-    pub address: String,
+    pub spk: String,
 }
 
 #[derive(Clone, Serialize, Deserialize)]

client/src/spaces.rs

@@ -176,7 +176,7 @@ impl Spaced {
     pub fn ptr_genesis(network: ExtendedNetwork) -> ChainAnchor {
         match network {
             ExtendedNetwork::Testnet4 => ChainAnchor::PTR_TESTNET4(),
-            ExtendedNetwork::Regtest => ChainAnchor::PTR_TESTNET4(),
+            ExtendedNetwork::Regtest => ChainAnchor::PTR_REGTEST(),
             _ => panic!("unsupported network"),
         }
     }

client/src/wallets.rs

@@ -36,7 +36,7 @@ use tokio::{
     time::Instant,
 };
 use spaces_protocol::bitcoin::address::ParseError;
-use spaces_protocol::bitcoin::Network;
+use spaces_protocol::bitcoin::{Network, ScriptBuf};
 use spaces_ptr::sptr::{Sptr, SptrParseError, SPTR_HRP};
 use spaces_wallet::builder::{CommitmentRequest, PtrRequest, PtrTransfer};
 use crate::{calc_progress, checker::TxChecker, client::BlockSource, config::ExtendedNetwork, rpc::{RpcWalletRequest, RpcWalletTxBuilder, WalletLoadRequest}, source::{
@@ -1275,10 +1275,12 @@ impl RpcWallet {
                     }
                 }
                 RpcWalletRequest::CreatePtr(params) => {
-                    let addr = Address::from_str(&params.address)
-                        .map_err(|e| anyhow!("transferptr: invalid address for ptr {}: {:?}", params.address, e))?;
+                    let spk_raw = hex::decode(params.spk)
+                        .map_err(|e| anyhow!("transferptr: invalid spk: {:?}", e))?;
+
+                    let spk = ScriptBuf::from(spk_raw);
                     builder = builder.add_ptr(PtrRequest {
-                        ptr: addr,
+                        spk,
                     })
                 }
                 RpcWalletRequest::Commit(params) => {

client/tests/ptr_tests.rs

@@ -16,24 +16,25 @@ use spaces_ptr::transcript_hash;
 use spaces_testutil::TestRig;
 use spaces_wallet::{export::WalletExport};
 use spaces_wallet::address::SpaceAddress;
-use spaces_wallet::bitcoin::{Network, ScriptBuf};
 
 const ALICE: &str = "wallet_99";
 const BOB: &str = "wallet_98";
 const EVE: &str = "wallet_93";
 
 async fn it_should_create_sptrs(rig: &TestRig) -> anyhow::Result<()> {
-
-    println!("sptr example: {}", Sptr::from_spk::<Sha256>(ScriptBuf::from(hex::decode("5120d3c3196cb3ed7fa79c882ed62f8e5942e546130d5ae5983da67dbb6c9bdd2e79").expect("valid"))));
-
     rig.wait_until_wallet_synced(ALICE).await?;
 
     // 1) Create ptr bound to addr0 (spk0)
     let addr0 = rig.spaced.client.wallet_get_new_address(ALICE, AddressKind::Coin).await?;
+    let addr0_spk = bitcoin::address::Address::from_str(&addr0)
+        .expect("valid").assume_checked()
+        .script_pubkey();
+    let addr0_spk_string = hex::encode(addr0_spk.as_bytes());
+
     let create0 = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::CreatePtr(CreatePtrParams { address: addr0.clone() })],
+        vec![RpcWalletRequest::CreatePtr(CreatePtrParams { spk: addr0_spk_string.clone() })],
         false,
     ).await.expect("CreatePtr addr0");
     assert!(wallet_res_err(&create0).is_ok(), "CreatePtr(addr0) must not error");
@@ -86,7 +87,7 @@ async fn it_should_create_sptrs(rig: &TestRig) -> anyhow::Result<()> {
     let dup = wallet_do(
         rig,
         ALICE,
-        vec![RpcWalletRequest::CreatePtr(CreatePtrParams { address: addr0.clone() })],
+        vec![RpcWalletRequest::CreatePtr(CreatePtrParams { spk: addr0_spk_string })],
         false,
     ).await.expect("duplicate CreatePtr(addr0)");
     assert!(wallet_res_err(&dup).is_ok(), "duplicate CreatePtr should not error");
@@ -171,15 +172,11 @@ async fn it_should_operate_space(rig: &TestRig) -> anyhow::Result<()> {
     assert_eq!(current_spk, spk_after, "space spk must remain the same after renewal");
 
     // --- Create/bind an SPTR using the SAME scriptPubKey as the space ---
-    let space_addr = bitcoin::address::Address::from_script(&current_spk, Network::Regtest)
-        .expect("derive address from space spk")
-        .to_string();
-
     let create_ptr_res = wallet_do(
         rig,
         ALICE,
         vec![RpcWalletRequest::CreatePtr(CreatePtrParams {
-            address: space_addr.clone(),
+            spk: hex::encode(current_spk.as_bytes()),
         })],
         false,
     )

wallet/src/builder.rs

@@ -21,7 +21,6 @@ use bitcoin::{
     Amount, FeeRate, Network, OutPoint, Psbt, Script, ScriptBuf, Sequence, Transaction, TxOut,
     Txid, Weight, Witness,
 };
-use bitcoin::address::NetworkUnchecked;
 use spaces_protocol::{
     bitcoin::absolute::Height,
     constants::{BID_PSBT_INPUT_SEQUENCE, BID_PSBT_TX_VERSION},
@@ -124,7 +123,7 @@ pub struct RegisterRequest {
 
 #[derive(Debug, Clone)]
 pub struct PtrRequest {
-    pub ptr: Address<NetworkUnchecked>,
+    pub spk: ScriptBuf,
 }
 
 #[derive(Debug, Clone)]
@@ -978,7 +977,7 @@ impl Builder {
         // Add any binds last to not mess with input/output order for transfers
         for ptr in params.binds {
             builder.add_recipient(
-                ptr.ptr.assume_checked().script_pubkey(),
+                ptr.spk,
                 ptr_utxo_dust(Amount::from_sat(1000)),
             );
         }