fix: Vec<u8> for potentially non-ascii data

api/oas_generator/rust_oas_generator/generator/template_engine.py

@@ -490,6 +490,10 @@ def _generate_base_files(self, context: dict[str, Any], output_dir: Path) -> dic
             files[src_dir / "msgpack_value_bytes.rs"] = self.template_engine.render_template(
                 "base/msgpack_value_bytes.rs.j2", context
             )
+            # Provide msgpack helper to deserialize msgpack strings as raw bytes
+            files[src_dir / "msgpack_string_bytes.rs"] = self.template_engine.render_template(
+                "base/msgpack_string_bytes.rs.j2", context
+            )
 
         return files
 

api/oas_generator/rust_oas_generator/templates/base/lib.rs.j2

@@ -8,6 +8,7 @@ uniffi::setup_scaffolding!();
 pub mod apis;
 pub mod models;
 {% if client_type == "Algod" %}
+pub mod msgpack_string_bytes;
 pub mod msgpack_value_bytes;
 {% endif %}
 

api/oas_generator/rust_oas_generator/templates/base/msgpack_string_bytes.rs.j2

@@ -0,0 +1,39 @@
+/// Custom serde module for deserializing msgpack strings as raw bytes.
+///
+/// Msgpack strings may contain arbitrary bytes that aren't valid UTF-8.
+/// This module deserializes the raw string bytes into Vec<u8> without
+/// requiring UTF-8 validity.
+use serde::{Deserialize, Deserializer, Serializer};
+
+/// Deserialize a msgpack string as raw bytes
+pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Vec<u8>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    // Use rmpv::Value to capture the raw msgpack value
+    let value: Option<rmpv::Value> = Option::deserialize(deserializer)?;
+
+    match value {
+        Some(rmpv::Value::String(s)) => {
+            // rmpv::Utf8String gives us access to raw bytes even if not valid UTF-8
+            Ok(Some(s.into_bytes()))
+        }
+        Some(rmpv::Value::Binary(b)) => Ok(Some(b)),
+        Some(_) => Err(serde::de::Error::custom(
+            "expected string or binary, got other type",
+        )),
+        None => Ok(None),
+    }
+}
+
+/// Serialize bytes as a msgpack binary
+pub fn serialize<S>(value: &Option<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    match value {
+        Some(bytes) => serializer.serialize_bytes(bytes),
+        None => serializer.serialize_none(),
+    }
+}
+

api/oas_generator/rust_oas_generator/templates/models/block/block_app_eval_delta.rs.j2

@@ -41,9 +41,10 @@ pub struct BlockAppEvalDelta {
     #[serde_as(as = "Option<Vec<Bytes>>")]
     #[serde(rename = "sa", skip_serializing_if = "Option::is_none")]
     pub shared_accounts: Option<Vec<Vec<u8>>>,
-    /// [lg] Application log outputs as strings (msgpack strings).
+    /// [lg] Application log outputs.
+    #[serde_as(as = "Option<Vec<Bytes>>")]
     #[serde(rename = "lg", skip_serializing_if = "Option::is_none")]
-    pub logs: Option<Vec<String>>,
+    pub logs: Option<Vec<Vec<u8>>>,
 }
 
 impl AlgorandMsgpack for BlockAppEvalDelta {

api/oas_generator/rust_oas_generator/templates/models/block/block_eval_delta.rs.j2

@@ -21,8 +21,13 @@ pub struct BlockEvalDelta {
     #[serde(rename = "at")]
     pub action: u32,
     /// [bs] bytes value.
-    #[serde(rename = "bs", skip_serializing_if = "Option::is_none")]
-    pub bytes: Option<String>,
+    #[serde(
+        with = "crate::msgpack_string_bytes",
+        default,
+        rename = "bs",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub bytes: Option<Vec<u8>>,
     /// [ui] uint value.
     #[serde(rename = "ui", skip_serializing_if = "Option::is_none")]
     pub uint: Option<u64>,

api/oas_generator/rust_oas_generator/templates/models/block/block_state_delta.rs.j2

@@ -8,12 +8,90 @@
  {% endif %} * Generated by: Rust OpenAPI Generator
  */
 
-use crate::models;
-use std::collections::HashMap;
-
 use crate::models::BlockEvalDelta;
+use serde::de::{MapAccess, Visitor};
+use serde::ser::SerializeMap;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::collections::HashMap;
+use std::fmt;
+use std::ops::{Deref, DerefMut};
 
 /// BlockStateDelta is a map keyed by state key to BlockEvalDelta.
-pub type BlockStateDelta = HashMap<String, BlockEvalDelta>;
+/// Keys are raw bytes that may come as msgpack strings (which can contain non-UTF8 data).
+#[derive(Clone, Default, Debug, PartialEq)]
+#[cfg_attr(feature = "ffi_uniffi", derive(uniffi::Record))]
+pub struct BlockStateDelta {
+    pub entries: HashMap<Vec<u8>, BlockEvalDelta>,
+}
+
+impl Deref for BlockStateDelta {
+    type Target = HashMap<Vec<u8>, BlockEvalDelta>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.entries
+    }
+}
+
+impl DerefMut for BlockStateDelta {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.entries
+    }
+}
+
+struct BlockStateDeltaVisitor;
+
+impl<'de> Visitor<'de> for BlockStateDeltaVisitor {
+    type Value = BlockStateDelta;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a map with string or binary keys")
+    }
+
+    fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
+    where
+        M: MapAccess<'de>,
+    {
+        let mut entries = HashMap::with_capacity(access.size_hint().unwrap_or(0));
+
+        // Use rmpv::Value for keys to handle both string and binary
+        while let Some((key, value)) = access.next_entry::<rmpv::Value, BlockEvalDelta>()? {
+            let key_bytes = match key {
+                rmpv::Value::String(s) => s.into_bytes(),
+                rmpv::Value::Binary(b) => b,
+                _ => {
+                    return Err(serde::de::Error::custom(
+                        "expected string or binary key in BlockStateDelta",
+                    ))
+                }
+            };
+            entries.insert(key_bytes, value);
+        }
+
+        Ok(BlockStateDelta { entries })
+    }
+}
+
+impl<'de> Deserialize<'de> for BlockStateDelta {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_map(BlockStateDeltaVisitor)
+    }
+}
+
+impl Serialize for BlockStateDelta {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(self.entries.len()))?;
+        for (k, v) in &self.entries {
+            // Serialize keys as bytes
+            map.serialize_entry(&serde_bytes::Bytes::new(k), v)?;
+        }
+        map.end()
+    }
+}
 
 

crates/algod_client/src/lib.rs

@@ -6,6 +6,7 @@ uniffi::setup_scaffolding!();
 
 pub mod apis;
 pub mod models;
+pub mod msgpack_string_bytes;
 pub mod msgpack_value_bytes;
 
 // Re-export the main client for convenience

crates/algod_client/src/models/block_app_eval_delta.rs

@@ -41,9 +41,10 @@ pub struct BlockAppEvalDelta {
     #[serde_as(as = "Option<Vec<Bytes>>")]
     #[serde(rename = "sa", skip_serializing_if = "Option::is_none")]
     pub shared_accounts: Option<Vec<Vec<u8>>>,
-    /// [lg] Application log outputs as strings (msgpack strings).
+    /// [lg] Application log outputs.
+    #[serde_as(as = "Option<Vec<Bytes>>")]
     #[serde(rename = "lg", skip_serializing_if = "Option::is_none")]
-    pub logs: Option<Vec<String>>,
+    pub logs: Option<Vec<Vec<u8>>>,
 }
 
 impl AlgorandMsgpack for BlockAppEvalDelta {

crates/algod_client/src/models/block_eval_delta.rs

@@ -21,8 +21,13 @@ pub struct BlockEvalDelta {
     #[serde(rename = "at")]
     pub action: u32,
     /// [bs] bytes value.
-    #[serde(rename = "bs", skip_serializing_if = "Option::is_none")]
-    pub bytes: Option<String>,
+    #[serde(
+        with = "crate::msgpack_string_bytes",
+        default,
+        rename = "bs",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub bytes: Option<Vec<u8>>,
     /// [ui] uint value.
     #[serde(rename = "ui", skip_serializing_if = "Option::is_none")]
     pub uint: Option<u64>,

crates/algod_client/src/models/block_state_delta.rs

@@ -8,10 +8,88 @@
  * Generated by: Rust OpenAPI Generator
  */
 
-use crate::models;
-use std::collections::HashMap;
-
 use crate::models::BlockEvalDelta;
+use serde::de::{MapAccess, Visitor};
+use serde::ser::SerializeMap;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::collections::HashMap;
+use std::fmt;
+use std::ops::{Deref, DerefMut};
 
 /// BlockStateDelta is a map keyed by state key to BlockEvalDelta.
-pub type BlockStateDelta = HashMap<String, BlockEvalDelta>;
+/// Keys are raw bytes that may come as msgpack strings (which can contain non-UTF8 data).
+#[derive(Clone, Default, Debug, PartialEq)]
+#[cfg_attr(feature = "ffi_uniffi", derive(uniffi::Record))]
+pub struct BlockStateDelta {
+    pub entries: HashMap<Vec<u8>, BlockEvalDelta>,
+}
+
+impl Deref for BlockStateDelta {
+    type Target = HashMap<Vec<u8>, BlockEvalDelta>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.entries
+    }
+}
+
+impl DerefMut for BlockStateDelta {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.entries
+    }
+}
+
+struct BlockStateDeltaVisitor;
+
+impl<'de> Visitor<'de> for BlockStateDeltaVisitor {
+    type Value = BlockStateDelta;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a map with string or binary keys")
+    }
+
+    fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
+    where
+        M: MapAccess<'de>,
+    {
+        let mut entries = HashMap::with_capacity(access.size_hint().unwrap_or(0));
+
+        // Use rmpv::Value for keys to handle both string and binary
+        while let Some((key, value)) = access.next_entry::<rmpv::Value, BlockEvalDelta>()? {
+            let key_bytes = match key {
+                rmpv::Value::String(s) => s.into_bytes(),
+                rmpv::Value::Binary(b) => b,
+                _ => {
+                    return Err(serde::de::Error::custom(
+                        "expected string or binary key in BlockStateDelta",
+                    ));
+                }
+            };
+            entries.insert(key_bytes, value);
+        }
+
+        Ok(BlockStateDelta { entries })
+    }
+}
+
+impl<'de> Deserialize<'de> for BlockStateDelta {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_map(BlockStateDeltaVisitor)
+    }
+}
+
+impl Serialize for BlockStateDelta {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = serializer.serialize_map(Some(self.entries.len()))?;
+        for (k, v) in &self.entries {
+            // Serialize keys as bytes
+            map.serialize_entry(&serde_bytes::Bytes::new(k), v)?;
+        }
+        map.end()
+    }
+}