Merge branch 'develop' into chore/3.3.0.0.0_develop

Author: wileyj

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
+## [Unreleased]
+
+### 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
+- 
 ## [3.3.0.0.0]
 
 ### Added

clarity-types/src/errors/cost.rs

@@ -16,16 +16,43 @@ use std::fmt;
 
 use crate::execution_cost::ExecutionCost;
 
+/// Errors related to cost tracking and resource accounting in the Clarity VM.
+///
+/// Each error variant is annotated with "Invalidates Block" status, indicating
+/// whether the inclusion of the transaction that caused the error should cause
+/// an entire block to be rejected.
 #[derive(Debug, PartialEq, Eq)]
 pub enum CostErrors {
-    CostComputationFailed(String),
+    /// Arithmetic overflow in cost computation during type-checking, exceeding the maximum threshold.
+    /// Invalidates Block: true.
     CostOverflow,
+    /// Cumulative type-checking cost exceeds the allocated budget, indicating budget depletion.
+    /// The first `ExecutionCost` represents the total consumed cost, and the second represents the budget limit.
+    /// Invalidates Block: true.
     CostBalanceExceeded(ExecutionCost, ExecutionCost),
+    /// Memory usage during type-checking exceeds the allocated budget.
+    /// The first `u64` represents the total consumed memory, and the second represents the memory limit.
+    /// Invalidates Block:
+    ///  - true if happens during contract analysis
+    ///  - false if happens during contract intitialization or contract call.
     MemoryBalanceExceeded(u64, u64),
+    /// Failure to access or load cost-related contracts or their state during runtime operations.
+    /// Invalidates Block: false.
     CostContractLoadFailure,
+    /// Failure in cost-tracking due to an unexpected condition or invalid state.
+    /// The `String` wraps the specific reason for the failure.
+    /// Invalidates Block: false.
+    CostComputationFailed(String),
+    // Time checker errors
+    /// Type-checking time exceeds the allowed budget, halting analysis to ensure responsiveness.
+    /// Invalidates Block: true.
+    ExecutionTimeExpired,
+    /// Unexpected condition or failure, indicating a bug or invalid state.
+    /// Invalidates Block: true.
     InterpreterFailure,
+    /// Unexpected condition or failure, indicating a bug or invalid state.
+    /// Invalidates Block: true.
     Expect(String),
-    ExecutionTimeExpired,
 }
 
 impl fmt::Display for CostErrors {

clarity-types/src/errors/mod.rs

@@ -134,7 +134,9 @@ impl fmt::Display for Error {
         match self {
             Error::Runtime(err, stack) => {
                 write!(f, "{err}")?;
-                if let Some(stack_trace) = stack {
+                if let Some(stack_trace) = stack
+                    && !stack_trace.is_empty()
+                {
                     writeln!(f, "\n Stack Trace: ")?;
                     for item in stack_trace.iter() {
                         writeln!(f, "{item}")?;

clarity/src/vm/clarity.rs

@@ -81,6 +81,28 @@ impl From<CheckError> for Error {
     }
 }
 
+/// Converts [`InterpreterError`] to [`Error`] for transaction execution contexts.
+///
+/// This conversion is used in:
+/// - [`TransactionConnection::initialize_smart_contract`]
+/// - [`TransactionConnection::run_contract_call`]
+/// - [`TransactionConnection::run_stx_transfer`]
+///
+/// # Notes
+///
+/// - [`CheckErrors::MemoryBalanceExceeded`] and [`CheckErrors::CostComputationFailed`]
+///   are intentionally not converted to [`Error::CostError`].
+///   Instead, they remain wrapped in `Error::Interpreter(Unchecked(CheckErrors::MemoryBalanceExceeded))`,
+///   which causes the transaction to fail, but still be included in the block.
+///
+/// - This behavior differs from direct conversions of [`CheckError`] and [`ParseError`] to [`Error`],
+///   where [`CheckErrors::MemoryBalanceExceeded`] is converted to [`Error::CostError`],
+///   during contract analysis.
+///
+///   As a result:
+///   - A `MemoryBalanceExceeded` during contract analysis causes the block to be rejected.
+///   - A `MemoryBalanceExceeded` during execution (initialization or contract call)
+///     causes the transaction to fail, but the block remains valid.
 impl From<InterpreterError> for Error {
     fn from(e: InterpreterError) -> Self {
         match &e {

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