Improve transaction serialization.

Author: murisi

Cargo.lock

@@ -1,16 +1,42 @@
+use crate::utils::{bytes_to_words, words_to_bytes};
 use crate::{
     merkle_path::{MerklePath, PADDING_LEAF},
     utils::hash_two,
 };
 use risc0_zkvm::sha::Digest;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_bytes::ByteBuf;
 
 #[derive(Debug, Deserialize, Clone, PartialEq, Eq, Serialize)]
 #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.MerkleTree"))]
 pub struct MerkleTree {
+    #[serde(
+        deserialize_with = "deserialize_leaves",
+        serialize_with = "serialize_leaves"
+    )]
     pub leaves: Vec<Vec<u32>>,
 }
 
+pub fn serialize_leaves<S>(t: &[Vec<u32>], s: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    t.iter()
+        .map(|t| ByteBuf::from(words_to_bytes(t)))
+        .collect::<Vec<ByteBuf>>()
+        .serialize(s)
+}
+
+pub fn deserialize_leaves<'de, D>(deserializer: D) -> Result<Vec<Vec<u32>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    Ok(Vec::<ByteBuf>::deserialize(deserializer)?
+        .into_iter()
+        .map(|t| bytes_to_words(&t.into_vec()))
+        .collect())
+}
+
 impl MerkleTree {
     pub fn new(leaves: Vec<Digest>) -> Self {
         let leaves = leaves

arm/src/action_tree.rs

@@ -2,7 +2,7 @@ use crate::{
     merkle_path::MerklePath,
     nullifier_key::NullifierKey,
     resource::Resource,
-    utils::{bytes_to_words, words_to_bytes},
+    utils::{bytes_to_words, vec_u32, words_to_bytes},
 };
 use hex::FromHex;
 use k256::{
@@ -23,12 +23,19 @@ lazy_static! {
 #[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.ComplianceInstance"))]
 pub struct ComplianceInstance {
+    #[serde(with = "vec_u32")]
     pub consumed_nullifier: Vec<u32>,
+    #[serde(with = "vec_u32")]
     pub consumed_logic_ref: Vec<u32>,
+    #[serde(with = "vec_u32")]
     pub consumed_commitment_tree_root: Vec<u32>,
+    #[serde(with = "vec_u32")]
     pub created_commitment: Vec<u32>,
+    #[serde(with = "vec_u32")]
     pub created_logic_ref: Vec<u32>,
+    #[serde(with = "vec_u32")]
     pub delta_x: Vec<u32>,
+    #[serde(with = "vec_u32")]
     pub delta_y: Vec<u32>,
 }
 
@@ -40,6 +47,7 @@ pub struct ComplianceWitness {
     /// The path from the consumed commitment to the root in the commitment tree
     pub merkle_path: MerklePath,
     /// The existing root for the ephemeral resource
+    #[serde(with = "vec_u32")]
     pub ephemeral_root: Vec<u32>,
     /// Nullifier key of the consumed resource
     pub nf_key: NullifierKey,

arm/src/compliance.rs

@@ -1,10 +1,13 @@
+use crate::utils::vec_u32;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.LogicInstance"))]
 pub struct LogicInstance {
+    #[serde(with = "vec_u32")]
     pub tag: Vec<u32>,
     pub is_consumed: bool,
+    #[serde(with = "vec_u32")]
     pub root: Vec<u32>,
     pub app_data: AppData,
 }
@@ -21,6 +24,7 @@ pub struct AppData {
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.ExpirableBlob"))]
 pub struct ExpirableBlob {
+    #[serde(with = "vec_u32")]
     pub blob: Vec<u32>,
     pub deletion_criterion: u32,
 }

arm/src/logic_instance.rs

@@ -8,7 +8,7 @@ use crate::{
     resource::Resource,
     resource_logic::TrivialLogicWitness,
     test_logic::TestLogicWitness,
-    utils::words_to_bytes,
+    utils::{vec_u32, words_to_bytes},
 };
 use rand::Rng;
 use risc0_zkvm::{
@@ -52,6 +52,7 @@ pub struct LogicVerifier {
     pub proof: Vec<u8>,
     #[serde(with = "serde_bytes")]
     pub instance: Vec<u8>,
+    #[serde(with = "vec_u32")]
     pub verifying_key: Vec<u32>,
 }
 
@@ -61,7 +62,9 @@ pub struct LogicVerifier {
     serde(rename = "Elixir.Anoma.Arm.LogicVerifierInputs")
 )]
 pub struct LogicVerifierInputs {
+    #[serde(with = "vec_u32")]
     pub tag: Vec<u32>,
+    #[serde(with = "vec_u32")]
     pub verifying_key: Vec<u32>,
     pub app_data: AppData,
     #[serde(with = "serde_bytes")]

arm/src/logic_proof.rs

@@ -37,9 +37,9 @@ where
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.Delta"))]
 pub enum Delta {
-    #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.Delta.DeltaWitness"))]
+    #[cfg_attr(feature = "nif", serde(rename = "witness"))]
     Witness(DeltaWitness),
-    #[cfg_attr(feature = "nif", serde(rename = "Elixir.Anoma.Arm.Delta.DeltaProof"))]
+    #[cfg_attr(feature = "nif", serde(rename = "proof"))]
     Proof(DeltaProof),
 }
 

arm/src/transaction.rs

@@ -28,6 +28,28 @@ pub fn words_to_bytes(words: &[u32]) -> &[u8] {
     bytemuck::cast_slice(words)
 }
 
+pub mod vec_u32 {
+    use crate::utils::{bytes_to_words, words_to_bytes};
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+    use serde_bytes::ByteBuf;
+
+    pub fn serialize<S>(t: &[u32], s: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        ByteBuf::from(words_to_bytes(t)).serialize(s)
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u32>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(bytes_to_words(
+            &ByteBuf::deserialize(deserializer)?.into_vec(),
+        ))
+    }
+}
+
 pub fn hash_two(left: &[u32], right: &[u32]) -> Vec<u32> {
     let mut words = Vec::with_capacity(2 * DIGEST_WORDS);
     words.extend_from_slice(left);

arm/src/utils.rs

@@ -6,4 +6,5 @@ edition = "2021"
 [dependencies]
 arm = { path = "../../../arm", default-features = false }
 serde = { version = "1.0.197", default-features = false }
+serde_bytes = { version = "0.11.19", default-features = false }
 rand = "0.8"

examples/simple_transfer_application/simple_transfer_witness/Cargo.toml

@@ -10,7 +10,7 @@ use arm::{
     merkle_path::MerklePath,
     nullifier_key::NullifierKey,
     resource::Resource,
-    utils::{bytes_to_words, hash_bytes, words_to_bytes},
+    utils::{bytes_to_words, hash_bytes, vec_u32, words_to_bytes},
 };
 use serde::{Deserialize, Serialize};
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
@@ -39,24 +39,32 @@ pub struct EncryptionInfo {
     // randomly generated for persistent resource_ciphertext
     pub sender_sk: SecretKey,
     // randomly generated for persistent resource_ciphertext(12 bytes)
+    #[serde(with = "serde_bytes")]
     pub encryption_nonce: Vec<u8>,
     // The discovery ciphertext for the resource
+    #[serde(with = "vec_u32")]
     pub discovery_cipher: Vec<u32>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ForwarderInfo {
     pub call_type: CallType,
+    #[serde(with = "serde_bytes")]
     pub forwarder_addr: Vec<u8>,
+    #[serde(with = "serde_bytes")]
     pub token_addr: Vec<u8>,
+    #[serde(with = "serde_bytes")]
     pub user_addr: Vec<u8>,
     pub permit_info: Option<PermitInfo>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct PermitInfo {
+    #[serde(with = "serde_bytes")]
     pub permit_nonce: Vec<u8>,
+    #[serde(with = "serde_bytes")]
     pub permit_deadline: Vec<u8>,
+    #[serde(with = "serde_bytes")]
     pub permit_sig: Vec<u8>,
 }