Create TransactionEventPayload struct and add vm_error to it

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 
 ### Added
 
+- Added field `vm_error` to EventObserver transaction outputs
 - Added new `ValidateRejectCode` values to the `/v3/block_proposal` endpoint
 
 ### Changed

stackslib/src/chainstate/burn/operations/mod.rs

@@ -17,7 +17,8 @@
 use std::{error, fmt, fs, io};
 
 use clarity::vm::types::PrincipalData;
-use serde::Deserialize;
+use serde::de::Error as DeError;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use serde_json::json;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, TrieHash, VRFSeed,
@@ -374,6 +375,132 @@ pub fn stacks_addr_serialize(addr: &StacksAddress) -> serde_json::Value {
     })
 }
 
+fn normalize_stacks_addr_fields<'de, D>(
+    inner: &mut serde_json::Map<String, serde_json::Value>,
+) -> Result<(), D::Error>
+where
+    D: Deserializer<'de>,
+{
+    // Rename `address_version` to `version`
+    if let Some(address_version) = inner.remove("address_version") {
+        inner.insert("version".to_string(), address_version);
+    }
+
+    // Rename `address_hash_bytes` to `bytes` and convert to bytes
+    if let Some(address_bytes) = inner
+        .remove("address_hash_bytes")
+        .and_then(|addr| serde_json::Value::as_str(&addr).map(|x| x.to_string()))
+    {
+        let address_hex: String = address_bytes.chars().skip(2).collect(); // Remove "0x" prefix
+        inner.insert(
+            "bytes".to_string(),
+            serde_json::to_value(&address_hex).map_err(DeError::custom)?,
+        );
+    }
+
+    Ok(())
+}
+
+/// Serialization function for serializing extended information within the BlockstackOperationType
+/// that is not printed via the standard serde implementation. Specifically, serializes additional
+/// StacksAddress information.
+pub fn blockstack_op_extended_serialize_opt<S: Serializer>(
+    op: &Option<BlockstackOperationType>,
+    s: S,
+) -> Result<S::Ok, S::Error> {
+    match op {
+        Some(op) => {
+            let value = op.blockstack_op_to_json();
+            value.serialize(s)
+        }
+        None => s.serialize_none(),
+    }
+}
+
+/// Deserialize the burnchain op that was serialized with blockstack_op_to_json
+pub fn blockstack_op_extended_deserialize<'de, D>(
+    deserializer: D,
+) -> Result<Option<BlockstackOperationType>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de::Error as DeError;
+    use serde_json::{Map, Value};
+
+    let raw: Option<Value> = Option::deserialize(deserializer)?;
+    let Some(Value::Object(mut obj)) = raw else {
+        return Ok(None);
+    };
+
+    let Some((key, value)) = obj.iter_mut().next() else {
+        return Ok(None);
+    };
+
+    let inner = value
+        .as_object_mut()
+        .ok_or_else(|| DeError::custom("Expected blockstack op to be an object"))?;
+
+    let normalized_key = match key.as_str() {
+        "pre_stx" => {
+            BlockstackOperationType::normalize_pre_stx_fields::<D>(inner)?;
+            "PreStx"
+        }
+        "stack_stx" => {
+            BlockstackOperationType::normalize_stack_stx_fields::<D>(inner)?;
+            "StackStx"
+        }
+        "transfer_stx" => {
+            BlockstackOperationType::normalize_transfer_stx_fields::<D>(inner)?;
+            "TransferStx"
+        }
+        "delegate_stx" => {
+            BlockstackOperationType::normalize_delegate_stx_fields::<D>(inner)?;
+            "DelegateStx"
+        }
+        "vote_for_aggregate_key" => {
+            BlockstackOperationType::normalize_vote_for_aggregate_key_fields::<D>(inner)?;
+            "VoteForAggregateKey"
+        }
+        "leader_key_register" => "LeaderKeyRegister",
+        "leader_block_commit" => "LeaderBlockCommit",
+        other => other,
+    };
+
+    let mut map = Map::new();
+    map.insert(normalized_key.to_string(), value.clone());
+
+    let normalized = Value::Object(map);
+
+    serde_json::from_value(normalized)
+        .map(Some)
+        .map_err(serde::de::Error::custom)
+}
+
+fn normalize_common_fields<'de, D>(
+    map: &mut serde_json::Map<String, serde_json::Value>,
+) -> Result<(), D::Error>
+where
+    D: Deserializer<'de>,
+{
+    if let Some(hex_str) = map
+        .get("burn_header_hash")
+        .and_then(serde_json::Value::as_str)
+    {
+        let cleaned = hex_str.strip_prefix("0x").unwrap_or(hex_str);
+        let val = BurnchainHeaderHash::from_hex(cleaned).map_err(DeError::custom)?;
+        let ser_val = serde_json::to_value(val).map_err(DeError::custom)?;
+        map.insert("burn_header_hash".to_string(), ser_val);
+    }
+
+    if let Some(val) = map.remove("burn_txid") {
+        map.insert("txid".to_string(), val);
+    }
+    if let Some(val) = map.remove("burn_block_height") {
+        map.insert("block_height".to_string(), val);
+    }
+    Ok(())
+}
+
 impl BlockstackOperationType {
     pub fn opcode(&self) -> Opcodes {
         match *self {
@@ -475,6 +602,114 @@ impl BlockstackOperationType {
         };
     }
 
+    // Replace all the normalize_* functions with minimal implementations
+    fn normalize_pre_stx_fields<'de, D>(
+        map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields::<D>(map)?;
+        if let Some(serde_json::Value::Object(obj)) = map.get_mut("output") {
+            normalize_stacks_addr_fields::<D>(obj)?;
+        }
+        Ok(())
+    }
+
+    fn normalize_stack_stx_fields<'de, D>(
+        map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields::<D>(map)?;
+        if let Some(serde_json::Value::Object(obj)) = map.get_mut("sender") {
+            normalize_stacks_addr_fields::<D>(obj)?;
+        }
+        if let Some(reward_val) = map.get("reward_addr") {
+            let b58_str = reward_val
+                .as_str()
+                .ok_or_else(|| DeError::custom("Expected base58 string in reward_addr"))?;
+            let addr = PoxAddress::from_b58(b58_str)
+                .ok_or_else(|| DeError::custom("Invalid stacks address"))?;
+            let val = serde_json::to_value(addr).map_err(DeError::custom)?;
+            map.insert("reward_addr".into(), val);
+        }
+        Ok(())
+    }
+
+    fn normalize_transfer_stx_fields<'de, D>(
+        map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields::<D>(map)?;
+        for field in ["recipient", "sender"] {
+            if let Some(serde_json::Value::Object(obj)) = map.get_mut(field) {
+                normalize_stacks_addr_fields::<D>(obj)?;
+            }
+        }
+        if let Some(memo_str) = map.get("memo").and_then(serde_json::Value::as_str) {
+            let memo_hex = memo_str.trim_start_matches("0x");
+            let memo_bytes = hex_bytes(memo_hex).map_err(DeError::custom)?;
+            let val = serde_json::to_value(memo_bytes).map_err(DeError::custom)?;
+            map.insert("memo".into(), val);
+        }
+        Ok(())
+    }
+
+    fn normalize_delegate_stx_fields<'de, D>(
+        map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields::<D>(map)?;
+        if let Some(serde_json::Value::Array(arr)) = map.get("reward_addr") {
+            if arr.len() == 2 {
+                let index = arr[0]
+                    .as_u64()
+                    .ok_or_else(|| DeError::custom("Expected u64 index"))?
+                    as u32;
+                let b58_str = arr[1]
+                    .as_str()
+                    .ok_or_else(|| DeError::custom("Expected base58 string"))?;
+                let addr = PoxAddress::from_b58(b58_str)
+                    .ok_or_else(|| DeError::custom("Invalid stacks address"))?;
+                let val = serde_json::to_value((index, addr)).map_err(DeError::custom)?;
+                map.insert("reward_addr".into(), val);
+            }
+        }
+        for field in ["delegate_to", "sender"] {
+            if let Some(serde_json::Value::Object(obj)) = map.get_mut(field) {
+                normalize_stacks_addr_fields::<D>(obj)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn normalize_vote_for_aggregate_key_fields<'de, D>(
+        map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields::<D>(map)?;
+        for field in ["aggregate_key", "signer_key"] {
+            if let Some(hex_str) = map.get(field).and_then(serde_json::Value::as_str) {
+                let cleaned = hex_str.strip_prefix("0x").unwrap_or(hex_str);
+                let val = StacksPublicKeyBuffer::from_hex(cleaned).map_err(DeError::custom)?;
+                let ser_val = serde_json::to_value(val).map_err(DeError::custom)?;
+                map.insert(field.to_string(), ser_val);
+            }
+        }
+        if let Some(serde_json::Value::Object(obj)) = map.get_mut("sender") {
+            normalize_stacks_addr_fields::<D>(obj)?;
+        }
+        Ok(())
+    }
+
     pub fn pre_stx_to_json(op: &PreStxOp) -> serde_json::Value {
         json!({
             "pre_stx": {