Protocol and wallet safety updates

- Make selection of dust outputs for auctions safer
- Remove unused script errors
- Add option to store raw tx in block index
- Add Bytes type that can be serialized as hex
- Use sensible names for space op codes
- Add forcespend command for testing
- Cargo fmt

Author: buffrr

node/src/bin/space-cli.rs

@@ -231,6 +231,13 @@ enum Commands {
         /// The space name
         space: String,
     },
+    /// Force spend an output owned by wallet (for testing only)
+    #[command(name = "forcespend")]
+    ForceSpend {
+        outpoint: OutPoint,
+        #[arg(long, short)]
+        fee_rate: u64,
+    },
 }
 
 struct SpaceCli {
@@ -553,7 +560,7 @@ async fn handle_commands(
                 }
             };
 
-            let space_script = protocol::script::SpaceScript::create_set(data.as_slice());
+            let space_script = protocol::script::SpaceScript::create_set_fallback(data.as_slice());
 
             cli.send_request(
                 Some(RpcWalletRequest::Execute(ExecuteParams {
@@ -609,6 +616,17 @@ async fn handle_commands(
                 space_hash(&space).map_err(|e| ClientError::Custom(e.to_string()))?
             );
         }
+        Commands::ForceSpend { outpoint, fee_rate } => {
+            let result = cli
+                .client
+                .wallet_force_spend(
+                    &cli.wallet,
+                    outpoint,
+                    FeeRate::from_sat_per_vb(fee_rate).unwrap(),
+                )
+                .await?;
+            println!("{}", serde_json::to_string_pretty(&result).expect("result"));
+        }
     }
 
     Ok(())

node/src/config.rs

@@ -73,6 +73,9 @@ pub struct Args {
     /// Listen for JSON-RPC connections on <port>
     #[arg(long, help_heading = Some(RPC_OPTIONS), env = "SPACED_RPC_PORT")]
     rpc_port: Option<u16>,
+    /// Index blocks including the full transaction data
+    #[arg(long, env = "SPACED_BLOCK_INDEX_FULL", default_value = "false")]
+    block_index_full: bool,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, ValueEnum, Serialize, Deserialize)]
@@ -173,7 +176,8 @@ impl Args {
             store: chain_store,
         };
 
-        let block_index = if args.block_index {
+        let block_index_enabled = args.block_index || args.block_index_full;
+        let block_index = if block_index_enabled {
             let block_db_path = data_dir.join("block_index.sdb");
             if !initial_sync && !block_db_path.exists() {
                 return Err(anyhow::anyhow!(
@@ -206,6 +210,7 @@ impl Args {
             bind: rpc_bind_addresses,
             chain,
             block_index,
+            block_index_full: args.block_index_full,
             num_workers: args.jobs as usize,
         })
     }
@@ -262,7 +267,7 @@ pub fn safe_exit(code: i32) -> ! {
     std::process::exit(code)
 }
 
-fn default_bitcoin_rpc_url(network: &ExtendedNetwork) -> &'static str {
+pub fn default_bitcoin_rpc_url(network: &ExtendedNetwork) -> &'static str {
     match network {
         ExtendedNetwork::Mainnet | ExtendedNetwork::MainnetAlpha => "http://127.0.0.1:8332",
         ExtendedNetwork::Testnet4 => "http://127.0.0.1:48332",

node/src/node.rs

@@ -11,7 +11,7 @@ use protocol::{
     hasher::{BidKey, KeyHasher, OutpointKey, SpaceKey},
     prepare::TxContext,
     validate::{TxChangeSet, UpdateKind, Validator},
-    Covenant, FullSpaceOut, RevokeReason, SpaceOut,
+    Bytes, Covenant, FullSpaceOut, RevokeReason, SpaceOut,
 };
 use serde::{Deserialize, Serialize};
 use wallet::bitcoin::Transaction;
@@ -32,13 +32,29 @@ pub trait BlockSource {
 #[derive(Debug, Clone)]
 pub struct Node {
     validator: Validator,
+    tx_data: bool,
 }
 
 /// A block structure containing validated transaction metadata
 /// relevant to the Spaces protocol
 #[derive(Clone, Serialize, Deserialize, Encode, Decode)]
 pub struct BlockMeta {
-    pub tx_meta: Vec<TxChangeSet>,
+    pub height: u32,
+    pub tx_meta: Vec<TxEntry>,
+}
+
+#[derive(Clone, Serialize, Deserialize, Encode, Decode)]
+pub struct TxEntry {
+    #[serde(flatten)]
+    pub changeset: TxChangeSet,
+    #[serde(skip_serializing_if = "Option::is_none", flatten)]
+    pub tx: Option<TxData>,
+}
+
+#[derive(Clone, Serialize, Deserialize, Encode, Decode)]
+pub struct TxData {
+    pub position: u32,
+    pub raw: Bytes,
 }
 
 #[derive(Debug)]
@@ -60,9 +76,10 @@ impl fmt::Display for SyncError {
 impl Error for SyncError {}
 
 impl Node {
-    pub fn new() -> Self {
+    pub fn new(tx_data: bool) -> Self {
         Self {
             validator: Validator::new(),
+            tx_data,
         }
     }
 
@@ -85,7 +102,10 @@ impl Node {
             }
         }
 
-        let mut block_data = BlockMeta { tx_meta: vec![] };
+        let mut block_data = BlockMeta {
+            height,
+            tx_meta: vec![],
+        };
 
         if (height - 1) % ROLLOUT_BLOCK_INTERVAL == 0 {
             let batch = Self::get_rollout_batch(ROLLOUT_BATCH_SIZE, chain)?;
@@ -96,21 +116,44 @@ impl Node {
 
             let validated = self.validator.rollout(height, &coinbase, batch);
             if get_block_data {
-                block_data.tx_meta.push(validated.clone());
+                block_data.tx_meta.push(TxEntry {
+                    changeset: validated.clone(),
+                    tx: if self.tx_data {
+                        Some(TxData {
+                            position: 0,
+                            raw: Bytes::new(protocol::bitcoin::consensus::encode::serialize(
+                                &coinbase,
+                            )),
+                        })
+                    } else {
+                        None
+                    },
+                });
             }
-
             self.apply_tx(&mut chain.state, &coinbase, validated);
         }
 
-        for tx in block.txdata {
+        for (position, tx) in block.txdata.into_iter().enumerate() {
             let prepared_tx =
                 { TxContext::from_tx::<LiveSnapshot, Sha256>(&mut chain.state, &tx)? };
 
             if let Some(prepared_tx) = prepared_tx {
                 let validated_tx = self.validator.process(height, &tx, prepared_tx);
 
                 if get_block_data {
-                    block_data.tx_meta.push(validated_tx.clone());
+                    block_data.tx_meta.push(TxEntry {
+                        changeset: validated_tx.clone(),
+                        tx: if self.tx_data {
+                            Some(TxData {
+                                position: position as u32,
+                                raw: Bytes::new(protocol::bitcoin::consensus::encode::serialize(
+                                    &tx,
+                                )),
+                            })
+                        } else {
+                            None
+                        },
+                    });
                 }
                 self.apply_tx(&mut chain.state, &tx, validated_tx);
             }

node/src/rpc.rs

@@ -24,7 +24,6 @@ use protocol::{
     constants::ChainAnchor,
     hasher::{BaseHash, SpaceKey},
     prepare::DataSource,
-    validate::TxChangeSet,
     FullSpaceOut, SpaceOut,
 };
 use serde::{Deserialize, Serialize};
@@ -40,7 +39,7 @@ use wallet::{
 
 use crate::{
     config::ExtendedNetwork,
-    node::BlockMeta,
+    node::{BlockMeta, TxEntry},
     source::BitcoinRpc,
     store::{ChainState, LiveSnapshot},
     wallets::{
@@ -75,7 +74,7 @@ pub enum ChainStateCommand {
     },
     GetTxMeta {
         txid: Txid,
-        resp: Responder<anyhow::Result<Option<TxChangeSet>>>,
+        resp: Responder<anyhow::Result<Option<TxEntry>>>,
     },
     GetBlockMeta {
         block_hash: BlockHash,
@@ -124,7 +123,7 @@ pub trait Rpc {
     ) -> Result<Option<BlockMeta>, ErrorObjectOwned>;
 
     #[method(name = "gettxmeta")]
-    async fn get_tx_meta(&self, txid: Txid) -> Result<Option<TxChangeSet>, ErrorObjectOwned>;
+    async fn get_tx_meta(&self, txid: Txid) -> Result<Option<TxEntry>, ErrorObjectOwned>;
 
     #[method(name = "walletload")]
     async fn wallet_load(&self, name: &str) -> Result<(), ErrorObjectOwned>;
@@ -163,6 +162,14 @@ pub trait Rpc {
         fee_rate: FeeRate,
     ) -> Result<Vec<TxResponse>, ErrorObjectOwned>;
 
+    #[method(name = "walletforcespend")]
+    async fn wallet_force_spend(
+        &self,
+        wallet: &str,
+        outpoint: OutPoint,
+        fee_rate: FeeRate,
+    ) -> Result<TxResponse, ErrorObjectOwned>;
+
     #[method(name = "walletlistspaces")]
     async fn wallet_list_spaces(&self, wallet: &str)
         -> Result<Vec<WalletOutput>, ErrorObjectOwned>;
@@ -624,7 +631,7 @@ impl RpcServer for RpcServerImpl {
         Ok(data)
     }
 
-    async fn get_tx_meta(&self, txid: Txid) -> Result<Option<TxChangeSet>, ErrorObjectOwned> {
+    async fn get_tx_meta(&self, txid: Txid) -> Result<Option<TxEntry>, ErrorObjectOwned> {
         let data = self
             .store
             .get_tx_meta(txid)
@@ -715,6 +722,19 @@ impl RpcServer for RpcServerImpl {
             .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))
     }
 
+    async fn wallet_force_spend(
+        &self,
+        wallet: &str,
+        outpoint: OutPoint,
+        fee_rate: FeeRate,
+    ) -> Result<TxResponse, ErrorObjectOwned> {
+        self.wallet(&wallet)
+            .await?
+            .send_force_spend(outpoint, fee_rate)
+            .await
+            .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::<String>))
+    }
+
     async fn wallet_list_spaces(
         &self,
         wallet: &str,
@@ -768,7 +788,7 @@ impl AsyncChainState {
         client: &reqwest::Client,
         rpc: &BitcoinRpc,
         chain_state: &mut LiveSnapshot,
-    ) -> Result<Option<TxChangeSet>, anyhow::Error> {
+    ) -> Result<Option<TxEntry>, anyhow::Error> {
         let info: serde_json::Value = rpc
             .send_json(client, &rpc.get_raw_transaction(&txid, true))
             .await
@@ -781,7 +801,10 @@ impl AsyncChainState {
         let block = Self::get_indexed_block(index, &block_hash, client, rpc, chain_state).await?;
 
         if let Some(block) = block {
-            return Ok(block.tx_meta.into_iter().find(|tx| &tx.txid == txid));
+            return Ok(block
+                .tx_meta
+                .into_iter()
+                .find(|tx| &tx.changeset.txid == txid));
         }
         Ok(None)
     }
@@ -951,7 +974,7 @@ impl AsyncChainState {
         resp_rx.await?
     }
 
-    pub async fn get_tx_meta(&self, txid: Txid) -> anyhow::Result<Option<TxChangeSet>> {
+    pub async fn get_tx_meta(&self, txid: Txid) -> anyhow::Result<Option<TxEntry>> {
         let (resp, resp_rx) = oneshot::channel();
         self.sender
             .send(ChainStateCommand::GetTxMeta { txid, resp })

node/src/sync.rs

@@ -33,6 +33,7 @@ pub struct Spaced {
     pub network: ExtendedNetwork,
     pub chain: LiveStore,
     pub block_index: Option<LiveStore>,
+    pub block_index_full: bool,
     pub rpc: BitcoinRpc,
     pub data_dir: PathBuf,
     pub bind: Vec<SocketAddr>,
@@ -147,7 +148,7 @@ impl Spaced {
         shutdown: broadcast::Sender<()>,
     ) -> anyhow::Result<()> {
         let start_block: ChainAnchor = { self.chain.state.tip.read().expect("read").clone() };
-        let mut node = Node::new();
+        let mut node = Node::new(self.block_index_full);
 
         info!(
             "Start block={} height={}",