Merge branch 'develop' into feat/non-blocking-event-delivery

Author: benjamin-stacks

CHANGELOG.md

@@ -17,6 +17,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 ### Added
 
 - In the `/v3/transaction/{txid}` RPC endpoint, added `block_height` and `is_canonical` to the response.
+- New endpoint `/v3/blocks/simulate/{block_id}` allows to simulate the execution of a specific block with a brand new set of transactions
 - Improved block validation in `stacks-inspect`.
 - Allow non-blocking event dispatching. This is off by default, but can be enabled in the node configuration.
 

docs/rpc/openapi.yaml

@@ -2415,3 +2415,62 @@ paths:
           $ref: "#/components/responses/NotFound"
         "500":
           $ref: "#/components/responses/InternalServerError"
+
+  /v3/blocks/simulate/{block_id}:
+    get:
+      summary: Simulate mining of a block with the specified transactions and returns its content
+      tags:
+        - Blocks
+      security:
+        - rpcAuth: []
+      operationId: blockSimulate
+      description: |
+        Simulate the mining of a block (no data is written in the MARF) with specified transactions and returns its content.
+      parameters:
+        - name: block_id
+          in: path
+          description: The block ID hash
+          required: true
+          schema:
+            type: string
+            pattern: "^[0-9a-f]{64}$"
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                transactions_hex:
+                  type: array
+                  items:
+                    type: string
+                    description: SIP-003-encoded Transaction in hex format
+                mint:
+                  type: array
+                  items:
+                    type: object
+                    properties:
+                      principal:
+                        type: string
+                        description: Principal address receiving STX
+                      amount:
+                        type: integer
+                        description: amount of microSTX to mint for the block simulation
+      responses:
+        "200":
+          description: Content of the simulated block
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/BlockReplay"
+              example:
+                $ref: "./components/examples/block-replay.example.json"
+        "400":
+          $ref: "#/components/responses/BadRequest"
+        "401":
+          $ref: "#/components/responses/Unauthorized"
+        "404":
+          $ref: "#/components/responses/NotFound"
+        "500":
+          $ref: "#/components/responses/InternalServerError"

libsigner/src/events.rs

@@ -24,7 +24,7 @@ use std::time::SystemTime;
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
-use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
+use blockstack_lib::chainstate::stacks::events::{BurnBlockEvent, StackerDBChunksEvent};
 use blockstack_lib::chainstate::stacks::StacksTransaction;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use blockstack_lib::version_string;
@@ -568,28 +568,6 @@ impl<T: SignerEventTrait> TryFrom<BlockValidateResponse> for SignerEvent<T> {
     }
 }
 
-/// 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")]
-    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")]
-    pub consensus_hash: ConsensusHash,
-    /// The parent burn block hash
-    #[serde(with = "prefix_hex")]
-    pub parent_burn_block_hash: BurnchainHeaderHash,
-}
-
 impl<T: SignerEventTrait> TryFrom<BurnBlockEvent> for SignerEvent<T> {
     type Error = EventError;
 

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, BurnBlockEvent, EventReceiver, EventStopSignaler,
-    SignerEvent, SignerEventReceiver, SignerEventTrait, SignerStopSignaler, StacksBlockEvent,
+    BlockProposal, BlockProposalData, EventReceiver, EventStopSignaler, SignerEvent,
+    SignerEventReceiver, SignerEventTrait, SignerStopSignaler, StacksBlockEvent,
 };
 pub use crate::runloop::{RunningSigner, Signer, SignerRunLoop};
 pub use crate::session::{SignerSession, StackerDBSession};

stacks-node/src/event_dispatcher.rs

@@ -32,7 +32,7 @@ use lazy_static::lazy_static;
 use serde_json::json;
 use stacks::burnchains::{PoxConstants, Txid};
 use stacks::chainstate::burn::ConsensusHash;
-use stacks::chainstate::coordinator::BlockEventDispatcher;
+use stacks::chainstate::coordinator::{BlockEventDispatcher, PoxTransactionReward};
 use stacks::chainstate::nakamoto::NakamotoBlock;
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::boot::RewardSetData;
@@ -370,6 +370,7 @@ impl BlockEventDispatcher for EventDispatcher {
         burn_block_height: u64,
         rewards: Vec<(PoxAddress, u64)>,
         burns: u64,
+        pox_transactions: Vec<PoxTransactionReward>,
         recipient_info: Vec<PoxAddress>,
         consensus_hash: &ConsensusHash,
         parent_burn_block_hash: &BurnchainHeaderHash,
@@ -379,6 +380,7 @@ impl BlockEventDispatcher for EventDispatcher {
             burn_block_height,
             rewards,
             burns,
+            pox_transactions,
             recipient_info,
             consensus_hash,
             parent_burn_block_hash,
@@ -478,6 +480,7 @@ impl EventDispatcher {
         burn_block_height: u64,
         rewards: Vec<(PoxAddress, u64)>,
         burns: u64,
+        pox_transactions: Vec<PoxTransactionReward>,
         recipient_info: Vec<PoxAddress>,
         consensus_hash: &ConsensusHash,
         parent_burn_block_hash: &BurnchainHeaderHash,
@@ -493,6 +496,7 @@ impl EventDispatcher {
             burn_block_height,
             rewards,
             burns,
+            pox_transactions,
             recipient_info,
             consensus_hash,
             parent_burn_block_hash,

stacks-node/src/event_dispatcher/payloads.rs

@@ -26,13 +26,15 @@ use stacks::chainstate::burn::operations::{
     BlockstackOperationType,
 };
 use stacks::chainstate::burn::ConsensusHash;
+use stacks::chainstate::coordinator::PoxTransactionReward;
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::boot::{
     NakamotoSignerEntry, PoxStartCycleInfo, RewardSet, RewardSetData,
 };
 use stacks::chainstate::stacks::db::{StacksBlockHeaderTypes, StacksHeaderInfo};
 use stacks::chainstate::stacks::events::{
-    StacksBlockEventData, StacksTransactionEvent, StacksTransactionReceipt, TransactionOrigin,
+    BurnBlockEvent, BurnBlockEventRewardRecipient, StacksBlockEventData, StacksTransactionEvent,
+    StacksTransactionReceipt, TransactionOrigin,
 };
 use stacks::chainstate::stacks::miner::TransactionEvent;
 use stacks::chainstate::stacks::{StacksTransaction, TransactionPayload};
@@ -208,34 +210,28 @@ pub fn make_new_burn_block_payload(
     burn_block_height: u64,
     rewards: Vec<(PoxAddress, u64)>,
     burns: u64,
+    pox_transactions: Vec<PoxTransactionReward>,
     slot_holders: Vec<PoxAddress>,
     consensus_hash: &ConsensusHash,
     parent_burn_block_hash: &BurnchainHeaderHash,
 ) -> serde_json::Value {
-    let reward_recipients = rewards
-        .into_iter()
-        .map(|(pox_addr, amt)| {
-            json!({
-                "recipient": pox_addr.to_b58(),
-                "amt": amt,
+    serde_json::to_value(BurnBlockEvent {
+        burn_block_hash: burn_block.clone(),
+        burn_block_height,
+        reward_recipients: rewards
+            .into_iter()
+            .map(|(pox_addr, amt)| BurnBlockEventRewardRecipient {
+                recipient: pox_addr.clone(),
+                amt,
             })
-        })
-        .collect();
-
-    let reward_slot_holders = slot_holders
-        .into_iter()
-        .map(|pox_addr| json!(pox_addr.to_b58()))
-        .collect();
-
-    json!({
-        "burn_block_hash": format!("0x{burn_block}"),
-        "burn_block_height": burn_block_height,
-        "reward_recipients": serde_json::Value::Array(reward_recipients),
-        "reward_slot_holders": serde_json::Value::Array(reward_slot_holders),
-        "burn_amount": burns,
-        "consensus_hash": format!("0x{consensus_hash}"),
-        "parent_burn_block_hash": format!("0x{parent_burn_block_hash}"),
+            .collect(),
+        reward_slot_holders: slot_holders,
+        burn_amount: burns,
+        consensus_hash: consensus_hash.clone(),
+        parent_burn_block_hash: parent_burn_block_hash.clone(),
+        pox_transactions,
     })
+    .expect("FATAL: Failed to serialized burn block payload")
 }
 
 const STATUS_RESP_TRUE: &str = "success";

stacks-node/src/tests/epoch_21.rs

@@ -1675,16 +1675,7 @@ fn transition_removes_pox_sunset() {
         let recipients: Vec<(String, u64)> = block
             .reward_recipients
             .iter()
-            .map(|value| {
-                let recipient: String = value
-                    .get("recipient")
-                    .unwrap()
-                    .as_str()
-                    .unwrap()
-                    .to_string();
-                let amount = value.get("amt").unwrap().as_u64().unwrap();
-                (recipient, amount)
-            })
+            .map(|value| (value.recipient.clone().to_b58(), value.amt))
             .collect();
 
         if (i as u64) < (sunset_start_rc * reward_cycle_len) {

stacks-node/src/tests/nakamoto_integrations.rs

@@ -11406,7 +11406,7 @@ fn reload_miner_config() {
     let reward_amount = burn_block
         .reward_recipients
         .iter()
-        .map(|r| r.get("amt").unwrap().as_u64().unwrap())
+        .map(|r| r.amt)
         .sum::<u64>();
 
     let burn_amount = burn_block.burn_amount;
@@ -11431,7 +11431,7 @@ fn reload_miner_config() {
     let reward_amount = burn_block
         .reward_recipients
         .iter()
-        .map(|r| r.get("amt").unwrap().as_u64().unwrap())
+        .map(|r| r.amt)
         .sum::<u64>();
 
     let burn_amount = burn_block.burn_amount;

stacks-node/src/tests/neon_integrations.rs

@@ -296,9 +296,8 @@ pub mod test_observer {
     use std::sync::Mutex;
     use std::thread;
 
-    use libsigner::BurnBlockEvent;
     use stacks::chainstate::stacks::boot::RewardSet;
-    use stacks::chainstate::stacks::events::StackerDBChunksEvent;
+    use stacks::chainstate::stacks::events::{BurnBlockEvent, StackerDBChunksEvent};
     use stacks::chainstate::stacks::StacksTransaction;
     use stacks::codec::StacksMessageCodec;
     use stacks::config::{EventKeyType, EventObserverConfig};
@@ -5649,10 +5648,10 @@ fn pox_integration_test() {
 
     for block in burn_blocks.iter() {
         for holder in block.reward_slot_holders.iter() {
-            if let Some(current) = recipient_slots.get_mut(holder) {
+            if let Some(current) = recipient_slots.get_mut(&holder.clone().to_b58()) {
                 *current += 1;
             } else {
-                recipient_slots.insert(holder.clone(), 1);
+                recipient_slots.insert(holder.clone().to_b58(), 1);
             }
         }
     }

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

@@ -8143,3 +8143,70 @@ fn signers_treat_signatures_as_precommits() {
     info!("------------------------- Shutdown -------------------------");
     signer_test.shutdown();
 }
+
+#[test]
+#[ignore]
+/// Ensure that the `/new_burn_block` payload includes data on individual PoX transactions.
+fn burn_block_payload_includes_pox_transactions() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+    let mut miners = MultipleMinerTest::new(5, 0);
+
+    let (conf_1, _conf_2) = miners.get_node_configs();
+    miners.boot_to_epoch_3();
+    let sortdb = conf_1.get_burnchain().open_sortition_db(true).unwrap();
+
+    info!("---- Starting test -----");
+
+    miners
+        .mine_bitcoin_blocks_and_confirm(&sortdb, 1, 30)
+        .expect("Failed to mine BTC block.");
+    miners.wait_for_chains(120);
+
+    let burn_blocks = test_observer::get_burn_blocks();
+    let new_burn_block = burn_blocks.last().unwrap();
+
+    info!("New burn block: {new_burn_block:?}";
+        "pox_transactions" => ?new_burn_block.pox_transactions,
+    );
+
+    let pox_transactions = new_burn_block.pox_transactions.clone();
+    assert_eq!(
+        pox_transactions.len(),
+        2,
+        "Expected 1 transaction from each miner"
+    );
+
+    let total_amt = new_burn_block
+        .reward_recipients
+        .iter()
+        .map(|r| r.amt)
+        .sum::<u64>();
+
+    let total_from_transactions = pox_transactions
+        .iter()
+        .map(|t| t.reward_recipients.iter().map(|r| r.amt).sum::<u64>())
+        .sum::<u64>();
+
+    assert_eq!(total_amt, total_from_transactions, "Expected the total sum from `reward_recipients` to match the total sum from `pox_transactions`");
+
+    let total_per_recipient: HashMap<PoxAddress, u64> = new_burn_block
+        .reward_recipients
+        .iter()
+        .map(|r| (r.recipient.clone(), r.amt))
+        .collect();
+
+    let mut total_per_recipient_from_transactions: HashMap<PoxAddress, u64> = HashMap::new();
+
+    for t in pox_transactions.iter() {
+        for r in t.reward_recipients.iter() {
+            total_per_recipient_from_transactions
+                .entry(r.recipient.clone())
+                .and_modify(|amt| *amt += r.amt)
+                .or_insert(r.amt);
+        }
+    }
+
+    assert_eq!(total_per_recipient, total_per_recipient_from_transactions);
+}