Merge branch 'develop' of https://github.com/stacks-network/stacks-core into feat/expand-consensus-test-to-support-pre-nakamoto-epochs

Author: jacinta-stacks

CHANGELOG.md

@@ -10,9 +10,8 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 ### Added
 
 - Added support for new Clarity 4 builtin, `secp256r1-verify?` (not activated until epoch 3.3)
-
-### Added
-
+- Fixed an issue where `event.committed` was always equal to `true` in the block replay RPC endpoint
+- Added `result_hex` and `post_condition_aborted` to the block replay RPC endpoint
 - New `block_proposal_validation_timeout_secs` configuration option in the connection options section, allowing to set the maximum duration a node will spend validating a proposed block.
 
 ### Changed

build.rs

@@ -21,25 +21,6 @@ fn current_git_hash() -> Option<String> {
     None
 }
 
-fn current_git_branch() -> Option<String> {
-    if option_env!("GIT_BRANCH") == None {
-        let commit = Command::new("git")
-            .arg("rev-parse")
-            .arg("--abbrev-ref")
-            .arg("HEAD")
-            .output();
-        if let Ok(commit) = commit {
-            if let Ok(commit) = String::from_utf8(commit.stdout) {
-                return Some(commit);
-            }
-        }
-    } else {
-        return option_env!("GIT_BRANCH").map(String::from);
-    }
-
-    None
-}
-
 fn is_working_tree_clean() -> bool {
     let status = Command::new("git")
         .arg("diff")

docs/rpc/components/examples/block-replay.example.json

@@ -98,6 +98,8 @@
                     }
                 }
             },
+            "result_hex": "0x0703",
+            "post_condition_aborted": false,
             "stx_burned": 0,
             "tx_index": 0,
             "txid": "f14dd7dec56405fd7dac69c3080fb569fae4c49c591f9ad0e5cf5c797add9005"

docs/rpc/components/schemas/block-replay.schema.yaml

@@ -36,7 +36,7 @@ properties:
   state_index_root:
     type: string
     pattern: "^[0-9a-f]{64}$"
-    description: block state index root computed from the MARF (got from the original block) 
+    description: block state index root computed from the MARF (got from the original block)
   timestamp:
     type: integer
   tx_merkle_root:
@@ -67,6 +67,12 @@ properties:
         result:
           type: object
           description: Clarity value representing the transaction result
+        result_hex:
+          type: string
+          description: The transaction's result, encoded as a Clarity hex string
+        post_condition_aborted:
+          type: boolean
+          description: Whether the transaction was aborted by a post-condition
         stx_burned:
           type: integer
           description: number of burned stx

stackslib/src/core/test_util.rs

@@ -104,7 +104,7 @@ pub fn sign_standard_single_sig_tx_anchor_mode_version(
 }
 
 #[allow(clippy::too_many_arguments)]
-pub fn sign_tx_anchor_mode_version(
+pub fn make_unsigned_tx(
     payload: TransactionPayload,
     sender: &StacksPrivateKey,
     payer: Option<&StacksPrivateKey>,
@@ -139,6 +139,32 @@ pub fn sign_tx_anchor_mode_version(
     unsigned_tx.anchor_mode = anchor_mode;
     unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
     unsigned_tx.chain_id = chain_id;
+    unsigned_tx
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn sign_tx_anchor_mode_version(
+    payload: TransactionPayload,
+    sender: &StacksPrivateKey,
+    payer: Option<&StacksPrivateKey>,
+    sender_nonce: u64,
+    payer_nonce: Option<u64>,
+    tx_fee: u64,
+    chain_id: u32,
+    anchor_mode: TransactionAnchorMode,
+    version: TransactionVersion,
+) -> StacksTransaction {
+    let unsigned_tx = make_unsigned_tx(
+        payload,
+        sender,
+        payer,
+        sender_nonce,
+        payer_nonce,
+        tx_fee,
+        chain_id,
+        anchor_mode,
+        version,
+    );
 
     let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
     tx_signer.sign_origin(sender).unwrap();
@@ -178,25 +204,43 @@ pub fn serialize_sign_tx_anchor_mode_version(
     buf
 }
 
-pub fn make_contract_publish_versioned(
+pub fn make_contract_publish_tx(
     sender: &StacksPrivateKey,
     nonce: u64,
     tx_fee: u64,
     chain_id: u32,
     contract_name: &str,
     contract_content: &str,
     version: Option<ClarityVersion>,
-) -> Vec<u8> {
+) -> StacksTransaction {
     let name = ContractName::from(contract_name);
     let code_body = StacksString::from_string(&contract_content.to_string()).unwrap();
 
     let payload =
         TransactionPayload::SmartContract(TransactionSmartContract { name, code_body }, version);
 
-    let tx = sign_standard_single_sig_tx(payload, sender, nonce, tx_fee, chain_id);
-    let mut tx_bytes = vec![];
-    tx.consensus_serialize(&mut tx_bytes).unwrap();
-    tx_bytes
+    sign_standard_single_sig_tx(payload, sender, nonce, tx_fee, chain_id)
+}
+
+pub fn make_contract_publish_versioned(
+    sender: &StacksPrivateKey,
+    nonce: u64,
+    tx_fee: u64,
+    chain_id: u32,
+    contract_name: &str,
+    contract_content: &str,
+    version: Option<ClarityVersion>,
+) -> Vec<u8> {
+    make_contract_publish_tx(
+        sender,
+        nonce,
+        tx_fee,
+        chain_id,
+        contract_name,
+        contract_content,
+        version,
+    )
+    .serialize_to_vec()
 }
 
 pub fn make_contract_publish(
@@ -381,7 +425,7 @@ pub fn make_coinbase(sender: &StacksPrivateKey, nonce: u64, tx_fee: u64, chain_i
 }
 
 #[allow(clippy::too_many_arguments)]
-pub fn make_contract_call(
+pub fn make_contract_call_tx(
     sender: &StacksPrivateKey,
     nonce: u64,
     tx_fee: u64,
@@ -390,7 +434,7 @@ pub fn make_contract_call(
     contract_name: &str,
     function_name: &str,
     function_args: &[Value],
-) -> Vec<u8> {
+) -> StacksTransaction {
     let contract_name = ContractName::from(contract_name);
     let function_name = ClarityName::from(function_name);
 
@@ -401,10 +445,31 @@ pub fn make_contract_call(
         function_args: function_args.to_vec(),
     };
 
-    let tx = sign_standard_single_sig_tx(payload.into(), sender, nonce, tx_fee, chain_id);
-    let mut tx_bytes = vec![];
-    tx.consensus_serialize(&mut tx_bytes).unwrap();
-    tx_bytes
+    sign_standard_single_sig_tx(payload.into(), sender, nonce, tx_fee, chain_id)
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn make_contract_call(
+    sender: &StacksPrivateKey,
+    nonce: u64,
+    tx_fee: u64,
+    chain_id: u32,
+    contract_addr: &StacksAddress,
+    contract_name: &str,
+    function_name: &str,
+    function_args: &[Value],
+) -> Vec<u8> {
+    make_contract_call_tx(
+        sender,
+        nonce,
+        tx_fee,
+        chain_id,
+        contract_addr,
+        contract_name,
+        function_name,
+        function_args,
+    )
+    .serialize_to_vec()
 }
 
 #[allow(clippy::too_many_arguments)]

stackslib/src/lib.rs

@@ -44,7 +44,9 @@ extern crate stacks_common;
 #[macro_use]
 pub extern crate clarity;
 
-use stacks_common::versions::{GIT_BRANCH, GIT_COMMIT, GIT_TREE_CLEAN, STACKS_NODE_VERSION};
+use std::env::consts::{ARCH, OS};
+
+use stacks_common::versions::{GIT_COMMIT, GIT_TREE_CLEAN, STACKS_NODE_VERSION};
 pub use stacks_common::{address, codec, types, util};
 
 #[macro_use]
@@ -82,19 +84,10 @@ const BUILD_TYPE: &str = "release";
 
 pub fn version_string(pkg_name: &str, pkg_version: Option<&str>) -> String {
     let pkg_version = pkg_version.unwrap_or(STACKS_NODE_VERSION);
-    let git_branch = GIT_BRANCH_ENV.unwrap_or_else(|| GIT_BRANCH.unwrap_or(""));
     let git_commit = GIT_COMMIT_ENV.unwrap_or_else(|| GIT_COMMIT.unwrap_or(""));
     let git_tree_clean = GIT_TREE_CLEAN_ENV.unwrap_or_else(|| GIT_TREE_CLEAN.unwrap_or(""));
 
     format!(
-        "{} {} ({}:{}{}, {} build, {} [{}])",
-        pkg_name,
-        pkg_version,
-        git_branch,
-        git_commit,
-        git_tree_clean,
-        BUILD_TYPE,
-        std::env::consts::OS,
-        std::env::consts::ARCH
+        "{pkg_name} {pkg_version} ({git_commit}{git_tree_clean}, {BUILD_TYPE} build, {OS} [{ARCH}])"
     )
 }

stackslib/src/net/api/blockreplay.rs

@@ -21,6 +21,7 @@ use stacks_common::types::chainstate::{BlockHeaderHash, ConsensusHash, StacksBlo
 use stacks_common::types::net::PeerHost;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::util::secp256k1::MessageSignature;
+use stacks_common::util::serde_serializers::prefix_hex_codec;
 
 use crate::burnchains::Txid;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
@@ -215,12 +216,17 @@ pub struct RPCReplayedBlockTransaction {
     pub hex: String,
     /// result of transaction execution (clarity value)
     pub result: Value,
+    /// result of the transaction execution (hex string)
+    #[serde(with = "prefix_hex_codec")]
+    pub result_hex: Value,
     /// amount of burned stx
     pub stx_burned: u128,
     /// execution cost infos
     pub execution_cost: ExecutionCost,
     /// generated events
     pub events: Vec<serde_json::Value>,
+    /// Whether the tx was aborted by a post-condition
+    pub post_condition_aborted: bool,
     /// optional vm error
     pub vm_error: Option<String>,
 }
@@ -233,7 +239,11 @@ impl RPCReplayedBlockTransaction {
             .enumerate()
             .map(|(event_index, event)| {
                 event
-                    .json_serialize(event_index, &receipt.transaction.txid(), true)
+                    .json_serialize(
+                        event_index,
+                        &receipt.transaction.txid(),
+                        !receipt.post_condition_aborted,
+                    )
                     .unwrap()
             })
             .collect();
@@ -251,9 +261,11 @@ impl RPCReplayedBlockTransaction {
             data: transaction_data,
             hex: receipt.transaction.serialize_to_dbstring(),
             result: receipt.result.clone(),
+            result_hex: receipt.result.clone(),
             stx_burned: receipt.stx_burned,
             execution_cost: receipt.execution_cost.clone(),
             events,
+            post_condition_aborted: receipt.post_condition_aborted,
             vm_error: receipt.vm_error.clone(),
         }
     }