diff --git a/node/src/bin/space-cli.rs b/node/src/bin/space-cli.rs index 6e71d7d..3296767 100644 --- a/node/src/bin/space-cli.rs +++ b/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 { 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, + }, + )); } } } diff --git a/node/src/bin/spaced.rs b/node/src/bin/spaced.rs index 987f148..d3e6be7 100644 --- a/node/src/bin/spaced.rs +++ b/node/src/bin/spaced.rs @@ -6,7 +6,7 @@ use log::error; use spaced::{ config::{safe_exit, Args}, rpc::{AsyncChainState, LoadedWallet, RpcServerImpl, WalletManager}, - source::BitcoinBlockSource, + source::{BitcoinBlockSource, BitcoinRpc}, store, sync::Spaced, wallets::RpcWallet, @@ -82,6 +82,7 @@ impl Composer { }; let (async_chain_state, async_chain_state_handle) = create_async_store( + spaced.rpc.clone(), spaced.chain.state.clone(), spaced.block_index.as_ref().map(|index| index.state.clone()), self.shutdown.subscribe(), @@ -140,15 +141,16 @@ impl Composer { } async fn create_async_store( + rpc: BitcoinRpc, chain_state: LiveSnapshot, block_index: Option, shutdown: broadcast::Receiver<()>, ) -> (AsyncChainState, JoinHandle<()>) { let (tx, rx) = mpsc::channel(32); let async_store = AsyncChainState::new(tx); - + let client = reqwest::Client::new(); let handle = tokio::spawn(async move { - AsyncChainState::handler(chain_state, block_index, rx, shutdown).await + AsyncChainState::handler(&client, rpc, chain_state, block_index, rx, shutdown).await }); (async_store, handle) } diff --git a/node/src/config.rs b/node/src/config.rs index 9a4d79c..73514a8 100644 --- a/node/src/config.rs +++ b/node/src/config.rs @@ -159,23 +159,41 @@ impl Args { bitcoin_rpc_auth, ); - std::fs::create_dir_all(data_dir.clone())?; + fs::create_dir_all(data_dir.clone())?; - let chain_store = Store::open(data_dir.join("protocol.sdb"))?; + let proto_db_path = data_dir.join("protocol.sdb"); + let initial_sync = !proto_db_path.exists(); + + let chain_store = Store::open(proto_db_path)?; let chain = LiveStore { state: chain_store.begin(&genesis)?, store: chain_store, }; - let block_index = match args.block_index { - true => { - let block_store = Store::open(data_dir.join("blocks.sdb"))?; - Some(LiveStore { - state: block_store.begin(&genesis).expect("begin block index"), - store: block_store, - }) + let block_index = if args.block_index { + let block_db_path = data_dir.join("block_index.sdb"); + if !initial_sync && !block_db_path.exists() { + return Err(anyhow::anyhow!( + "Block index must be enabled from the initial sync." + )); } - false => None, + let block_store = Store::open(block_db_path)?; + let index = LiveStore { + state: block_store.begin(&genesis).expect("begin block index"), + store: block_store, + }; + { + let tip_1 = index.state.tip.read().expect("index"); + let tip_2 = chain.state.tip.read().expect("tip"); + if tip_1.height != tip_2.height || tip_1.hash != tip_2.hash { + return Err(anyhow::anyhow!( + "Protocol and block index states don't match." + )); + } + } + Some(index) + } else { + None }; Ok(Spaced { diff --git a/node/src/node.rs b/node/src/node.rs index 9a5d69b..d24e059 100644 --- a/node/src/node.rs +++ b/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::{TxChangeSet, UpdateKind, 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, +pub struct BlockMeta { + pub tx_meta: Vec, } #[derive(Debug)] @@ -73,7 +74,7 @@ impl Node { block_hash: BlockHash, block: Block, get_block_data: bool, - ) -> Result> { + ) -> Result> { { 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,137 +95,115 @@ 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::(&mut chain.state, tx)? }; + { TxContext::from_tx::(&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::(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::(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::(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::(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::( - 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::(update.output.outpoint()); + state.remove(hash); + } } } - MetaOutKind::RolloutOut(rollout) => { + UpdateKind::Rollout(rollout) => { let base_hash = Sha256::hash( - rollout + update + .output .spaceout .space .as_ref() @@ -232,17 +211,19 @@ impl Node { .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::(rollout.outpoint); + let outpoint_key = + OutpointKey::from_outpoint::(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,33 @@ 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::(carried.outpoint); - state.insert_spaceout(outpoint_key, carried.spaceout); + let outpoint_key = OutpointKey::from_outpoint::(carried_outpoint); + state.insert_spaceout(outpoint_key, update.output.spaceout); } } } @@ -291,7 +280,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 { diff --git a/node/src/rpc.rs b/node/src/rpc.rs index ef81e15..9d775fe 100644 --- a/node/src/rpc.rs +++ b/node/src/rpc.rs @@ -23,8 +23,9 @@ use protocol::{ OutPoint, }, constants::ChainAnchor, - hasher::{BaseHash, SpaceHash}, + hasher::{BaseHash, SpaceKey}, prepare::DataSource, + validate::TxChangeSet, FullSpaceOut, SpaceOut, }; use serde::{Deserialize, Serialize}; @@ -40,7 +41,7 @@ use wallet::{ use crate::{ config::ExtendedNetwork, - node::ValidatedBlock, + node::BlockMeta, source::BitcoinRpc, store::{ChainState, LiveSnapshot}, wallets::{AddressKind, JointBalance, RpcWallet, TxResponse, WalletCommand, WalletResponse}, @@ -59,7 +60,7 @@ pub enum ChainStateCommand { resp: Responder>, }, GetSpace { - hash: SpaceHash, + hash: SpaceKey, resp: Responder>>, }, @@ -68,12 +69,16 @@ pub enum ChainStateCommand { resp: Responder>>, }, GetSpaceOutpoint { - hash: SpaceHash, + hash: SpaceKey, resp: Responder>>, }, - GetBlockData { + GetTxMeta { + txid: Txid, + resp: Responder>>, + }, + GetBlockMeta { block_hash: BlockHash, - resp: Responder>>, + resp: Responder>>, }, EstimateBid { target: usize, @@ -81,7 +86,7 @@ pub enum ChainStateCommand { }, GetRollout { target: usize, - resp: Responder>>, + resp: Responder>>, }, } @@ -109,13 +114,16 @@ pub trait Rpc { async fn estimate_bid(&self, target: usize) -> Result; #[method(name = "getrollout")] - async fn get_rollout(&self, target: usize) -> Result, ErrorObjectOwned>; + async fn get_rollout(&self, target: usize) -> Result, ErrorObjectOwned>; - #[method(name = "getblockdata")] - async fn get_block_data( + #[method(name = "getblockmeta")] + async fn get_block_meta( &self, block_hash: BlockHash, - ) -> Result, ErrorObjectOwned>; + ) -> Result, ErrorObjectOwned>; + + #[method(name = "gettxmeta")] + async fn get_tx_meta(&self, txid: Txid) -> Result, ErrorObjectOwned>; #[method(name = "walletload")] async fn wallet_load(&self, name: &str) -> Result<(), ErrorObjectOwned>; @@ -645,7 +653,7 @@ impl RpcServer for RpcServerImpl { Ok(info) } - async fn get_rollout(&self, target: usize) -> Result, ErrorObjectOwned> { + async fn get_rollout(&self, target: usize) -> Result, ErrorObjectOwned> { let rollouts = self .store .get_rollout(target) @@ -654,19 +662,28 @@ impl RpcServer for RpcServerImpl { Ok(rollouts) } - async fn get_block_data( + async fn get_block_meta( &self, block_hash: BlockHash, - ) -> Result, ErrorObjectOwned> { + ) -> Result, ErrorObjectOwned> { let data = self .store - .get_block_data(block_hash) + .get_block_meta(block_hash) .await .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::))?; Ok(data) } + async fn get_tx_meta(&self, txid: Txid) -> Result, ErrorObjectOwned> { + let data = self + .store + .get_tx_meta(txid) + .await + .map_err(|error| ErrorObjectOwned::owned(-1, error.to_string(), None::))?; + Ok(data) + } + async fn wallet_load(&self, name: &str) -> Result<(), ErrorObjectOwned> { self.wallet_manager .load_wallet(&self.client, name) @@ -796,7 +813,74 @@ impl AsyncChainState { Self { sender } } + async fn get_indexed_tx( + index: &mut Option, + txid: &Txid, + client: &reqwest::Client, + rpc: &BitcoinRpc, + chain_state: &mut LiveSnapshot, + ) -> Result, anyhow::Error> { + let info: serde_json::Value = rpc + .send_json(client, &rpc.get_raw_transaction(&txid, true)) + .await + .map_err(|e| anyhow!("Could not retrieve tx ({})", e))?; + + let block_hash = BlockHash::from_str( + info.get("blockhash") + .and_then(|t| t.as_str()) + .ok_or_else(|| anyhow!("Could not retrieve block hash for tx (is it in the mempool?)"))?, + )?; + 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)); + } + Ok(None) + } + + async fn get_indexed_block( + index: &mut Option, + block_hash: &BlockHash, + client: &reqwest::Client, + rpc: &BitcoinRpc, + chain_state: &mut LiveSnapshot, + ) -> Result, anyhow::Error> { + let index = index + .as_mut() + .ok_or_else(|| anyhow!("block index must be enabled"))?; + let hash = BaseHash::from_slice(block_hash.as_ref()); + let block: Option = index + .get(hash) + .context("Could not fetch block from index")?; + + if let Some(block_set) = block { + return Ok(Some(block_set)); + } + + let info: serde_json::Value = rpc + .send_json(client, &rpc.get_block_header(block_hash)) + .await + .map_err(|e| anyhow!("Could not retrieve block ({})", e))?; + + let height = info + .get("height") + .and_then(|t| t.as_u64()) + .ok_or_else(|| anyhow!("Could not retrieve block height"))?; + + let tip = chain_state.tip.read().expect("read meta").clone(); + if height > tip.height as u64 { + return Err(anyhow!( + "Spaces is syncing at height {}, requested block height {}", + tip.height, + height + )); + } + Ok(None) + } + pub async fn handle_command( + client: &reqwest::Client, + rpc: &BitcoinRpc, chain_state: &mut LiveSnapshot, block_index: &mut Option, cmd: ChainStateCommand, @@ -822,19 +906,16 @@ impl AsyncChainState { .context("could not fetch spaceout"); let _ = resp.send(result); } - ChainStateCommand::GetBlockData { block_hash, resp } => match block_index { - None => { - let _ = resp.send(Err(anyhow!("block index must be enabled"))); - } - Some(index) => { - let hash = BaseHash::from_slice(block_hash.as_ref()); - let _ = resp.send( - index - .get(hash) - .context("Could not fetch blockdata from index"), - ); - } - }, + ChainStateCommand::GetBlockMeta { block_hash, resp } => { + let res = + Self::get_indexed_block(block_index, &block_hash, client, rpc, chain_state) + .await; + let _ = resp.send(res); + } + ChainStateCommand::GetTxMeta { txid, resp } => { + let res = Self::get_indexed_tx(block_index, &txid, client, rpc, chain_state).await; + let _ = resp.send(res); + } ChainStateCommand::EstimateBid { target, resp } => { let estimate = chain_state.estimate_bid(target); _ = resp.send(estimate); @@ -847,6 +928,8 @@ impl AsyncChainState { } pub async fn handler( + client: &reqwest::Client, + rpc: BitcoinRpc, mut chain_state: LiveSnapshot, mut block_index: Option, mut rx: mpsc::Receiver, @@ -858,7 +941,7 @@ impl AsyncChainState { break; } Some(cmd) = rx.recv() => { - Self::handle_command(&mut chain_state, &mut block_index, cmd).await; + Self::handle_command(client, &rpc, &mut chain_state, &mut block_index, cmd).await; } } } @@ -874,7 +957,7 @@ impl AsyncChainState { resp_rx.await? } - pub async fn get_rollout(&self, target: usize) -> anyhow::Result> { + pub async fn get_rollout(&self, target: usize) -> anyhow::Result> { let (resp, resp_rx) = oneshot::channel(); self.sender .send(ChainStateCommand::GetRollout { target, resp }) @@ -882,7 +965,7 @@ impl AsyncChainState { resp_rx.await? } - pub async fn get_space(&self, hash: SpaceHash) -> anyhow::Result> { + pub async fn get_space(&self, hash: SpaceKey) -> anyhow::Result> { let (resp, resp_rx) = oneshot::channel(); self.sender .send(ChainStateCommand::GetSpace { hash, resp }) @@ -890,7 +973,7 @@ impl AsyncChainState { resp_rx.await? } - pub async fn get_space_outpoint(&self, hash: SpaceHash) -> anyhow::Result> { + pub async fn get_space_outpoint(&self, hash: SpaceKey) -> anyhow::Result> { let (resp, resp_rx) = oneshot::channel(); self.sender .send(ChainStateCommand::GetSpaceOutpoint { hash, resp }) @@ -912,19 +995,24 @@ impl AsyncChainState { resp_rx.await? } - pub async fn get_block_data( - &self, - block_hash: BlockHash, - ) -> anyhow::Result> { + pub async fn get_block_meta(&self, block_hash: BlockHash) -> anyhow::Result> { + let (resp, resp_rx) = oneshot::channel(); + self.sender + .send(ChainStateCommand::GetBlockMeta { block_hash, resp }) + .await?; + resp_rx.await? + } + + pub async fn get_tx_meta(&self, txid: Txid) -> anyhow::Result> { let (resp, resp_rx) = oneshot::channel(); self.sender - .send(ChainStateCommand::GetBlockData { block_hash, resp }) + .send(ChainStateCommand::GetTxMeta { txid, resp }) .await?; resp_rx.await? } } -fn space_hash_from_string(space_hash: &str) -> Result { +fn space_hash_from_string(space_hash: &str) -> Result { let mut hash = [0u8; 32]; hex::decode_to_slice(space_hash, &mut hash).map_err(|_| { ErrorObjectOwned::owned( @@ -933,7 +1021,7 @@ fn space_hash_from_string(space_hash: &str) -> Result, ) })?; - SpaceHash::from_raw(hash).map_err(|_| { + SpaceKey::from_raw(hash).map_err(|_| { ErrorObjectOwned::owned( -1, "expected a 32-byte hex encoded space hash", diff --git a/node/src/source.rs b/node/src/source.rs index 2b1fafe..090d9e2 100644 --- a/node/src/source.rs +++ b/node/src/source.rs @@ -141,6 +141,16 @@ impl BitcoinRpc { self.make_request("getblockcount", params) } + pub fn get_block_header(&self, hash: &BlockHash) -> BitcoinRpcRequest { + let params = serde_json::json!([hash]); + self.make_request("getblockheader", params) + } + + pub fn get_raw_transaction(&self, hash: &Txid, verbose: bool) -> BitcoinRpcRequest { + let params = serde_json::json!([hash, verbose]); + self.make_request("getrawtransaction", params) + } + pub fn get_block_hash(&self, height: u32) -> BitcoinRpcRequest { let params = serde_json::json!([height]); diff --git a/node/src/store.rs b/node/src/store.rs index 1bd8590..a21f008 100644 --- a/node/src/store.rs +++ b/node/src/store.rs @@ -13,7 +13,7 @@ use bincode::{config, Decode, Encode}; use protocol::{ bitcoin::OutPoint, constants::{ChainAnchor, ROLLOUT_BATCH_SIZE}, - hasher::{BidHash, KeyHash, OutpointHash, SpaceHash}, + hasher::{BidKey, KeyHash, OutpointKey, SpaceKey}, prepare::DataSource, FullSpaceOut, SpaceOut, }; @@ -141,41 +141,41 @@ impl From for OutPoint { } pub trait ChainState { - fn insert_spaceout(&self, key: OutpointHash, spaceout: SpaceOut); - fn insert_space(&self, key: SpaceHash, outpoint: EncodableOutpoint); + fn insert_spaceout(&self, key: OutpointKey, spaceout: SpaceOut); + fn insert_space(&self, key: SpaceKey, outpoint: EncodableOutpoint); - fn update_bid(&self, previous: Option, bid: BidHash, space: SpaceHash); + fn update_bid(&self, previous: Option, bid: BidKey, space: SpaceKey); fn get_space_info( &mut self, - space_hash: &protocol::hasher::SpaceHash, + space_hash: &protocol::hasher::SpaceKey, ) -> anyhow::Result>; } impl ChainState for LiveSnapshot { - fn insert_spaceout(&self, key: OutpointHash, spaceout: SpaceOut) { + fn insert_spaceout(&self, key: OutpointKey, spaceout: SpaceOut) { self.insert(key, spaceout) } - fn insert_space(&self, key: SpaceHash, outpoint: EncodableOutpoint) { + fn insert_space(&self, key: SpaceKey, outpoint: EncodableOutpoint) { self.insert(key, outpoint) } - fn update_bid(&self, previous: Option, bid: BidHash, space: SpaceHash) { + fn update_bid(&self, previous: Option, bid: BidKey, space: SpaceKey) { if let Some(previous) = previous { self.remove(previous); } self.insert(bid, space) } - fn get_space_info(&mut self, space_hash: &SpaceHash) -> anyhow::Result> { + fn get_space_info(&mut self, space_hash: &SpaceKey) -> anyhow::Result> { let outpoint = self.get_space_outpoint(space_hash)?; if let Some(outpoint) = outpoint { let spaceout = self.get_spaceout(&outpoint)?; return Ok(Some(FullSpaceOut { - outpoint, + txid: outpoint.txid, spaceout: spaceout.expect("should exist if outpoint exists"), })); } @@ -324,7 +324,7 @@ impl LiveSnapshot { Ok(*priority as u64) } - pub fn get_rollout(&mut self, target: usize) -> anyhow::Result> { + pub fn get_rollout(&mut self, target: usize) -> anyhow::Result> { let skip = target * ROLLOUT_BATCH_SIZE; let entries = self.get_rollout_entries(Some(ROLLOUT_BATCH_SIZE), skip)?; @@ -335,7 +335,7 @@ impl LiveSnapshot { &mut self, limit: Option, skip: usize, - ) -> anyhow::Result> { + ) -> anyhow::Result> { // TODO: this could use some clean up let rlock = self.staged.read().expect("acquire lock"); let mut deleted = BTreeSet::new(); @@ -344,13 +344,13 @@ impl LiveSnapshot { .iter() .rev() .filter_map(|(key, value)| { - if BidHash::is_valid(key) { + if BidKey::is_valid(key) { if value.is_some() { let spacehash = - SpaceHash::from_slice_unchecked(value.as_ref().unwrap().as_slice()); - Some((BidHash::from_slice_unchecked(key.as_slice()), spacehash)) + SpaceKey::from_slice_unchecked(value.as_ref().unwrap().as_slice()); + Some((BidKey::from_slice_unchecked(key.as_slice()), spacehash)) } else { - deleted.insert(BidHash::from_slice_unchecked(key.as_slice())); + deleted.insert(BidKey::from_slice_unchecked(key.as_slice())); None } } else { @@ -390,7 +390,7 @@ impl LiveSnapshot { impl protocol::prepare::DataSource for LiveSnapshot { fn get_space_outpoint( &mut self, - space_hash: &protocol::hasher::SpaceHash, + space_hash: &protocol::hasher::SpaceKey, ) -> protocol::errors::Result> { let result: Option = self .get(*space_hash) @@ -399,7 +399,7 @@ impl protocol::prepare::DataSource for LiveSnapshot { } fn get_spaceout(&mut self, outpoint: &OutPoint) -> protocol::errors::Result> { - let h = OutpointHash::from_outpoint::(*outpoint); + let h = OutpointKey::from_outpoint::(*outpoint); let result = self .get(h) .map_err(|err| protocol::errors::Error::IO(err.to_string()))?; @@ -427,7 +427,7 @@ impl Iterator for RolloutIterator { match result { Ok((key, value)) => { - if BidHash::is_valid(&key) { + if BidKey::is_valid(&key) { return Some(Ok((key, value))); } } @@ -445,13 +445,13 @@ struct KeyRolloutIterator { } impl Iterator for KeyRolloutIterator { - type Item = anyhow::Result<(BidHash, SpaceHash)>; + type Item = anyhow::Result<(BidKey, SpaceKey)>; fn next(&mut self) -> Option { while let Some(result) = self.iter.next() { match result { - Ok((key, value)) if BidHash::is_valid(&key) => { - let spacehash = SpaceHash::from_slice_unchecked(value.as_slice()); - let bidhash = BidHash::from_slice_unchecked(key.as_slice()); + Ok((key, value)) if BidKey::is_valid(&key) => { + let spacehash = SpaceKey::from_slice_unchecked(value.as_slice()); + let bidhash = BidKey::from_slice_unchecked(key.as_slice()); return Some(Ok((bidhash, spacehash))); } Ok(_) => { @@ -466,8 +466,8 @@ impl Iterator for KeyRolloutIterator { struct MergingIterator where - I1: Iterator>, - I2: Iterator>, + I1: Iterator>, + I2: Iterator>, { iter1: std::iter::Peekable, iter2: std::iter::Peekable, @@ -475,8 +475,8 @@ where impl MergingIterator where - I1: Iterator>, - I2: Iterator>, + I1: Iterator>, + I2: Iterator>, { fn new(iter1: I1, iter2: I2) -> Self { MergingIterator { @@ -488,10 +488,10 @@ where impl Iterator for MergingIterator where - I1: Iterator>, - I2: Iterator>, + I1: Iterator>, + I2: Iterator>, { - type Item = Result<(BidHash, SpaceHash)>; + type Item = Result<(BidKey, SpaceKey)>; fn next(&mut self) -> Option { match (self.iter1.peek(), self.iter2.peek()) { diff --git a/node/src/sync.rs b/node/src/sync.rs index ae37edc..d9f9589 100644 --- a/node/src/sync.rs +++ b/node/src/sync.rs @@ -11,7 +11,7 @@ use tokio::sync::broadcast; use crate::{ config::ExtendedNetwork, - node::{BlockSource, Node, ValidatedBlock}, + node::{BlockMeta, BlockSource, Node}, source::{BitcoinBlockSource, BitcoinRpc, BlockEvent, BlockFetchError, BlockFetcher}, store::LiveStore, }; @@ -98,7 +98,7 @@ impl Spaced { pub fn save_block( store: LiveStore, block_hash: BlockHash, - block: ValidatedBlock, + block: BlockMeta, ) -> anyhow::Result<()> { store .state diff --git a/node/src/wallets.rs b/node/src/wallets.rs index 996c962..2c21add 100644 --- a/node/src/wallets.rs +++ b/node/src/wallets.rs @@ -7,7 +7,7 @@ use log::{info, warn}; use protocol::{ bitcoin::Txid, constants::ChainAnchor, - hasher::{KeyHasher, SpaceHash}, + hasher::{KeyHasher, SpaceKey}, prepare::DataSource, sname::{NameLike, SName}, FullSpaceOut, @@ -20,7 +20,11 @@ use tokio::{ }; use wallet::{ address::SpaceAddress, - bdk_wallet::{bitcoin::psbt::Input, KeychainKind, LocalOutput, Utxo, WeightedUtxo}, + bdk_wallet::{ + bitcoin::psbt::Input, + chain::{local_chain::CheckPoint, BlockId}, + KeychainKind, LocalOutput, Utxo, WeightedUtxo, + }, bitcoin, bitcoin::{Address, Amount, FeeRate, Sequence}, builder::{ @@ -28,8 +32,7 @@ use wallet::{ }, DoubleUtxo, SpacesWallet, WalletInfo, }; -use wallet::bdk_wallet::chain::BlockId; -use wallet::bdk_wallet::chain::local_chain::CheckPoint; + use crate::{ config::ExtendedNetwork, node::BlockSource, @@ -354,7 +357,7 @@ impl RpcWallet { wallet.spaces.insert_checkpoint(cp.block_id())?; cp } - Some(cp) => cp + Some(cp) => cp, }; wallet_tip.height = restore_point.block_id().height; @@ -429,7 +432,7 @@ impl RpcWallet { coinouts.push(output); } Some(spaceout) => spaceouts.push(FullSpaceOut { - outpoint: output.outpoint, + txid: output.outpoint.txid, spaceout, }), } @@ -462,7 +465,7 @@ impl RpcWallet { } }; - let spacehash = SpaceHash::from(Sha256::hash(sname.to_bytes())); + let spacehash = SpaceKey::from(Sha256::hash(sname.to_bytes())); let script_pubkey = match store.get_space_info(&spacehash)? { None => return Ok(None), Some(fullspaceout) => fullspaceout.spaceout.script_pubkey, @@ -528,7 +531,7 @@ impl RpcWallet { Some(r) => r, }; for space in spaces { - let spacehash = SpaceHash::from(Sha256::hash(space.to_bytes())); + let spacehash = SpaceKey::from(Sha256::hash(space.to_bytes())); match store.get_space_info(&spacehash)? { None => return Err(anyhow!("sendspaces: you don't own `{}`", space)), Some(full) @@ -554,7 +557,7 @@ impl RpcWallet { let name = SName::from_str(¶ms.name)?; if !tx.force { // Warn if already exists - let spacehash = SpaceHash::from(Sha256::hash(name.to_bytes())); + let spacehash = SpaceKey::from(Sha256::hash(name.to_bytes())); let spaceout = store.get_space_info(&spacehash)?; if spaceout.is_some() { return Err(anyhow!("open '{}': space already exists", params.name)); @@ -565,7 +568,7 @@ impl RpcWallet { } RpcWalletRequest::Bid(params) => { let name = SName::from_str(¶ms.name)?; - let spacehash = SpaceHash::from(Sha256::hash(name.to_bytes())); + let spacehash = SpaceKey::from(Sha256::hash(name.to_bytes())); let spaceout = store.get_space_info(&spacehash)?; if spaceout.is_none() { return Err(anyhow!("bid '{}': space does not exist", params.name)); @@ -574,7 +577,7 @@ impl RpcWallet { } RpcWalletRequest::Register(params) => { let name = SName::from_str(¶ms.name)?; - let spacehash = SpaceHash::from(Sha256::hash(name.to_bytes())); + let spacehash = SpaceKey::from(Sha256::hash(name.to_bytes())); let spaceout = store.get_space_info(&spacehash)?; if spaceout.is_none() { return Err(anyhow!("register '{}': space does not exist", params.name)); @@ -627,7 +630,7 @@ impl RpcWallet { let mut spaces = Vec::new(); for space in params.context.iter() { let name = SName::from_str(&space)?; - let spacehash = SpaceHash::from(Sha256::hash(name.to_bytes())); + let spacehash = SpaceKey::from(Sha256::hash(name.to_bytes())); let spaceout = store.get_space_info(&spacehash)?; if spaceout.is_none() { return Err(anyhow!("execute on '{}': space does not exist", space)); diff --git a/protocol/src/constants.rs b/protocol/src/constants.rs index 978f069..637cf76 100644 --- a/protocol/src/constants.rs +++ b/protocol/src/constants.rs @@ -1,5 +1,6 @@ use bitcoin::{ absolute::{Height, LockTime}, + blockdata::transaction::Version, hashes::Hash, BlockHash, Sequence, }; @@ -35,7 +36,7 @@ pub const RENEWAL_INTERVAL: u32 = 144 * 365; /// The transaction version used in the carried bid PSBT. /// This must match for correct PSBT reconstruction. -pub const BID_PSBT_TX_VERSION: i32 = 2; +pub const BID_PSBT_TX_VERSION: Version = Version::TWO; /// The lock time for bid PSBTs. /// This must match for correct PSBT reconstruction. diff --git a/protocol/src/hasher.rs b/protocol/src/hasher.rs index 09231fd..fe86c37 100644 --- a/protocol/src/hasher.rs +++ b/protocol/src/hasher.rs @@ -15,12 +15,12 @@ pub trait KeyHasher { #[derive(Copy, Clone, Debug, Ord, PartialOrd, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] -pub struct SpaceHash(Hash); +pub struct SpaceKey(Hash); #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] -pub struct BidHash(Hash); +pub struct BidKey(Hash); #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] @@ -38,23 +38,23 @@ impl BaseHash { #[derive(Copy, Clone)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] -pub struct OutpointHash(Hash); +pub struct OutpointKey(Hash); pub trait KeyHash {} -impl KeyHash for SpaceHash {} -impl KeyHash for OutpointHash {} -impl KeyHash for BidHash {} +impl KeyHash for SpaceKey {} +impl KeyHash for OutpointKey {} +impl KeyHash for BidKey {} impl KeyHash for BaseHash {} -impl From for SpaceHash { +impl From for SpaceKey { fn from(mut value: Hash) -> Self { value[0] &= 0b0111_1111; value[31] &= 0b1111_1110; - SpaceHash(value) + SpaceKey(value) } } -impl SpaceHash { +impl SpaceKey { #[inline(always)] pub fn from_raw(value: Hash) -> crate::errors::Result { if (value[0] & 0b1000_0000) == 0 && (value[31] & 0b0000_0001) == 0 { @@ -75,20 +75,20 @@ impl SpaceHash { } } -impl From for Hash { - fn from(value: SpaceHash) -> Self { +impl From for Hash { + fn from(value: SpaceKey) -> Self { value.0 } } -impl From for Hash { - fn from(value: BidHash) -> Self { +impl From for Hash { + fn from(value: BidKey) -> Self { value.0 } } -impl From for Hash { - fn from(value: OutpointHash) -> Self { +impl From for Hash { + fn from(value: OutpointKey) -> Self { value.0 } } @@ -105,7 +105,7 @@ impl From for Hash { } } -impl OutpointHash { +impl OutpointKey { pub fn from_outpoint(value: OutPoint) -> Self { let mut buffer = [0u8; 32 + 4]; buffer[0..32].copy_from_slice(value.txid.as_ref()); @@ -115,7 +115,7 @@ impl OutpointHash { } } -impl BidHash { +impl BidKey { pub fn from_bid(bid_value: Amount, mut base_hash: Hash) -> Self { let priority = core::cmp::min(bid_value.to_sat(), (1 << 31) - 1) as u32; let priority_bytes = priority.to_be_bytes(); @@ -123,7 +123,7 @@ impl BidHash { // first bit is always 1 base_hash[0] |= 0b1000_0000; - BidHash(base_hash) + BidKey(base_hash) } pub fn priority(&self) -> u32 { @@ -152,20 +152,20 @@ impl BidHash { } } -impl From for BidHash { +impl From for BidKey { fn from(mut value: Hash) -> Self { // First bit is always 0 and last bit is always 1 value[0] &= 0b0111_1111; value[31] |= 0b0000_0001; - BidHash(value) + BidKey(value) } } -impl From for OutpointHash { +impl From for OutpointKey { fn from(mut value: Hash) -> Self { // First bit is always 0 and last bit is always 1 value[0] &= 0b0111_1111; value[31] |= 0b0000_0001; - OutpointHash(value) + OutpointKey(value) } } diff --git a/protocol/src/lib.rs b/protocol/src/lib.rs index 4a19b1c..02265a5 100644 --- a/protocol/src/lib.rs +++ b/protocol/src/lib.rs @@ -15,7 +15,7 @@ use bitcoin::{ sighash::{Prevouts, SighashCache, TapSighashType}, taproot, transaction::Version, - Amount, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Witness, + Amount, OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid, Witness, }; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; @@ -39,7 +39,7 @@ pub mod validate; #[cfg_attr(feature = "bincode", derive(Encode, Decode))] pub struct FullSpaceOut { #[cfg_attr(feature = "bincode", bincode(with_serde))] - pub outpoint: OutPoint, + pub txid: Txid, #[cfg_attr(feature = "serde", serde(flatten))] pub spaceout: SpaceOut, @@ -51,15 +51,16 @@ pub struct FullSpaceOut { #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] pub struct SpaceOut { + pub n: usize, + /// Any space associated with this output + #[cfg_attr(feature = "serde", serde(flatten))] + pub space: Option, /// The value of the output, in satoshis. #[cfg_attr(feature = "bincode", bincode(with_serde))] pub value: Amount, /// The script which must be satisfied for the output to be spent. #[cfg_attr(feature = "bincode", bincode(with_serde))] pub script_pubkey: ScriptBuf, - /// Any space associated with this output - #[cfg_attr(feature = "serde", serde(flatten))] - pub space: Option, } #[derive(Clone, PartialEq, Debug)] @@ -114,7 +115,10 @@ pub enum Covenant { #[derive(Copy, Clone, PartialEq, Debug)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] -#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))] +#[cfg_attr( + feature = "serde", + serde(rename_all = "snake_case", tag = "revoke_reason") +)] pub enum RevokeReason { BidPsbt(BidPsbtReason), /// Space was prematurely spent during the auctions phase @@ -125,16 +129,24 @@ pub enum RevokeReason { Expired, } -#[derive(Copy, Clone, PartialEq, Debug)] -#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[derive(Copy, Clone, PartialEq, Debug, Eq)] +#[cfg_attr( + feature = "serde", + derive(Serialize, Deserialize), + serde(rename_all = "snake_case") +)] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] pub enum RejectReason { AlreadyExists, BidPSBT(BidPsbtReason), } -#[derive(Copy, Clone, Debug, PartialEq)] -#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +#[cfg_attr( + feature = "serde", + derive(Serialize, Deserialize), + serde(rename_all = "snake_case", tag = "bid_psbt_reason") +)] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] pub enum BidPsbtReason { Required, @@ -162,7 +174,7 @@ impl Space { } } - pub fn is_bid_spend(&self, tx_version: i32, txin: &TxIn) -> bool { + pub fn is_bid_spend(&self, tx_version: Version, txin: &TxIn) -> bool { if tx_version != BID_PSBT_TX_VERSION || txin.sequence != BID_PSBT_INPUT_SEQUENCE || txin.witness.len() != 1 @@ -200,6 +212,13 @@ impl Space { } impl FullSpaceOut { + pub fn outpoint(&self) -> OutPoint { + OutPoint { + txid: self.txid, + vout: self.spaceout.n as u32, + } + } + pub fn verify_bid_sig(&self) -> bool { if !self.spaceout.script_pubkey.is_p2tr() { return false; @@ -329,10 +348,13 @@ impl FullSpaceOut { ); let tx = Transaction { - version: Version(BID_PSBT_TX_VERSION), + version: BID_PSBT_TX_VERSION, lock_time: BID_PSBT_TX_LOCK_TIME, input: vec![TxIn { - previous_output: auctioned_utxo.outpoint, + previous_output: OutPoint { + txid: auctioned_utxo.txid, + vout: auctioned_utxo.spaceout.n as u32, + }, sequence: BID_PSBT_INPUT_SEQUENCE, witness, ..Default::default() diff --git a/protocol/src/prepare.rs b/protocol/src/prepare.rs index ef2a353..c3baa3b 100644 --- a/protocol/src/prepare.rs +++ b/protocol/src/prepare.rs @@ -4,13 +4,12 @@ use bitcoin::{ absolute::LockTime, opcodes::all::OP_RETURN, secp256k1::{schnorr, schnorr::Signature}, - transaction::Version, - Amount, OutPoint, Transaction, TxIn, TxOut, Txid, + Amount, OutPoint, Transaction, TxOut, }; use crate::{ errors::Result, - hasher::{KeyHasher, SpaceHash}, + hasher::{KeyHasher, SpaceKey}, script::{ScriptMachine, ScriptResult}, SpaceOut, }; @@ -23,32 +22,13 @@ pub struct BidPsbt { pub(crate) burn_amount: Amount, } -/// A subset of a Bitcoin transaction relevant to the Spaces protocol -/// along with all the data necessary to validate it. -pub struct PreparedTransaction { - pub version: Version, - - pub lock_time: LockTime, - - /// The Bitcoin transaction id - pub txid: Txid, - - /// List of transaction inputs - pub inputs: Vec, - - /// List of transaction outputs - pub outputs: Vec, - +pub struct TxContext { + pub inputs: Vec, pub auctioned_output: Option, } -pub enum FullTxIn { - FullSpaceIn(FullSpaceIn), - CoinIn(TxIn), -} - -pub struct FullSpaceIn { - pub input: TxIn, +pub struct InputContext { + pub n: usize, pub sstxo: SSTXO, pub script: Option>, } @@ -67,17 +47,14 @@ pub struct AuctionedOutput { } pub trait DataSource { - fn get_space_outpoint( - &mut self, - space_hash: &SpaceHash, - ) -> crate::errors::Result>; + fn get_space_outpoint(&mut self, space_hash: &SpaceKey) -> Result>; - fn get_spaceout(&mut self, outpoint: &OutPoint) -> crate::errors::Result>; + fn get_spaceout(&mut self, outpoint: &OutPoint) -> Result>; } -impl PreparedTransaction { +impl TxContext { #[inline(always)] - pub fn spending_space_in(src: &mut T, tx: &Transaction) -> Result { + pub fn spending_spaces(src: &mut T, tx: &Transaction) -> Result { for input in tx.input.iter() { if src.get_spaceout(&input.previous_output)?.is_some() { return Ok(true); @@ -86,40 +63,22 @@ impl PreparedTransaction { Ok(false) } - /// Creates a [PreparedTransaction] from a Bitcoin [Transaction], loading all necessary data + /// Creates a [TxContext] from a Bitcoin [Transaction], loading all necessary data /// for validation from the provided data source `src`. This function executes the Space script /// and loads any additional context required for further validation. /// - /// Key behaviors and assumptions: - /// - /// 1. OP_RETURN Priority: - /// - The OP_RETURN at index 0 is assumed to carry the bid PSBT. - /// - This PSBT is consumed by either an input spending a Space UTXO or an OP_OPEN revealed - /// in the input witness. If both are present in the same input, the spend takes priority. - /// - /// 2. Multiple Space Scripts: - /// - If Space scripts are revealed in multiple inputs, they are executed in input order. - /// - Execution stops at the first error encountered in a script but has no effect on other - /// scripts in the transaction. - /// /// Returns `Some(PreparedTransaction)` if the transaction is relevant to the Spaces protocol. /// Returns `None` if the transaction is not relevant. pub fn from_tx( src: &mut T, - tx: Transaction, - ) -> Result> { - if !Self::spending_space_in(src, &tx)? { - if tx.is_magic_output() { - return Ok(Some(PreparedTransaction { - version: tx.version, - lock_time: tx.lock_time, - txid: tx.compute_txid(), - inputs: tx - .input - .into_iter() - .map(|input| FullTxIn::CoinIn(input)) - .collect(), - outputs: tx.output, + tx: &Transaction, + ) -> Result> { + if !Self::spending_spaces(src, &tx)? { + if is_magic_lock_time(&tx.lock_time) + && tx.output.iter().any(|out| out.is_magic_output()) + { + return Ok(Some(TxContext { + inputs: vec![], // even if such an output exists, it can be ignored // as there's no spends of existing space outputs auctioned_output: None, @@ -137,40 +96,30 @@ impl PreparedTransaction { }), }; - let txid = tx.compute_txid(); - for input in tx.input.into_iter() { + for (n, input) in tx.input.iter().enumerate() { let spaceout = match src.get_spaceout(&input.previous_output)? { - None => { - inputs.push(FullTxIn::CoinIn(input)); - continue; - } + None => continue, Some(out) => out, }; - let sstxo = SSTXO { previous_output: spaceout, }; - - let mut spacein = FullSpaceIn { - input, + let mut spacein = InputContext { + n, sstxo, script: None, }; // Run any space scripts - if let Some(script) = spacein.input.witness.tapscript() { - spacein.script = Some(ScriptMachine::execute::(src, script)?); + if let Some(script) = input.witness.tapscript() { + spacein.script = Some(ScriptMachine::execute::(n, src, script)?); } - inputs.push(FullTxIn::FullSpaceIn(spacein)) + inputs.push(spacein) } - Ok(Some(PreparedTransaction { - version: tx.version, - lock_time: tx.lock_time, - txid, + Ok(Some(TxContext { inputs, - outputs: tx.output, - auctioned_output: auctioned_output, + auctioned_output, })) } @@ -230,15 +179,6 @@ pub trait TrackableOutput { fn is_magic_output(&self) -> bool; } -impl TrackableOutput for Transaction { - fn is_magic_output(&self) -> bool { - if is_magic_lock_time(&self.lock_time) { - return self.output.iter().any(|out| out.is_magic_output()); - } - false - } -} - pub fn is_magic_lock_time(lock_time: &LockTime) -> bool { if let LockTime::Seconds(s) = lock_time { return s.to_consensus_u32() % 1000 == 222; diff --git a/protocol/src/script.rs b/protocol/src/script.rs index c19dde5..7ee26d5 100644 --- a/protocol/src/script.rs +++ b/protocol/src/script.rs @@ -15,10 +15,11 @@ use bitcoin::{ use serde::{Deserialize, Serialize}; use crate::{ - hasher::{KeyHasher, SpaceHash}, + hasher::{KeyHasher, SpaceKey}, opcodes::{SpaceOpcode, *}, prepare::DataSource, sname::{NameLike, SName, SNameRef}, + validate::RejectParams, FullSpaceOut, }; @@ -39,6 +40,7 @@ pub struct ScriptMachine { pub struct OpOpenContext { // Whether its attempting to open a new space or an existing one pub spaceout: SpaceKind, + pub input_index: usize, } #[derive(Clone, Debug)] @@ -78,6 +80,7 @@ pub enum SpaceInstruction<'a> { impl ScriptMachine { fn op_open( + input_index: usize, src: &mut T, stack: &mut Vec>, ) -> crate::errors::Result> { @@ -100,22 +103,26 @@ impl ScriptMachine { }; let spaceout = { - let spacehash = SpaceHash::from(H::hash(name.to_bytes())); + let spacehash = SpaceKey::from(H::hash(name.to_bytes())); let existing = src.get_space_outpoint(&spacehash)?; match existing { None => SpaceKind::NewSpace(name.to_owned()), Some(outpoint) => SpaceKind::ExistingSpace(FullSpaceOut { - outpoint, + txid: outpoint.txid, spaceout: src.get_spaceout(&outpoint)?.expect("spaceout exists"), }), } }; - let open = Ok(OpOpenContext { spaceout }); + let open = Ok(OpOpenContext { + input_index, + spaceout, + }); Ok(open) } pub fn execute( + input_index: usize, src: &mut T, script: &Script, ) -> crate::errors::Result> { @@ -138,11 +145,10 @@ impl ScriptMachine { SpaceInstruction::Op(op) => { match op.code { OP_OPEN => { - let open_result = Self::op_open::(src, &mut stack)?; + let open_result = Self::op_open::(input_index, src, &mut stack)?; if open_result.is_err() { return Ok(Err(open_result.unwrap_err())); } - machine.open = Some(open_result.unwrap()); } OP_SET => { @@ -463,7 +469,11 @@ mod tests { /// much as it could be; patches welcome if more detailed errors /// would help you. #[derive(Debug, Clone, PartialEq, Eq)] -#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] +#[cfg_attr( + feature = "serde", + derive(Serialize, Deserialize), + serde(tag = "type", rename_all = "snake_case") +)] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] #[non_exhaustive] pub enum ScriptError { @@ -475,7 +485,8 @@ pub enum ScriptError { /// invalid/malformed during OP_OPEN UnexpectedLabelCount, TooManyItems, - MultiOpen, + TooManyOpens, + Reject(RejectParams), } impl core::fmt::Display for ScriptError { @@ -488,7 +499,8 @@ impl core::fmt::Display for ScriptError { ExpectedValidVarInt => f.write_str("expected a valid varint"), UnexpectedLabelCount => f.write_str("unexpected label count in space name"), TooManyItems => f.write_str("too many items"), - MultiOpen => f.write_str("multiple opens"), + TooManyOpens => f.write_str("multiple opens"), + Reject(_) => f.write_str("rejected"), } } } diff --git a/protocol/src/validate.rs b/protocol/src/validate.rs index c6511a2..8232728 100644 --- a/protocol/src/validate.rs +++ b/protocol/src/validate.rs @@ -2,15 +2,13 @@ use alloc::{collections::btree_map::BTreeMap, vec, vec::Vec}; #[cfg(feature = "bincode")] use bincode::{Decode, Encode}; -use bitcoin::{absolute, transaction::Version, Amount, OutPoint, Transaction, TxIn, TxOut, Txid}; +use bitcoin::{Amount, OutPoint, Transaction, Txid}; #[cfg(feature = "serde")] use serde::{Deserialize, Serialize}; use crate::{ constants::{AUCTION_DURATION, AUCTION_EXTENSION_ON_BID, RENEWAL_INTERVAL, ROLLOUT_BATCH_SIZE}, - prepare::{ - is_magic_lock_time, AuctionedOutput, FullTxIn, PreparedTransaction, TrackableOutput, SSTXO, - }, + prepare::{is_magic_lock_time, AuctionedOutput, TrackableOutput, TxContext, SSTXO}, script::{OpOpenContext, ScriptError, SpaceKind}, sname::SName, BidPsbtReason, Covenant, FullSpaceOut, RejectReason, RevokeReason, Space, SpaceOut, @@ -22,92 +20,53 @@ pub struct Validator {} #[derive(Clone)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] -/// A `ValidatedTransaction` is a validated protocol transaction that is a superset of -/// a Bitcoin transaction. It includes additional metadata -/// and captures all resulting state changes. -pub struct ValidatedTransaction { - #[cfg_attr(feature = "bincode", bincode(with_serde))] - pub version: Version, - /// Txid cache +/// A `TxChangeSet` captures all resulting state changes. +pub struct TxChangeSet { #[cfg_attr(feature = "bincode", bincode(with_serde))] pub txid: Txid, - /// Block height or timestamp. Transaction cannot be included in a block until this height/time. - #[cfg_attr(feature = "bincode", bincode(with_serde))] - pub lock_time: absolute::LockTime, /// List of transaction inputs. - #[cfg_attr(feature = "serde", serde(rename = "vin"))] - pub input: Vec, + pub spends: Vec, /// List of transaction outputs. - #[cfg_attr(feature = "serde", serde(rename = "vout"))] - pub output: Vec, - /// Meta outputs are not part of the actual transaction, - /// but they capture other state changes caused by it - #[cfg_attr(feature = "serde", serde(rename = "vmetaout"))] - pub meta_output: Vec, -} - -#[derive(Clone, Debug)] -#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] -#[cfg_attr(feature = "bincode", derive(Encode, Decode))] -#[cfg_attr(feature = "serde", serde(untagged))] -pub enum TxInKind { - #[cfg_attr(feature = "serde", serde(rename = "coinout"))] - CoinIn(#[cfg_attr(feature = "bincode", bincode(with_serde))] TxIn), - #[cfg_attr(feature = "serde", serde(rename = "spaceout"))] - SpaceIn(SpaceIn), + pub creates: Vec, + /// Updates to outputs that are not part of the actual transaction such as bid + /// or "auctioned" outputs. + pub updates: Vec, } #[derive(Clone, Debug)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] pub struct SpaceIn { - #[cfg_attr(feature = "bincode", bincode(with_serde))] - #[cfg_attr(feature = "serde", serde(flatten))] - pub txin: TxIn, + pub n: usize, + #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))] pub script_error: Option, } #[derive(Clone, Debug)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] -#[cfg_attr(feature = "serde", serde(untagged))] -pub enum TxOutKind { - CoinOut(#[cfg_attr(feature = "bincode", bincode(with_serde))] TxOut), - SpaceOut(SpaceOut), -} - -#[derive(Clone, Debug)] -#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] -#[cfg_attr(feature = "bincode", derive(Encode, Decode))] -#[cfg_attr(feature = "serde", serde(untagged))] -pub enum MetaOutKind { - ErrorOut(ErrorOut), - RolloutOut(RolloutOut), - SpaceOut(FullSpaceOut), +#[cfg_attr(feature = "serde", serde(rename_all = "snake_case", tag = "type"))] +pub enum UpdateKind { + Revoke(RevokeReason), + Rollout(RolloutDetails), + Bid, } #[derive(Clone, Debug)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] -pub struct RolloutOut { - #[cfg_attr(feature = "bincode", bincode(with_serde))] - pub outpoint: OutPoint, - #[cfg_attr(feature = "bincode", bincode(with_serde))] - pub bid_value: Amount, - +pub struct UpdateOut { #[cfg_attr(feature = "serde", serde(flatten))] - pub spaceout: SpaceOut, + pub kind: UpdateKind, + pub output: FullSpaceOut, } #[derive(Clone, Debug)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] -#[cfg_attr(feature = "serde", serde(tag = "action"))] -pub enum ErrorOut { - #[cfg_attr(feature = "serde", serde(rename = "reject"))] - Reject(RejectParams), - #[cfg_attr(feature = "serde", serde(rename = "revoke"))] - Revoke(RevokeParams), +pub struct RolloutDetails { + #[cfg_attr(feature = "bincode", bincode(with_serde))] + pub priority: Amount, } #[derive(Clone, Debug)] @@ -115,11 +74,9 @@ pub enum ErrorOut { #[cfg_attr(feature = "bincode", derive(Encode, Decode))] pub struct RevokeParams { pub reason: RevokeReason, - #[cfg_attr(feature = "serde", serde(rename = "target"))] - pub spaceout: FullSpaceOut, } -#[derive(Clone, Debug)] +#[derive(Clone, Debug, Eq, PartialEq)] #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))] #[cfg_attr(feature = "bincode", derive(Encode, Decode))] pub struct RejectParams { @@ -142,84 +99,64 @@ impl Validator { Self {} } - pub fn process(&self, height: u32, mut tx: PreparedTransaction) -> ValidatedTransaction { + pub fn process(&self, height: u32, tx: &Transaction, mut ctx: TxContext) -> TxChangeSet { // Auctioned outputs could technically be spent in the same transaction // making the bid psbt unusable. We need to clear any spent ones // before proceeding with further validation - Self::clear_auctioned_spent(&mut tx); - - let mut changeset = ValidatedTransaction { - txid: tx.txid, - version: tx.version, - lock_time: tx.lock_time, - input: Vec::with_capacity(tx.inputs.len()), - output: tx - .outputs - .into_iter() - .map(|out| TxOutKind::CoinOut(out)) - .collect(), - meta_output: vec![], + Self::clear_auctioned_spent(tx, &mut ctx); + + let mut changeset = TxChangeSet { + txid: tx.compute_txid(), + spends: vec![], + creates: vec![], + updates: vec![], }; let mut default_space_data = Vec::new(); let mut space_data = BTreeMap::new(); let mut reserve = false; - for (input_index, full_txin) in tx.inputs.into_iter().enumerate() { - match full_txin { - FullTxIn::FullSpaceIn(spacein) => { - changeset.input.push(TxInKind::SpaceIn(SpaceIn { - txin: spacein.input.clone(), - script_error: None, - })); - - // Process spends of existing space outputs - self.process_spend( - height, - tx.version.0, - &mut tx.auctioned_output, - spacein.input, - input_index as u32, - spacein.sstxo, - &mut changeset, - ); + for fullspacein in ctx.inputs.into_iter() { + changeset.spends.push(SpaceIn { + n: fullspacein.n, + script_error: None, + }); - // Process any space scripts - if let Some(script) = spacein.script { - if script.is_err() { - match &mut changeset.input.last_mut().unwrap() { - TxInKind::CoinIn(_) => { - // Do nothing - } - TxInKind::SpaceIn(spacein) => { - spacein.script_error = Some(script.unwrap_err()); - } - } - } else { - let mut script = script.unwrap(); - if !script.reserve { - if let Some(open) = script.open { - self.process_open( - height, - open, - &mut tx.auctioned_output, - &mut changeset, - ); - } - if let Some(data) = script.default_sdata { - default_space_data = data; - } - space_data.append(&mut script.sdata); - } else { - // Script uses reserved op codes - reserve = true; - } + // Process spends of existing space outputs + self.process_spend( + height, + tx, + &mut ctx.auctioned_output, + fullspacein.n, + fullspacein.sstxo, + &mut changeset, + ); + + // Process any space scripts + if let Some(script) = fullspacein.script { + if script.is_err() { + let last = changeset.spends.last_mut().unwrap(); + last.script_error = Some(script.unwrap_err()); + } else { + let mut script = script.unwrap(); + if !script.reserve { + if let Some(open) = script.open { + self.process_open( + height, + open, + &mut ctx.auctioned_output, + &mut changeset, + ); + } + if let Some(data) = script.default_sdata { + default_space_data = data; } + space_data.append(&mut script.sdata); + } else { + // Script uses reserved op codes + reserve = true; } } - FullTxIn::CoinIn(coinin) => { - changeset.input.push(TxInKind::CoinIn(coinin)); - } } } @@ -227,17 +164,10 @@ impl Validator { // then all space outputs with the transfer covenant must be marked as reserved // This does not have an effect on meta outputs if reserve { - for out in changeset.output.iter_mut() { - match out { - TxOutKind::SpaceOut(spaceout) => { - if let Some(space) = spaceout.space.as_mut() { - if matches!(space.covenant, Covenant::Transfer { .. }) { - space.covenant = Covenant::Reserved - } - } - } - TxOutKind::CoinOut(_) => { - // do nothing + for out in changeset.creates.iter_mut() { + if let Some(space) = out.space.as_mut() { + if matches!(space.covenant, Covenant::Transfer { .. }) { + space.covenant = Covenant::Reserved } } } @@ -245,57 +175,51 @@ impl Validator { // Set default space data if any if !default_space_data.is_empty() { - changeset.output.iter_mut().for_each(|output| match output { - TxOutKind::SpaceOut(spaceout) => match spaceout.space.as_mut() { - None => {} - Some(space) => match &mut space.covenant { + changeset.creates.iter_mut().for_each(|output| { + if let Some(space) = output.space.as_mut() { + match &mut space.covenant { Covenant::Transfer { data, .. } => { *data = Some(default_space_data.clone()); } _ => {} - }, - }, - _ => {} + } + } }); } // Set space specific data if !space_data.is_empty() { for (key, value) in space_data.into_iter() { - match changeset.output.get_mut(key as usize) { - None => { - // do nothing + if let Some(spaceout) = changeset.creates.get_mut(key as usize) { + if let Some(space) = spaceout.space.as_mut() { + match &mut space.covenant { + Covenant::Transfer { data, .. } => { + *data = Some(value); + } + _ => {} + } } - Some(output) => match output { - TxOutKind::SpaceOut(spaceout) => match spaceout.space.as_mut() { - None => {} - Some(space) => match &mut space.covenant { - Covenant::Transfer { data, .. } => { - *data = Some(value); - } - _ => {} - }, - }, - _ => {} - }, } } } // Check if any outputs should be tracked - if is_magic_lock_time(&changeset.lock_time) { - for output in changeset.output.iter_mut() { - match output { - TxOutKind::CoinOut(txout) => { - if txout.is_magic_output() { - *output = TxOutKind::SpaceOut(SpaceOut { - value: txout.value, - script_pubkey: txout.script_pubkey.clone(), + if is_magic_lock_time(&tx.lock_time) { + for (n, output) in tx.output.iter().enumerate() { + match changeset.creates.iter().find(|x| x.n == n) { + None => { + if output.is_magic_output() { + changeset.creates.push(SpaceOut { + n, + value: output.value, + script_pubkey: output.script_pubkey.clone(), space: None, }) } } - _ => {} + Some(_) => { + // already tracked + } } } } @@ -306,27 +230,17 @@ impl Validator { pub fn rollout( &self, height: u32, - coinbase: Transaction, + coinbase: &Transaction, entries: Vec, - ) -> ValidatedTransaction { + ) -> TxChangeSet { assert!(coinbase.is_coinbase(), "expected a coinbase tx"); assert!(entries.len() <= ROLLOUT_BATCH_SIZE, "bad rollout size"); - let mut tx = ValidatedTransaction { - version: coinbase.version, + let mut tx = TxChangeSet { txid: coinbase.compute_txid(), - lock_time: coinbase.lock_time, - input: coinbase - .input - .into_iter() - .map(|input| TxInKind::CoinIn(input)) - .collect(), - output: coinbase - .output - .into_iter() - .map(|out| TxOutKind::CoinOut(out)) - .collect(), - meta_output: vec![], + spends: vec![], + creates: vec![], + updates: vec![], }; for mut entry in entries { @@ -351,11 +265,12 @@ impl Validator { } }; - tx.meta_output.push(MetaOutKind::RolloutOut(RolloutOut { - outpoint: entry.outpoint, - bid_value: rollout_bid, - spaceout: entry.spaceout, - })); + tx.updates.push(UpdateOut { + kind: UpdateKind::Rollout(RolloutDetails { + priority: rollout_bid, + }), + output: entry, + }); } tx @@ -365,17 +280,18 @@ impl Validator { // this function checks for such spends and updates the prepared tx // accordingly #[inline] - fn clear_auctioned_spent(tx: &mut PreparedTransaction) { - if let Some(auctioned) = tx + fn clear_auctioned_spent(tx: &Transaction, meta: &mut TxContext) { + if let Some(auctioned) = meta .auctioned_output .as_ref() .and_then(|out| Some(out.bid_psbt.outpoint)) { - if tx.inputs.iter().any(|input| match input { - FullTxIn::FullSpaceIn(prev) => prev.input.previous_output == auctioned, - FullTxIn::CoinIn(prev) => prev.previous_output == auctioned, - }) { - tx.auctioned_output.as_mut().unwrap().output = None; + if tx + .input + .iter() + .any(|input| input.previous_output == auctioned) + { + meta.auctioned_output.as_mut().unwrap().output = None; } } } @@ -385,31 +301,34 @@ impl Validator { height: u32, open: OpOpenContext, auctiond: &mut Option, - changeset: &mut ValidatedTransaction, + changeset: &mut TxChangeSet, ) { + let spend_index = changeset + .spends + .iter() + .position(|s| s.n == open.input_index) + .expect("open must have an input index revealing the space in witness"); + let name = match open.spaceout { SpaceKind::ExistingSpace(mut prev) => { let prev_space = prev.spaceout.space.as_mut().unwrap(); if !prev_space.is_expired(height) { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Reject(RejectParams { - name: prev.spaceout.space.unwrap().name, - reason: RejectReason::AlreadyExists, - }))); + let reject = ScriptError::Reject(RejectParams { + name: prev.spaceout.space.unwrap().name, + reason: RejectReason::AlreadyExists, + }); + changeset.spends[spend_index].script_error = Some(reject); return; } // Revoke the previously expired space - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: FullSpaceOut { - outpoint: prev.outpoint, - spaceout: prev.spaceout.clone(), - }, - reason: RevokeReason::Expired, - }))); + changeset.updates.push(UpdateOut { + kind: UpdateKind::Revoke(RevokeReason::Expired), + output: FullSpaceOut { + txid: prev.txid, + spaceout: prev.spaceout.clone(), + }, + }); prev.spaceout.space.unwrap().name } SpaceKind::NewSpace(name) => name, @@ -417,24 +336,23 @@ impl Validator { let mut auctiond = match auctiond.take() { None => { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Reject(RejectParams { - name, - reason: RejectReason::BidPSBT(BidPsbtReason::Required), - }))); + let reject = ScriptError::Reject(RejectParams { + name, + reason: RejectReason::BidPSBT(BidPsbtReason::Required), + }); + + changeset.spends[spend_index].script_error = Some(reject); return; } Some(auctiond) => auctiond, }; if auctiond.output.is_none() { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Reject(RejectParams { - name, - reason: RejectReason::BidPSBT(BidPsbtReason::OutputSpent), - }))); + let reject = ScriptError::Reject(RejectParams { + name, + reason: RejectReason::BidPSBT(BidPsbtReason::OutputSpent), + }); + changeset.spends[spend_index].script_error = Some(reject); return; } @@ -454,61 +372,54 @@ impl Validator { }); let fullspaceout = FullSpaceOut { - outpoint: contract.outpoint, + txid: contract.outpoint.txid, spaceout: auctioned_spaceout, }; if !fullspaceout.verify_bid_sig() { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Reject(RejectParams { - name: fullspaceout.spaceout.space.unwrap().name, - reason: RejectReason::BidPSBT(BidPsbtReason::BadSignature), - }))); + let reject = ScriptError::Reject(RejectParams { + name: fullspaceout.spaceout.space.unwrap().name, + reason: RejectReason::BidPSBT(BidPsbtReason::BadSignature), + }); + changeset.spends[spend_index].script_error = Some(reject); return; } - changeset - .meta_output - .push(MetaOutKind::SpaceOut(fullspaceout)); + changeset.updates.push(UpdateOut { + kind: UpdateKind::Bid, + output: fullspaceout, + }); } /// Auctioned output may already be representing another space, /// so we'll need to revoke it, and then we could attach this /// any new space to the output #[inline] - fn detach_existing_space( - auctioned: &mut AuctionedOutput, - changeset: &mut ValidatedTransaction, - ) { + fn detach_existing_space(auctioned: &mut AuctionedOutput, changeset: &mut TxChangeSet) { if let Some(spaceout) = &auctioned.output { if spaceout.space.is_none() { return; } - - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: FullSpaceOut { - outpoint: auctioned.bid_psbt.outpoint, - spaceout: spaceout.clone(), - }, - reason: RevokeReason::BadSpend, - }))); + changeset.updates.push(UpdateOut { + output: FullSpaceOut { + txid: auctioned.bid_psbt.outpoint.txid, + spaceout: spaceout.clone(), + }, + kind: UpdateKind::Revoke(RevokeReason::BadSpend), + }); } } - /// All spends with an spent spaces transaction output must be + /// All spends with a spent spaces transaction output must be /// marked as spent as this function only does additional processing for spends of spaces fn process_spend( &self, height: u32, - tx_version: i32, + tx: &Transaction, auctioned: &mut Option, - input: TxIn, - input_index: u32, + input_index: usize, stxo: SSTXO, - changeset: &mut ValidatedTransaction, + changeset: &mut TxChangeSet, ) { let spaceout = &stxo.previous_output; let space = match &spaceout.space { @@ -519,16 +430,15 @@ impl Validator { Some(space) => space, }; + let input = tx.input.get(input_index).expect("input"); if space.is_expired(height) { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: FullSpaceOut { - outpoint: input.previous_output, - spaceout: spaceout.clone(), - }, - reason: RevokeReason::Expired, - }))); + changeset.updates.push(UpdateOut { + output: FullSpaceOut { + txid: input.previous_output.txid, + spaceout: spaceout.clone(), + }, + kind: UpdateKind::Revoke(RevokeReason::Expired), + }); return; } @@ -540,9 +450,8 @@ impl Validator { } => { self.process_bid_spend( height, - tx_version, + tx, auctioned, - input, input_index, stxo, total_burned, @@ -553,7 +462,7 @@ impl Validator { Covenant::Transfer { .. } => { self.process_transfer( height, - input, + tx, input_index, stxo.previous_output.clone(), space.data_owned(), @@ -561,8 +470,10 @@ impl Validator { ); } Covenant::Reserved => { - // Treat it as a coin spend, so it remains locked in our UTXO set - changeset.input[input_index as usize] = TxInKind::CoinIn(input); + // Keep it unspent so it remains locked in our UTXO set + if let Some(pos) = changeset.spends.iter().position(|i| i.n == input_index) { + changeset.spends.remove(pos); + } } } } @@ -570,57 +481,51 @@ impl Validator { fn process_bid_spend( &self, height: u32, - tx_version: i32, + tx: &Transaction, auctioned: &mut Option, - input: TxIn, - input_index: u32, + input_index: usize, stxo: SSTXO, total_burned: Amount, claim_height: Option, - changeset: &mut ValidatedTransaction, + changeset: &mut TxChangeSet, ) { + let input = tx.input.get(input_index as usize).expect("input"); let mut spaceout = stxo.previous_output; let space_ref = spaceout.space.as_mut().unwrap(); // Handle bid spends - if space_ref.is_bid_spend(tx_version, &input) { + if space_ref.is_bid_spend(tx.version, input) { // Bid spends must have an auctioned output let auctioned_output = auctioned.take(); if auctioned_output.is_none() { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: FullSpaceOut { - outpoint: input.previous_output, - spaceout, - }, - reason: RevokeReason::BidPsbt(BidPsbtReason::Required), - }))); + changeset.updates.push(UpdateOut { + output: FullSpaceOut { + txid: input.previous_output.txid, + spaceout, + }, + kind: UpdateKind::Revoke(RevokeReason::BidPsbt(BidPsbtReason::Required)), + }); return; } let auctioned_output = auctioned_output.unwrap(); if auctioned_output.output.is_none() { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: FullSpaceOut { - outpoint: input.previous_output, - spaceout, - }, - reason: RevokeReason::BidPsbt(BidPsbtReason::OutputSpent), - }))); + changeset.updates.push(UpdateOut { + output: FullSpaceOut { + txid: input.previous_output.txid, + spaceout, + }, + kind: UpdateKind::Revoke(RevokeReason::BidPsbt(BidPsbtReason::OutputSpent)), + }); return; } if auctioned_output.bid_psbt.burn_amount == Amount::ZERO { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: FullSpaceOut { - outpoint: input.previous_output, - spaceout, - }, - reason: RevokeReason::BidPsbt(BidPsbtReason::LowBidAmount), - }))); + changeset.updates.push(UpdateOut { + output: FullSpaceOut { + txid: input.previous_output.txid, + spaceout, + }, + kind: UpdateKind::Revoke(RevokeReason::BidPsbt(BidPsbtReason::LowBidAmount)), + }); return; } @@ -640,100 +545,103 @@ impl Validator { claim_height, }; + let auctioned_spaceout = auctioned_output.output.unwrap(); + assert_eq!( + auctioned_spaceout.n, + auctioned_output.bid_psbt.outpoint.vout as usize + ); let mut fullspaceout = FullSpaceOut { - outpoint: auctioned_output.bid_psbt.outpoint, - spaceout: auctioned_output.output.unwrap(), + txid: auctioned_output.bid_psbt.outpoint.txid, + spaceout: auctioned_spaceout, }; fullspaceout.spaceout.space = Some(spaceout.space.unwrap()); if !fullspaceout.verify_bid_sig() { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: fullspaceout, - reason: RevokeReason::BidPsbt(BidPsbtReason::BadSignature), - }))); + changeset.updates.push(UpdateOut { + output: fullspaceout, + kind: UpdateKind::Revoke(RevokeReason::BidPsbt(BidPsbtReason::BadSignature)), + }); return; } - changeset - .meta_output - .push(MetaOutKind::SpaceOut(fullspaceout)); + changeset.updates.push(UpdateOut { + output: fullspaceout, + kind: UpdateKind::Bid, + }); return; } // Handle non-bid spends: // Check register attempt before claim height if claim_height.is_none() || *claim_height.as_ref().unwrap() > height { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: FullSpaceOut { - outpoint: input.previous_output, - spaceout, - }, - reason: RevokeReason::PrematureClaim, - }))); + changeset.updates.push(UpdateOut { + output: FullSpaceOut { + txid: input.previous_output.txid, + spaceout, + }, + kind: UpdateKind::Revoke(RevokeReason::PrematureClaim), + }); return; } // Registration spend: - self.process_transfer(height, input, input_index, spaceout, None, changeset); + self.process_transfer(height, tx, input_index, spaceout, None, changeset); } fn process_transfer( &self, height: u32, - input: TxIn, - input_index: u32, - spaceout: SpaceOut, + tx: &Transaction, + input_index: usize, + mut spaceout: SpaceOut, existing_data: Option>, - changeset: &mut ValidatedTransaction, + changeset: &mut TxChangeSet, ) { + let input = tx.input.get(input_index).expect("input"); let output_index = input_index + 1; - let output = changeset.output.get_mut(output_index as usize); + let output = tx.output.get(output_index); match output { + None => { + // No corresponding output found + changeset.updates.push(UpdateOut { + output: FullSpaceOut { + txid: input.previous_output.txid, + spaceout, + }, + kind: UpdateKind::Revoke(RevokeReason::BadSpend), + }); + } Some(output) => { - let txout = match output { - TxOutKind::CoinOut(txout) => txout.clone(), - _ => { - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: FullSpaceOut { - outpoint: input.previous_output, - spaceout, - }, - reason: RevokeReason::BadSpend, - }))); - return; - } - }; + // check if there's an existing space output created by this transaction + // representing another space somehow (should never be possible anyway?) + if changeset + .creates + .iter() + .position(|x| x.n == input_index) + .is_some() + { + changeset.updates.push(UpdateOut { + output: FullSpaceOut { + txid: input.previous_output.txid, + spaceout, + }, + kind: UpdateKind::Revoke(RevokeReason::BadSpend), + }); + return; + } + + spaceout.n = output_index; + spaceout.value = output.value; + spaceout.script_pubkey = output.script_pubkey.clone(); let mut space = spaceout.space.unwrap(); space.covenant = Covenant::Transfer { expire_height: height + RENEWAL_INTERVAL, data: existing_data, }; - - *output = TxOutKind::SpaceOut(SpaceOut { - value: txout.value, - script_pubkey: txout.script_pubkey, - space: Some(space), - }); + spaceout.space = Some(space); + changeset.creates.push(spaceout); } - None => { - // No corresponding output found - changeset - .meta_output - .push(MetaOutKind::ErrorOut(ErrorOut::Revoke(RevokeParams { - spaceout: FullSpaceOut { - outpoint: input.previous_output, - spaceout, - }, - reason: RevokeReason::BadSpend, - }))); - } - }; + } } } diff --git a/wallet/src/builder.rs b/wallet/src/builder.rs index 715bc64..c06d31d 100644 --- a/wallet/src/builder.rs +++ b/wallet/src/builder.rs @@ -182,9 +182,9 @@ impl<'a, Cs: CoinSelectionAlgorithm> TxBuilderSpacesUtils<'a, Cs> for TxBuilder< }; let tap_key_spend_weight = 66; - self.version(BID_PSBT_TX_VERSION); + self.version(BID_PSBT_TX_VERSION.0); self.add_foreign_utxo_with_sequence( - info.outpoint, + info.outpoint(), input, tap_key_spend_weight, BID_PSBT_INPUT_SEQUENCE, @@ -295,7 +295,14 @@ impl<'a, Cs: CoinSelectionAlgorithm> TxBuilderSpacesUtils<'a, Cs> for TxBuilder< spend_input .proprietary .insert(SpacesWallet::spaces_signer("tbs"), Vec::new()); - self.add_foreign_utxo(request.space.outpoint, spend_input, 66)?; + self.add_foreign_utxo( + OutPoint { + txid: request.space.txid, + vout: request.space.spaceout.n as u32, + }, + spend_input, + 66, + )?; self.add_recipient( request.recipient.script_pubkey(), request.space.spaceout.value,