Refactor block index and internal structures. See #18

Author: buffrr

node/src/bin/space-cli.rs

@@ -10,7 +10,7 @@ use jsonrpsee::{
 };
 use protocol::{
     bitcoin::{Amount, FeeRate, OutPoint, Txid},
-    hasher::{KeyHasher, SpaceHash},
+    hasher::{KeyHasher, SpaceKey},
     opcodes::OP_SETALL,
     sname::{NameLike, SName},
     Covenant, FullSpaceOut,
@@ -372,7 +372,7 @@ async fn main() -> anyhow::Result<()> {
 fn space_hash(spaceish: &str) -> anyhow::Result<String> {
     let space = normalize_space(&spaceish);
     let sname = SName::from_str(&space)?;
-    let spacehash = SpaceHash::from(Sha256::hash(sname.to_bytes()));
+    let spacehash = SpaceKey::from(Sha256::hash(sname.to_bytes()));
     Ok(hex::encode(spacehash.as_slice()))
 }
 
@@ -394,7 +394,13 @@ async fn handle_commands(
 
                 if let Some(outpoint) = outpoint {
                     if let Some(spaceout) = cli.client.get_spaceout(outpoint).await? {
-                        spaceouts.push((priority, FullSpaceOut { outpoint, spaceout }));
+                        spaceouts.push((
+                            priority,
+                            FullSpaceOut {
+                                txid: outpoint.txid,
+                                spaceout,
+                            },
+                        ));
                     }
                 }
             }

node/src/node.rs

@@ -8,13 +8,14 @@ use bincode::{Decode, Encode};
 use protocol::{
     bitcoin::{Amount, Block, BlockHash, OutPoint},
     constants::{ChainAnchor, ROLLOUT_BATCH_SIZE, ROLLOUT_BLOCK_INTERVAL},
-    hasher::{BidHash, KeyHasher, OutpointHash, SpaceHash},
-    prepare::PreparedTransaction,
+    hasher::{BidKey, KeyHasher, OutpointKey, SpaceKey},
+    prepare::TxContext,
     sname::NameLike,
-    validate::{ErrorOut, MetaOutKind, TxInKind, TxOutKind, ValidatedTransaction, Validator},
+    validate::{UpdateKind, TxChangeSet, Validator},
     Covenant, FullSpaceOut, RevokeReason, SpaceOut,
 };
 use serde::{Deserialize, Serialize};
+use wallet::bitcoin::Transaction;
 
 use crate::{
     source::BitcoinRpcError,
@@ -34,11 +35,11 @@ pub struct Node {
     validator: Validator,
 }
 
-/// A block structure containing validated transactions
+/// A block structure containing validated transaction metadata
 /// relevant to the Spaces protocol
 #[derive(Clone, Serialize, Deserialize, Encode, Decode)]
-pub struct ValidatedBlock {
-    tx_data: Vec<ValidatedTransaction>,
+pub struct BlockMeta {
+    tx_meta: Vec<TxChangeSet>,
 }
 
 #[derive(Debug)]
@@ -73,7 +74,7 @@ impl Node {
         block_hash: BlockHash,
         block: Block,
         get_block_data: bool,
-    ) -> Result<Option<ValidatedBlock>> {
+    ) -> Result<Option<BlockMeta>> {
         {
             let tip = chain.state.tip.read().expect("read tip");
             if tip.hash != block.header.prev_blockhash || tip.height + 1 != height {
@@ -85,7 +86,7 @@ impl Node {
             }
         }
 
-        let mut block_data = ValidatedBlock { tx_data: vec![] };
+        let mut block_data = BlockMeta { tx_meta: vec![] };
 
         if (height - 1) % ROLLOUT_BLOCK_INTERVAL == 0 {
             let batch = Self::get_rollout_batch(ROLLOUT_BATCH_SIZE, chain)?;
@@ -94,155 +95,135 @@ impl Node {
                 .expect("expected a coinbase tx to be present in the block")
                 .clone();
 
-            let validated = self.validator.rollout(height, coinbase, batch);
+            let validated = self.validator.rollout(height, &coinbase, batch);
             if get_block_data {
-                block_data.tx_data.push(validated.clone());
+                block_data.tx_meta.push(validated.clone());
             }
 
-            self.apply_tx(&mut chain.state, validated);
+            self.apply_tx(&mut chain.state, &coinbase, validated);
         }
 
         for tx in block.txdata {
             let prepared_tx =
-                { PreparedTransaction::from_tx::<LiveSnapshot, Sha256>(&mut chain.state, tx)? };
+                { TxContext::from_tx::<LiveSnapshot, Sha256>(&mut chain.state, &tx)? };
 
             if let Some(prepared_tx) = prepared_tx {
-                let validated_tx = self.validator.process(height, prepared_tx);
+                let validated_tx = self.validator.process(height, &tx, prepared_tx);
+
                 if get_block_data {
-                    block_data.tx_data.push(validated_tx.clone());
+                    block_data.tx_meta.push(validated_tx.clone());
                 }
-                self.apply_tx(&mut chain.state, validated_tx);
+                self.apply_tx(&mut chain.state, &tx, validated_tx);
             }
         }
         let mut tip = chain.state.tip.write().expect("write tip");
         tip.height = height;
         tip.hash = block_hash;
 
-        if get_block_data && !block_data.tx_data.is_empty() {
+        if get_block_data && !block_data.tx_meta.is_empty() {
             return Ok(Some(block_data));
         }
         Ok(None)
     }
 
-    fn apply_tx(&self, state: &mut LiveSnapshot, changeset: ValidatedTransaction) {
+    fn apply_tx(&self, state: &mut LiveSnapshot, tx: &Transaction, changeset: TxChangeSet) {
         // Remove spends
-        for input in changeset.input {
-            match input {
-                TxInKind::CoinIn(_) => {
-                    // not relevant to spaces
-                }
-                TxInKind::SpaceIn(spacein) => {
-                    // remove spend
-                    let spend = OutpointHash::from_outpoint::<Sha256>(spacein.txin.previous_output);
-                    state.remove(spend);
-                }
-            }
+        for spend in changeset.spends.into_iter() {
+            let previous = tx.input[spend.n].previous_output;
+            let spend = OutpointKey::from_outpoint::<Sha256>(previous);
+            state.remove(spend);
         }
 
         // Apply outputs
-        for (index, output) in changeset.output.into_iter().enumerate() {
-            match output {
-                TxOutKind::CoinOut(_) => {
-                    // not relevant to spaces
-                }
-                TxOutKind::SpaceOut(spaceout) => {
-                    if let Some(space) = spaceout.space.as_ref() {
-                        assert!(
-                            !matches!(space.covenant, Covenant::Bid { .. }),
-                            "bid unexpected"
-                        );
-                    }
-                    let outpoint = OutPoint {
-                        txid: changeset.txid,
-                        vout: index as u32,
-                    };
-
-                    // Space => Outpoint
-                    if let Some(space) = spaceout.space.as_ref() {
-                        let space_key = SpaceHash::from(Sha256::hash(space.name.to_bytes()));
-                        state.insert_space(space_key, outpoint.into());
-                    }
-                    // Outpoint => SpaceOut
-                    let outpoint_key = OutpointHash::from_outpoint::<Sha256>(outpoint);
-                    state.insert_spaceout(outpoint_key, spaceout);
-                }
+        for create in changeset.creates.into_iter() {
+            if let Some(space) = create.space.as_ref() {
+                assert!(
+                    !matches!(space.covenant, Covenant::Bid { .. }),
+                    "bid unexpected"
+                );
+            }
+            let outpoint = OutPoint {
+                txid: changeset.txid,
+                vout: create.n as u32,
+            };
+
+            // Space => Outpoint
+            if let Some(space) = create.space.as_ref() {
+                let space_key = SpaceKey::from(Sha256::hash(space.name.to_bytes()));
+                state.insert_space(space_key, outpoint.into());
             }
+            // Outpoint => SpaceOut
+            let outpoint_key = OutpointKey::from_outpoint::<Sha256>(outpoint);
+            state.insert_spaceout(outpoint_key, create);
         }
 
         // Apply meta outputs
-        for meta_output in changeset.meta_output {
-            match meta_output {
-                MetaOutKind::ErrorOut(errrout) => {
-                    match errrout {
-                        ErrorOut::Reject(_) => {
-                            // no state changes as it doesn't
-                            // modify any existing spaces
-                        }
-                        ErrorOut::Revoke(params) => {
-                            match params.reason {
-                                RevokeReason::BidPsbt(_)
-                                | RevokeReason::PrematureClaim
-                                | RevokeReason::BadSpend => {
-                                    // Since these are caused by spends
-                                    // Outpoint -> Spaceout mapping is already removed,
-                                    let space = params.spaceout.spaceout.space.unwrap();
-                                    let base_hash = Sha256::hash(space.name.to_bytes());
-
-                                    // Remove Space -> Outpoint
-                                    let space_key = SpaceHash::from(base_hash);
-                                    state.remove(space_key);
-
-                                    // Remove any bids from pre-auction pool
-                                    match space.covenant {
-                                        Covenant::Bid {
-                                            total_burned,
-                                            claim_height,
-                                            ..
-                                        } => {
-                                            if claim_height.is_none() {
-                                                let bid_key =
-                                                    BidHash::from_bid(total_burned, base_hash);
-                                                state.remove(bid_key);
-                                            }
-                                        }
-                                        _ => {}
+        for update in changeset.updates {
+            match update.kind {
+                UpdateKind::Revoke(params) => {
+                    match params {
+                        RevokeReason::BidPsbt(_)
+                        | RevokeReason::PrematureClaim
+                        | RevokeReason::BadSpend => {
+                            // Since these are caused by spends
+                            // Outpoint -> Spaceout mapping is already removed,
+                            let space = update.output.spaceout.space.unwrap();
+                            let base_hash = Sha256::hash(space.name.to_bytes());
+
+                            // Remove Space -> Outpoint
+                            let space_key = SpaceKey::from(base_hash);
+                            state.remove(space_key);
+
+                            // Remove any bids from pre-auction pool
+                            match space.covenant {
+                                Covenant::Bid {
+                                    total_burned,
+                                    claim_height,
+                                    ..
+                                } => {
+                                    if claim_height.is_none() {
+                                        let bid_key = BidKey::from_bid(total_burned, base_hash);
+                                        state.remove(bid_key);
                                     }
                                 }
-                                RevokeReason::Expired => {
-                                    // Space => Outpoint mapping will be removed
-                                    // since this type of revocation only happens when an
-                                    // expired space is being re-opened for auction.
-                                    // No bids here so only remove Outpoint -> Spaceout
-                                    let hash = OutpointHash::from_outpoint::<Sha256>(
-                                        params.spaceout.outpoint,
-                                    );
-                                    state.remove(hash);
-                                }
+                                _ => {}
                             }
                         }
+                        RevokeReason::Expired => {
+                            // Space => Outpoint mapping will be removed
+                            // since this type of revocation only happens when an
+                            // expired space is being re-opened for auction.
+                            // No bids here so only remove Outpoint -> Spaceout
+                            let hash =
+                                OutpointKey::from_outpoint::<Sha256>(update.output.outpoint());
+                            state.remove(hash);
+                        }
                     }
                 }
-                MetaOutKind::RolloutOut(rollout) => {
+                UpdateKind::Rollout(rollout) => {
                     let base_hash = Sha256::hash(
-                        rollout
+                        update
+                            .output
                             .spaceout
                             .space
                             .as_ref()
                             .expect("a space in rollout")
                             .name
                             .to_bytes(),
                     );
-                    let bid_key = BidHash::from_bid(rollout.bid_value, base_hash);
+                    let bid_key = BidKey::from_bid(rollout.priority, base_hash);
 
-                    let outpoint_key = OutpointHash::from_outpoint::<Sha256>(rollout.outpoint);
+                    let outpoint_key =
+                        OutpointKey::from_outpoint::<Sha256>(update.output.outpoint());
 
                     state.remove(bid_key);
-                    state.insert_spaceout(outpoint_key, rollout.spaceout);
+                    state.insert_spaceout(outpoint_key, update.output.spaceout);
                 }
-                MetaOutKind::SpaceOut(carried) => {
+                UpdateKind::Bid => {
                     // Only bids are expected in meta outputs
                     let base_hash = Sha256::hash(
-                        carried
+                        update
+                            .output
                             .spaceout
                             .space
                             .as_ref()
@@ -251,25 +232,27 @@ impl Node {
                             .to_bytes(),
                     );
 
-                    let (bid_value, previous_bid) = unwrap_bid_value(&carried.spaceout);
+                    let (bid_value, previous_bid) =
+                        unwrap_bid_value(&update.output.spaceout);
 
-                    let bid_hash = BidHash::from_bid(bid_value, base_hash);
-                    let space_key = SpaceHash::from(base_hash);
+                    let bid_hash = BidKey::from_bid(bid_value, base_hash);
+                    let space_key = SpaceKey::from(base_hash);
 
-                    match carried.spaceout.space.as_ref().expect("space").covenant {
+                    match update.output.spaceout.space.as_ref().expect("space").covenant {
                         Covenant::Bid { claim_height, .. } => {
                             if claim_height.is_none() {
-                                let prev_bid_hash = BidHash::from_bid(previous_bid, base_hash);
+                                let prev_bid_hash = BidKey::from_bid(previous_bid, base_hash);
                                 state.update_bid(Some(prev_bid_hash), bid_hash, space_key);
                             }
                         }
                         _ => panic!("expected bid"),
                     }
 
-                    state.insert_space(space_key, carried.outpoint.into());
+                    let carried_outpoint = update.output.outpoint();
+                    state.insert_space(space_key, carried_outpoint.into());
 
-                    let outpoint_key = OutpointHash::from_outpoint::<Sha256>(carried.outpoint);
-                    state.insert_spaceout(outpoint_key, carried.spaceout);
+                    let outpoint_key = OutpointKey::from_outpoint::<Sha256>(carried_outpoint);
+                    state.insert_spaceout(outpoint_key, update.output.spaceout);
                 }
             }
         }
@@ -291,7 +274,7 @@ impl Node {
             let mut hash = [0u8; 32];
             hash.copy_from_slice(raw_hash.as_slice());
 
-            let space_hash = SpaceHash::from_raw(hash)?;
+            let space_hash = SpaceKey::from_raw(hash)?;
             let full = chain.state.get_space_info(&space_hash)?;
 
             if let Some(full) = full {