Use serde_bytes to (de)serialize Vec<u8>s.

Author: murisi

Cargo.lock

@@ -20,6 +20,7 @@ rustler = { version = "0.36.2", optional = true }
 bytemuck = { version = "1.12", features = ["derive"] }
 alloy-primitives = "1.0.23"
 alloy-sol-types = "1.0.23"
+serde_bytes = "0.11.19"
 
 [features]
 default = ["transaction", "prove"]

arm/Cargo.toml

@@ -46,6 +46,7 @@ pub struct ComplianceWitness {
     /// The created resource
     pub created_resource: Resource,
     /// Random scalar for delta commitment
+    #[serde(with = "serde_bytes")]
     pub rcv: Vec<u8>,
     // TODO: If we want to add function privacy, include:
     // pub input_resource_logic_cm_r: [u8; DATA_BYTES],

arm/src/compliance.rs

@@ -13,7 +13,9 @@ use crate::{compliance::ComplianceWitness, constants::COMPLIANCE_PK, proving_sys
 #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.ComplianceUnit"))]
 pub struct ComplianceUnit {
     // vk is a constant in the compliance unit, so we don't place it here.
+    #[serde(with = "serde_bytes")]
     pub proof: Vec<u8>,
+    #[serde(with = "serde_bytes")]
     pub instance: Vec<u8>,
 }
 

arm/src/compliance_unit.rs

@@ -3,12 +3,9 @@ use k256::{
     elliptic_curve::PublicKey, elliptic_curve::ScalarPrimitive, ProjectivePoint, Scalar, SecretKey,
 };
 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
-use serde::de::{SeqAccess};
 
 use sha3::{Digest, Keccak256};
-use std::marker::PhantomData;
-use std::fmt;
-use serde::de::Visitor;
+use serde_bytes::ByteArray;
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.DeltaProof"))]
@@ -20,38 +17,11 @@ pub struct DeltaProof {
 }
 
 fn serialize_signature<S>(t: &Signature, s: S) -> Result<S::Ok, S::Error> where S: Serializer {
-    s.serialize_bytes(&t.to_bytes())
+    ByteArray::<64>::new(t.to_bytes().into()).serialize(s)
 }
 
 fn deserialize_signature<'de, D>(deserializer: D) -> Result<Signature, D::Error> where D: Deserializer<'de> {
-    const LEN: usize = 64;
-    struct ArrayVisitor<T> {
-        element: PhantomData<T>,
-    }
-
-    impl<'de, T> Visitor<'de> for ArrayVisitor<T>
-    where T: Default + Copy + Deserialize<'de>
-    {
-        type Value = [T; LEN];
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            write!(formatter, "an array of length {}", LEN)
-        }
-
-        fn visit_seq<A>(self, mut seq: A) -> Result<[T; LEN], A::Error>
-        where A: SeqAccess<'de>
-        {
-            let mut arr = [T::default(); LEN];
-            for i in 0..LEN {
-                arr[i] = seq.next_element()?
-                    .ok_or_else(|| de::Error::invalid_length(i, &self))?;
-            }
-            Ok(arr)
-        }
-    }
-
-    let visitor = ArrayVisitor { element: PhantomData };
-    let b: [u8; LEN] = deserializer.deserialize_tuple(LEN, visitor)?;
+    let b: [u8; 64] = ByteArray::deserialize(deserializer)?.into_array();
     Signature::from_bytes(&b.into()).map_err(de::Error::custom)
 }
 
@@ -72,11 +42,11 @@ pub struct DeltaWitness {
 }
 
 fn serialize_signing_key<S>(t: &SigningKey, s: S) -> Result<S::Ok, S::Error> where S: Serializer {
-    s.serialize_bytes(&t.to_bytes())
+    ByteArray::<32>::new(t.to_bytes().into()).serialize(s)
 }
 
 fn deserialize_signing_key<'de, D>(deserializer: D) -> Result<SigningKey, D::Error> where D: Deserializer<'de> {
-    let b: [u8; 32] = Deserialize::deserialize(deserializer)?;
+    let b: [u8; 32] = ByteArray::deserialize(deserializer)?.into_array();
     SigningKey::from_bytes(&b.into()).map_err(de::Error::custom)
 }
 

arm/src/delta_proof.rs

@@ -48,7 +48,9 @@ pub trait LogicProver: Default + Clone + Serialize + for<'de> Deserialize<'de> {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.LogicVerifier"))]
 pub struct LogicVerifier {
+    #[serde(with = "serde_bytes")]
     pub proof: Vec<u8>,
+    #[serde(with = "serde_bytes")]
     pub instance: Vec<u8>,
     pub verifying_key: Vec<u32>,
 }
@@ -59,6 +61,7 @@ pub struct LogicVerifierInputs {
     pub tag: Vec<u32>,
     pub verifying_key: Vec<u32>,
     pub app_data: AppData,
+    #[serde(with = "serde_bytes")]
     pub proof: Vec<u8>,
 }
 

arm/src/logic_proof.rs

@@ -29,20 +29,25 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.Resource"))]
 pub struct Resource {
     // a succinct representation of the predicate associated with the resource
+    #[serde(with = "serde_bytes")]
     pub logic_ref: Vec<u8>,
     // specifies the fungibility domain for the resource
+    #[serde(with = "serde_bytes")]
     pub label_ref: Vec<u8>,
     // number representing the quantity of the resource
     pub quantity: u128,
     // the fungible value reference of the resource
+    #[serde(with = "serde_bytes")]
     pub value_ref: Vec<u8>,
     // flag that reflects the resource ephemerality
     pub is_ephemeral: bool,
     // guarantees the uniqueness of the resource computable components
+    #[serde(with = "serde_bytes")]
     pub nonce: Vec<u8>,
     // commitment to nullifier key
     pub nk_commitment: NullifierKeyCommitment,
     // randomness seed used to derive whatever randomness needed
+    #[serde(with = "serde_bytes")]
     pub rand_seed: Vec<u8>,
 }