feat: use JSON payload for tx replay set

Author: hstove

stacks-signer/src/client/stacks_client.rs

@@ -321,6 +321,7 @@ impl StacksClient {
         let block_proposal = NakamotoBlockProposal {
             block,
             chain_id: self.chain_id,
+            replay_txs: None,
         };
         let timer = crate::monitoring::actions::new_rpc_call_timer(
             &self.block_proposal_path(),

stackslib/src/net/api/postblock_proposal.rs

@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+use std::collections::VecDeque;
 use std::io::{Read, Write};
 #[cfg(any(test, feature = "testing"))]
 use std::sync::LazyLock;
@@ -215,6 +216,8 @@ pub struct NakamotoBlockProposal {
     pub block: NakamotoBlock,
     /// Identifies which chain block is for (Mainnet, Testnet, etc.)
     pub chain_id: u32,
+    /// Optional transaction replay set
+    pub replay_txs: Option<Vec<StacksTransaction>>,
 }
 
 impl NakamotoBlockProposal {
@@ -554,11 +557,8 @@ impl NakamotoBlockProposal {
             builder.load_tenure_info(chainstate, &burn_dbconn, tenure_cause)?;
         let mut tenure_tx = builder.tenure_begin(&burn_dbconn, &mut miner_tenure_info)?;
 
-        // TODO: get replay set from stackerdb
-        #[cfg(any(test, feature = "testing"))]
-        let mut replay_txs_maybe = TEST_REPLAY_TRANSACTIONS.0.lock().unwrap().clone();
-        #[cfg(not(any(test, feature = "testing")))]
-        let mut replay_txs_maybe = None;
+        let mut replay_txs_maybe: Option<VecDeque<StacksTransaction>> =
+            self.replay_txs.clone().map(|txs| txs.into());
 
         for (i, tx) in self.block.txs.iter().enumerate() {
             let tx_len = tx.tx_len();

stackslib/src/net/api/tests/postblock_proposal.rs

@@ -55,6 +55,7 @@ fn test_try_parse_request() {
     let proposal = NakamotoBlockProposal {
         block: block.clone(),
         chain_id: 0x80000000,
+        replay_txs: None,
     };
     let mut request = StacksHttpRequest::new_for_peer(
         addr.into(),
@@ -99,7 +100,8 @@ fn test_try_parse_request() {
         handler.block_proposal,
         Some(NakamotoBlockProposal {
             block,
-            chain_id: 0x80000000
+            chain_id: 0x80000000,
+            replay_txs: None,
         })
     );
 
@@ -299,6 +301,7 @@ fn test_try_make_response() {
     let proposal = NakamotoBlockProposal {
         block: good_block.clone(),
         chain_id: 0x80000000,
+        replay_txs: None,
     };
 
     let mut request = StacksHttpRequest::new_for_peer(
@@ -323,6 +326,7 @@ fn test_try_make_response() {
     let proposal = NakamotoBlockProposal {
         block: early_time_block,
         chain_id: 0x80000000,
+        replay_txs: None,
     };
 
     let mut request = StacksHttpRequest::new_for_peer(
@@ -347,6 +351,7 @@ fn test_try_make_response() {
     let proposal = NakamotoBlockProposal {
         block: late_time_block,
         chain_id: 0x80000000,
+        replay_txs: None,
     };
 
     let mut request = StacksHttpRequest::new_for_peer(
@@ -368,6 +373,7 @@ fn test_try_make_response() {
     let proposal = NakamotoBlockProposal {
         block: stale_block,
         chain_id: 0x80000000,
+        replay_txs: None,
     };
 
     let mut request = StacksHttpRequest::new_for_peer(
@@ -537,28 +543,10 @@ fn replay_validation_test(
         .miner
         .sign_nakamoto_block(&mut proposed_block);
 
-    // post the valid block proposal
-    let proposal = NakamotoBlockProposal {
-        block: proposed_block.clone(),
-        chain_id: 0x80000000,
-    };
-
-    let mut request = StacksHttpRequest::new_for_peer(
-        rpc_test.peer_1.to_peer_host(),
-        "POST".into(),
-        "/v3/block_proposal".into(),
-        HttpRequestContents::new().payload_json(serde_json::to_value(proposal).unwrap()),
-    )
-    .expect("failed to construct request");
-    request.add_header("authorization".into(), "password".into());
-    requests.push(request);
-
-    TEST_REPLAY_TRANSACTIONS.set(expected_replay_txs);
-
-    // Post the block proposal
     let proposal = NakamotoBlockProposal {
         block: proposed_block.clone(),
         chain_id: 0x80000000,
+        replay_txs: Some(expected_replay_txs.into()),
     };
 
     let mut request = StacksHttpRequest::new_for_peer(

testnet/stacks-node/src/tests/nakamoto_integrations.rs

@@ -3097,6 +3097,7 @@ fn block_proposal_api_endpoint() {
     let proposal = NakamotoBlockProposal {
         block,
         chain_id: chainstate.chain_id,
+        replay_txs: None,
     };
 
     const HTTP_ACCEPTED: u16 = 202;