Merge pull request #6109 from hstove/feat/full-tx-replay

feat: validate blocks against replay set

Author: hstove

libsigner/src/events.rs

@@ -45,8 +45,8 @@ pub use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, SortitionId, StacksPublicKey,
 };
-use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
-use stacks_common::util::serde_serializers::{prefix_hex, prefix_opt_hex};
+use stacks_common::util::hash::{hex_bytes, Hash160, Sha512Trunc256Sum};
+use stacks_common::util::serde_serializers::{prefix_hex, prefix_opt_hex, prefix_string_0x};
 use stacks_common::util::HexError;
 use stacks_common::versions::STACKS_NODE_VERSION;
 use tiny_http::{
@@ -229,6 +229,8 @@ pub enum SignerEvent<T: SignerEventTrait> {
         signer_sighash: Option<Sha512Trunc256Sum>,
         /// The block height for the newly processed stacks block
         block_height: u64,
+        /// The transactions included in the block
+        transactions: Vec<StacksTransaction>,
     },
 }
 
@@ -577,18 +579,26 @@ impl<T: SignerEventTrait> TryFrom<BlockValidateResponse> for SignerEvent<T> {
     }
 }
 
-#[derive(Debug, Deserialize)]
-struct BurnBlockEvent {
+/// Burn block JSON payload from the event receiver
+#[derive(Debug, Deserialize, Clone)]
+pub struct BurnBlockEvent {
+    /// The hash of the burn block
     #[serde(with = "prefix_hex")]
-    burn_block_hash: BurnchainHeaderHash,
-    burn_block_height: u64,
-    reward_recipients: Vec<serde_json::Value>,
-    reward_slot_holders: Vec<String>,
-    burn_amount: u64,
+    pub burn_block_hash: BurnchainHeaderHash,
+    /// The height of the burn block
+    pub burn_block_height: u64,
+    /// The reward recipients
+    pub reward_recipients: Vec<serde_json::Value>,
+    /// The reward slot holders
+    pub reward_slot_holders: Vec<String>,
+    /// The amount of burn
+    pub burn_amount: u64,
+    /// The consensus hash of the burn block
     #[serde(with = "prefix_hex")]
-    consensus_hash: ConsensusHash,
+    pub consensus_hash: ConsensusHash,
+    /// The parent burn block hash
     #[serde(with = "prefix_hex")]
-    parent_burn_block_hash: BurnchainHeaderHash,
+    pub parent_burn_block_hash: BurnchainHeaderHash,
 }
 
 impl<T: SignerEventTrait> TryFrom<BurnBlockEvent> for SignerEvent<T> {
@@ -605,6 +615,45 @@ impl<T: SignerEventTrait> TryFrom<BurnBlockEvent> for SignerEvent<T> {
     }
 }
 
+/// A subset of `TransactionEventPayload`, received from the event
+/// dispatcher.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct NewBlockTransaction {
+    /// The raw transaction bytes. If this is a burn operation,
+    /// this will be "00".
+    #[serde(with = "prefix_string_0x")]
+    raw_tx: String,
+}
+
+impl NewBlockTransaction {
+    pub fn get_stacks_transaction(&self) -> Result<Option<StacksTransaction>, CodecError> {
+        if self.raw_tx == "00" {
+            Ok(None)
+        } else {
+            let tx_bytes = hex_bytes(&self.raw_tx).map_err(|e| {
+                CodecError::DeserializeError(format!("Failed to deserialize raw tx: {}", e))
+            })?;
+            let tx = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..])?;
+            Ok(Some(tx))
+        }
+    }
+}
+
+/// "Special" deserializer to turn `{ tx_raw: "0x..." }` into `StacksTransaction`.
+fn deserialize_raw_tx_hex<'de, D: serde::Deserializer<'de>>(
+    d: D,
+) -> Result<Vec<StacksTransaction>, D::Error> {
+    let tx_objs: Vec<NewBlockTransaction> = serde::Deserialize::deserialize(d)?;
+    Ok(tx_objs
+        .iter()
+        .map(|tx| tx.get_stacks_transaction())
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(serde::de::Error::custom)?
+        .into_iter()
+        .flatten()
+        .collect::<Vec<_>>())
+}
+
 #[derive(Debug, Deserialize)]
 struct BlockEvent {
     #[serde(with = "prefix_hex")]
@@ -617,6 +666,8 @@ struct BlockEvent {
     #[serde(with = "prefix_hex")]
     block_hash: BlockHeaderHash,
     block_height: u64,
+    #[serde(deserialize_with = "deserialize_raw_tx_hex")]
+    transactions: Vec<StacksTransaction>,
 }
 
 impl<T: SignerEventTrait> TryFrom<BlockEvent> for SignerEvent<T> {
@@ -628,6 +679,7 @@ impl<T: SignerEventTrait> TryFrom<BlockEvent> for SignerEvent<T> {
             block_id: block_event.index_block_hash,
             consensus_hash: block_event.consensus_hash,
             block_height: block_event.block_height,
+            transactions: block_event.transactions,
         })
     }
 }

libsigner/src/libsigner.rs

@@ -57,8 +57,8 @@ use stacks_common::versions::STACKS_SIGNER_VERSION;
 
 pub use crate::error::{EventError, RPCError};
 pub use crate::events::{
-    BlockProposal, BlockProposalData, EventReceiver, EventStopSignaler, SignerEvent,
-    SignerEventReceiver, SignerEventTrait, SignerStopSignaler,
+    BlockProposal, BlockProposalData, BurnBlockEvent, EventReceiver, EventStopSignaler,
+    SignerEvent, SignerEventReceiver, SignerEventTrait, SignerStopSignaler,
 };
 pub use crate::runloop::{RunningSigner, Signer, SignerRunLoop};
 pub use crate::session::{SignerSession, StackerDBSession};

libsigner/src/tests/signer_state.rs

@@ -24,7 +24,7 @@ use crate::v0::messages::{
     StateMachineUpdate as StateMachineUpdateMessage, StateMachineUpdateContent,
     StateMachineUpdateMinerState,
 };
-use crate::v0::signer_state::{GlobalStateEvaluator, SignerStateMachine};
+use crate::v0::signer_state::{GlobalStateEvaluator, ReplayTransactionSet, SignerStateMachine};
 
 fn generate_global_state_evaluator(num_addresses: u32) -> GlobalStateEvaluator {
     let address_weights = generate_random_address_with_equal_weights(num_addresses);
@@ -237,7 +237,7 @@ fn determine_global_states() {
         burn_block_height,
         current_miner: (&current_miner).into(),
         active_signer_protocol_version: local_supported_signer_protocol_version, // a majority of signers are saying they support version the same local_supported_signer_protocol_version, so update it here...
-        tx_replay_set: None,
+        tx_replay_set: ReplayTransactionSet::none(),
     };
 
     global_eval.insert_update(local_address, local_update);
@@ -276,7 +276,7 @@ fn determine_global_states() {
         burn_block_height,
         current_miner: (&new_miner).into(),
         active_signer_protocol_version: local_supported_signer_protocol_version, // a majority of signers are saying they support version the same local_supported_signer_protocol_version, so update it here...
-        tx_replay_set: None,
+        tx_replay_set: ReplayTransactionSet::none(),
     };
 
     global_eval.insert_update(local_address, new_update);

libsigner/src/v0/signer_state.rs

@@ -132,7 +132,12 @@ impl GlobalStateEvaluator {
                         burn_block_height,
                         current_miner,
                         ..
-                    } => (burn_block, burn_block_height, current_miner, None),
+                    } => (
+                        burn_block,
+                        burn_block_height,
+                        current_miner,
+                        ReplayTransactionSet::none(),
+                    ),
                     StateMachineUpdateContent::V1 {
                         burn_block,
                         burn_block_height,
@@ -142,7 +147,7 @@ impl GlobalStateEvaluator {
                         burn_block,
                         burn_block_height,
                         current_miner,
-                        Some(replay_transactions.clone()),
+                        ReplayTransactionSet::new(replay_transactions.clone()),
                     ),
                 };
             let state_machine = SignerStateMachine {
@@ -177,6 +182,77 @@ impl GlobalStateEvaluator {
     pub fn reached_agreement(&self, vote_weight: u32) -> bool {
         vote_weight >= self.total_weight * 7 / 10
     }
+
+    /// Get the global transaction replay set. Returns `None` if there
+    /// is no global state.
+    pub fn get_global_tx_replay_set(&mut self) -> Option<ReplayTransactionSet> {
+        let global_state = self.determine_global_state()?;
+        Some(global_state.tx_replay_set)
+    }
+}
+
+/// A "wrapper" struct around Vec<StacksTransaction> that behaves like
+/// `None` when the vector is empty.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Eq, Hash)]
+pub struct ReplayTransactionSet(Vec<StacksTransaction>);
+
+impl ReplayTransactionSet {
+    /// Create a new `ReplayTransactionSet`
+    pub fn new(tx_replay_set: Vec<StacksTransaction>) -> Self {
+        Self(tx_replay_set)
+    }
+
+    /// Check if the `ReplayTransactionSet` is empty
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Map into an optional, returning `None` if the set is empty
+    pub fn clone_as_optional(&self) -> Option<Vec<StacksTransaction>> {
+        if self.is_empty() {
+            None
+        } else {
+            Some(self.0.clone())
+        }
+    }
+
+    /// Unwrap the `ReplayTransactionSet` or return a default vector if it is empty
+    pub fn unwrap_or_default(self) -> Vec<StacksTransaction> {
+        if self.is_empty() {
+            vec![]
+        } else {
+            self.0
+        }
+    }
+
+    /// Map the transactions in the set to a new type, only
+    /// if the set is not empty
+    pub fn map<U, F>(self, f: F) -> Option<U>
+    where
+        F: Fn(Vec<StacksTransaction>) -> U,
+    {
+        if self.is_empty() {
+            None
+        } else {
+            Some(f(self.0))
+        }
+    }
+
+    /// Create a new `ReplayTransactionSet` with no transactions
+    pub fn none() -> Self {
+        Self(vec![])
+    }
+
+    /// Check if the `ReplayTransactionSet` isn't empty
+    pub fn is_some(&self) -> bool {
+        !self.is_empty()
+    }
+}
+
+impl Default for ReplayTransactionSet {
+    fn default() -> Self {
+        Self::none()
+    }
 }
 
 /// A signer state machine view. This struct can
@@ -193,7 +269,7 @@ pub struct SignerStateMachine {
     /// The active signing protocol version
     pub active_signer_protocol_version: u64,
     /// Transaction replay set
-    pub tx_replay_set: Option<Vec<StacksTransaction>>,
+    pub tx_replay_set: ReplayTransactionSet,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Eq, Hash)]

stacks-signer/src/client/mod.rs

@@ -431,6 +431,7 @@ pub(crate) mod tests {
             block_proposal_max_age_secs: config.block_proposal_max_age_secs,
             reorg_attempts_activity_timeout: config.reorg_attempts_activity_timeout,
             proposal_wait_for_parent_time: config.proposal_wait_for_parent_time,
+            validate_with_replay_tx: config.validate_with_replay_tx,
         }
     }
 

stacks-signer/src/client/stacks_client.rs

@@ -18,7 +18,7 @@ use std::collections::{HashMap, VecDeque};
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::{NakamotoSignerEntry, SIGNERS_NAME};
 use blockstack_lib::chainstate::stacks::db::StacksBlockHeaderTypes;
-use blockstack_lib::chainstate::stacks::TransactionVersion;
+use blockstack_lib::chainstate::stacks::{StacksTransaction, TransactionVersion};
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
 use blockstack_lib::net::api::get_tenures_fork_info::{
     TenureForkingInfo, RPC_TENURE_FORKING_INFO_PATH,
@@ -302,7 +302,11 @@ impl StacksClient {
     }
 
     /// Submit the block proposal to the stacks node. The block will be validated and returned via the HTTP endpoint for Block events.
-    pub fn submit_block_for_validation(&self, block: NakamotoBlock) -> Result<(), ClientError> {
+    pub fn submit_block_for_validation(
+        &self,
+        block: NakamotoBlock,
+        replay_txs: Option<Vec<StacksTransaction>>,
+    ) -> Result<(), ClientError> {
         debug!("StacksClient: Submitting block for validation";
             "signer_signature_hash" => %block.header.signer_signature_hash(),
             "block_id" => %block.header.block_id(),
@@ -311,7 +315,7 @@ impl StacksClient {
         let block_proposal = NakamotoBlockProposal {
             block,
             chain_id: self.chain_id,
-            replay_txs: None,
+            replay_txs,
         };
         let timer = crate::monitoring::actions::new_rpc_call_timer(
             &self.block_proposal_path(),
@@ -1094,7 +1098,7 @@ mod tests {
             header,
             txs: vec![],
         };
-        let h = spawn(move || mock.client.submit_block_for_validation(block));
+        let h = spawn(move || mock.client.submit_block_for_validation(block, None));
         write_response(mock.server, b"HTTP/1.1 200 OK\n\n");
         assert!(h.join().unwrap().is_ok());
     }
@@ -1107,7 +1111,7 @@ mod tests {
             header,
             txs: vec![],
         };
-        let h = spawn(move || mock.client.submit_block_for_validation(block));
+        let h = spawn(move || mock.client.submit_block_for_validation(block, None));
         write_response(mock.server, b"HTTP/1.1 404 Not Found\n\n");
         assert!(h.join().unwrap().is_err());
     }