Add deserializer for custom blockstack op fields and make sure backwards compatibility satisfied for TransactionEventPayload

Signed-off-by: Jacinta Ferrant <jacinta.ferrant@gmail.com>

Author: jferrant

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, Serialize, Serializer};
+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,32 @@ 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.
@@ -390,6 +417,101 @@ pub fn blockstack_op_extended_serialize_opt<S: Serializer>(
     }
 }
 
+/// Deserialize the burnchain op that was serialized with blockstack_op_to_json
+pub fn deserialize_extended_blockstack_op<'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)
+}
+
+macro_rules! normalize_common_fields {
+    ($map:ident, $de:ident) => {{
+        normalize_hex_field::<$de, _>(&mut $map, "burn_header_hash", |s| {
+            BurnchainHeaderHash::from_hex(s).map_err(DeError::custom)
+        })?;
+        rename_field(&mut $map, "burn_txid", "txid");
+        rename_field(&mut $map, "burn_block_height", "block_height");
+    }};
+}
+
+// Utility function to normalize a hex string to a BurnchainHeaderHash JSON value
+fn normalize_hex_field<'de, D, T>(
+    map: &mut serde_json::Map<String, serde_json::Value>,
+    field: &str,
+    from_hex: fn(&str) -> Result<T, D::Error>,
+) -> Result<(), D::Error>
+where
+    D: Deserializer<'de>,
+    T: serde::Serialize,
+{
+    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 = 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);
+    }
+    Ok(())
+}
+
+// Normalize renamed field
+fn rename_field(map: &mut serde_json::Map<String, serde_json::Value>, from: &str, to: &str) {
+    if let Some(val) = map.remove(from) {
+        map.insert(to.to_string(), val);
+    }
+}
+
 impl BlockstackOperationType {
     pub fn opcode(&self) -> Opcodes {
         match *self {
@@ -491,6 +613,114 @@ impl BlockstackOperationType {
         };
     }
 
+    // Replace all the normalize_* functions with minimal implementations
+    fn normalize_pre_stx_fields<'de, D>(
+        mut map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields!(map, D);
+        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>(
+        mut map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields!(map, D);
+        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>(
+        mut map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields!(map, D);
+        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>(
+        mut map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields!(map, D);
+        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>(
+        mut map: &mut serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        normalize_common_fields!(map, D);
+        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": {