use prefix_hex for ser/deser

* simplify multiple_miners_empty_sortition and single_miner_empty_sortition tests

Author: kantai

libsigner/src/events.rs

@@ -29,6 +29,7 @@ use blockstack_lib::chainstate::stacks::StacksTransaction;
 use blockstack_lib::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, ValidateRejectCode,
 };
+use blockstack_lib::net::api::{prefix_hex, prefix_opt_hex};
 use blockstack_lib::net::stackerdb::MINER_SLOT_COUNT;
 use blockstack_lib::util_lib::boot::boot_code_id;
 use blockstack_lib::version_string;
@@ -215,8 +216,9 @@ pub enum SignerEvent<T: SignerEventTrait> {
         /// The consensus hash of the block (either the tenure it was produced during for Stacks 3.0
         ///   or the burn block that won the sortition in Stacks 2.0)
         consensus_hash: ConsensusHash,
-        /// The signer sighash for the newly processed stacks block
-        signer_sighash: Sha512Trunc256Sum,
+        /// The signer sighash for the newly processed stacks block. If the newly processed block is a 2.0
+        ///  block, there is *no* signer sighash
+        signer_sighash: Option<Sha512Trunc256Sum>,
         /// The block height for the newly processed stacks block
         block_height: u64,
     },
@@ -559,86 +561,50 @@ impl<T: SignerEventTrait> TryFrom<BlockValidateResponse> for SignerEvent<T> {
 
 #[derive(Debug, Deserialize)]
 struct BurnBlockEvent {
-    burn_block_hash: String,
+    #[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,
-    consensus_hash: String,
+    #[serde(with = "prefix_hex")]
+    consensus_hash: ConsensusHash,
 }
 
 impl<T: SignerEventTrait> TryFrom<BurnBlockEvent> for SignerEvent<T> {
     type Error = EventError;
 
     fn try_from(burn_block_event: BurnBlockEvent) -> Result<Self, Self::Error> {
-        let burn_header_hash = burn_block_event
-            .burn_block_hash
-            .get(2..)
-            .ok_or_else(|| EventError::Deserialize("Hex string should be 0x prefixed".into()))
-            .and_then(|hex| {
-                BurnchainHeaderHash::from_hex(hex)
-                    .map_err(|e| EventError::Deserialize(format!("Invalid hex string: {e}")))
-            })?;
-
-        let consensus_hash = burn_block_event
-            .consensus_hash
-            .get(2..)
-            .ok_or_else(|| EventError::Deserialize("Hex string should be 0x prefixed".into()))
-            .and_then(|hex| {
-                ConsensusHash::from_hex(hex)
-                    .map_err(|e| EventError::Deserialize(format!("Invalid hex string: {e}")))
-            })?;
-
         Ok(SignerEvent::NewBurnBlock {
             burn_height: burn_block_event.burn_block_height,
             received_time: SystemTime::now(),
-            burn_header_hash,
-            consensus_hash,
+            burn_header_hash: burn_block_event.burn_block_hash,
+            consensus_hash: burn_block_event.consensus_hash,
         })
     }
 }
 
 #[derive(Debug, Deserialize)]
 struct BlockEvent {
-    index_block_hash: String,
-    signer_signature_hash: String,
-    consensus_hash: String,
+    #[serde(with = "prefix_hex")]
+    index_block_hash: StacksBlockId,
+    #[serde(with = "prefix_opt_hex")]
+    signer_signature_hash: Option<Sha512Trunc256Sum>,
+    #[serde(with = "prefix_hex")]
+    consensus_hash: ConsensusHash,
+    #[serde(with = "prefix_hex")]
+    block_hash: BlockHeaderHash,
     block_height: u64,
 }
 
 impl<T: SignerEventTrait> TryFrom<BlockEvent> for SignerEvent<T> {
     type Error = EventError;
 
     fn try_from(block_event: BlockEvent) -> Result<Self, Self::Error> {
-        let signer_sighash = block_event
-            .signer_signature_hash
-            .get(2..)
-            .ok_or_else(|| EventError::Deserialize("Hex string should be 0x prefixed".into()))
-            .and_then(|hex| {
-                Sha512Trunc256Sum::from_hex(hex)
-                    .map_err(|e| EventError::Deserialize(format!("Invalid hex string: {e}")))
-            })?;
-        let consensus_hash = block_event
-            .consensus_hash
-            .get(2..)
-            .ok_or_else(|| EventError::Deserialize("Hex string should be 0x prefixed".into()))
-            .and_then(|hex| {
-                ConsensusHash::from_hex(hex)
-                    .map_err(|e| EventError::Deserialize(format!("Invalid hex string: {e}")))
-            })?;
-        let block_id = block_event
-            .index_block_hash
-            .get(2..)
-            .ok_or_else(|| EventError::Deserialize("Hex string should be 0x prefixed".into()))
-            .and_then(|hex| {
-                StacksBlockId::from_hex(hex)
-                    .map_err(|e| EventError::Deserialize(format!("Invalid hex string: {e}")))
-            })?;
-
         Ok(SignerEvent::NewBlock {
-            block_id,
-            signer_sighash,
-            consensus_hash,
+            signer_sighash: block_event.signer_signature_hash,
+            block_id: block_event.index_block_hash,
+            consensus_hash: block_event.consensus_hash,
             block_height: block_event.block_height,
         })
     }

stacks-signer/src/v0/signer.rs

@@ -341,6 +341,10 @@ impl SignerTrait<SignerMessage> for Signer {
                 consensus_hash,
                 signer_sighash,
             } => {
+                let Some(signer_sighash) = signer_sighash else {
+                    debug!("{self}: received a new block event for a pre-nakamoto block, no processing necessary");
+                    return;
+                };
                 debug!(
                     "{self}: Received a new block event.";
                     "block_id" => %block_id,

stackslib/src/net/api/mod.rs

@@ -20,7 +20,7 @@ use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, SortitionId, StacksBlockId,
 };
-use stacks_common::util::hash::Hash160;
+use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
 use stacks_common::util::HexError;
 
 use crate::burnchains::Txid;
@@ -244,3 +244,4 @@ impl_hex_deser!(VRFSeed);
 impl_hex_deser!(ConsensusHash);
 impl_hex_deser!(BlockHeaderHash);
 impl_hex_deser!(Hash160);
+impl_hex_deser!(Sha512Trunc256Sum);

testnet/stacks-node/src/tests/signer/mod.rs

@@ -50,11 +50,11 @@ use stacks_signer::runloop::{SignerResult, State, StateInfo};
 use stacks_signer::v0::signer_state::{LocalStateMachine, MinerState};
 use stacks_signer::{Signer, SpawnedSigner};
 
-use super::make_stacks_transfer;
 use super::nakamoto_integrations::{
     check_nakamoto_empty_block_heuristics, next_block_and, wait_for,
 };
 use super::neon_integrations::{get_account, get_sortition_info_ch, submit_tx_fallible};
+use super::{make_contract_call, make_contract_publish, make_stacks_transfer};
 use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
@@ -448,6 +448,65 @@ impl<S: Signer<T> + Send + 'static, T: SignerEventTrait + 'static> SignerTest<Sp
         submit_tx_fallible(&http_origin, &transfer_tx).map(|resp| (resp, sender_nonce))
     }
 
+    /// Submit a burn block dependent contract for publishing
+    ///  and wait until it is included in a block
+    pub fn submit_burn_block_contract_and_wait(
+        &mut self,
+        sender_sk: &StacksPrivateKey,
+    ) -> Result<String, String> {
+        let http_origin = format!("http://{}", &self.running_nodes.conf.node.rpc_bind);
+        let sender_addr = to_addr(&sender_sk);
+        let sender_nonce = get_account(&http_origin, &sender_addr).nonce;
+        let burn_height_contract = "
+         (define-data-var local-burn-block-ht uint u0)
+         (define-public (run-update)
+           (ok (var-set local-burn-block-ht burn-block-height)))
+        ";
+        let contract_tx = make_contract_publish(
+            &sender_sk,
+            0,
+            1000,
+            self.running_nodes.conf.burnchain.chain_id,
+            "burn-height-local",
+            burn_height_contract,
+        );
+        let txid = submit_tx_fallible(&http_origin, &contract_tx)?;
+
+        wait_for(120, || {
+            let next_nonce = get_account(&http_origin, &sender_addr).nonce;
+            Ok(next_nonce > sender_nonce)
+        })
+        .map(|()| txid)
+    }
+
+    /// Submit a burn block dependent contract-call
+    ///  and wait until it is included in a block
+    pub fn submit_burn_block_call_and_wait(
+        &mut self,
+        sender_sk: &StacksPrivateKey,
+    ) -> Result<String, String> {
+        let http_origin = format!("http://{}", &self.running_nodes.conf.node.rpc_bind);
+        let sender_addr = to_addr(&sender_sk);
+        let sender_nonce = get_account(&http_origin, &sender_addr).nonce;
+        let contract_call_tx = make_contract_call(
+            &sender_sk,
+            sender_nonce,
+            1000,
+            self.running_nodes.conf.burnchain.chain_id,
+            &sender_addr,
+            "burn-height-local",
+            "run-update",
+            &[],
+        );
+        let txid = submit_tx_fallible(&http_origin, &contract_call_tx)?;
+
+        wait_for(120, || {
+            let next_nonce = get_account(&http_origin, &sender_addr).nonce;
+            Ok(next_nonce > sender_nonce)
+        })
+        .map(|()| txid)
+    }
+
     /// Get the local state machines and most recent peer info from the stacks-node,
     ///  waiting until all of the signers have updated their state machines to
     ///  reflect the most recent burn block.