fix: started to replace borsh with bincode serialization, verify commitment consistency in SP1 proofs and FinalizedEpoch

Author: sebasti810

Cargo.lock

@@ -15,3 +15,4 @@ serde.workspace = true
 hex.workspace = true
 sha2.workspace = true
 celestia-types.workspace = true
+bincode.workspace = true

crates/common/Cargo.toml

@@ -1,5 +1,4 @@
 use anyhow::{bail, Result};
-use borsh::{BorshDeserialize, BorshSerialize};
 use jmt::KeyHash;
 use serde::{Deserialize, Serialize};
 use std::ops::{Deref, DerefMut};
@@ -9,7 +8,7 @@ use crate::{
     tree::{hash, Digest, Hasher},
 };
 
-#[derive(Clone, BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 pub struct Hashchain {
     pub id: String,
     pub entries: Vec<HashchainEntry>,
@@ -129,9 +128,17 @@ impl Hashchain {
     pub fn len(&self) -> usize {
         self.entries.len()
     }
+
+    pub fn serialize(&self) -> Result<Vec<u8>> {
+        bincode::serialize(self).map_err(anyhow::Error::from)
+    }
+
+    pub fn deserialize(data: &[u8]) -> Result<Self> {
+        bincode::deserialize(data).map_err(anyhow::Error::from)
+    }
 }
 
-#[derive(Clone, BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 // A [`HashchainEntry`] represents a single entry in an account's hashchain.
 // The value in the leaf of the corresponding account's node in the IMT is the hash of the last node in the hashchain.
 pub struct HashchainEntry {
@@ -155,4 +162,12 @@ impl HashchainEntry {
             operation,
         }
     }
+
+    pub fn serialize(&self) -> Result<Vec<u8>> {
+        bincode::serialize(self).map_err(anyhow::Error::from)
+    }
+
+    pub fn deserialize(data: &[u8]) -> Result<Self> {
+        bincode::deserialize(data).map_err(anyhow::Error::from)
+    }
 }

crates/common/src/hashchain.rs

@@ -1,10 +1,9 @@
 use anyhow::{Context, Result};
-use borsh::{BorshDeserialize, BorshSerialize};
 use celestia_types::Blob;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 
-#[derive(Clone, BorshDeserialize, BorshSerialize, Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 // An [`Operation`] represents a state transition in the system.
 // In a blockchain analogy, this would be the full set of our transaction types.
 pub enum Operation {
@@ -26,7 +25,7 @@ pub enum Operation {
     },
 }
 
-#[derive(Clone, BorshSerialize, BorshDeserialize, Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
 // An [`AccountSource`] represents the source of an account. See adr-002 for more information.
 pub enum AccountSource {
     SignedBySequencer { signature: String },
@@ -61,7 +60,7 @@ impl TryFrom<&Blob> for Operation {
     type Error = anyhow::Error;
 
     fn try_from(value: &Blob) -> Result<Self, Self::Error> {
-        borsh::from_slice::<Self>(&value.data)
+        bincode::deserialize(&value.data)
             .context(format!("Failed to decode blob into Operation: {value:?}"))
     }
 }

crates/common/src/operation.rs

@@ -1,6 +1,6 @@
 use anyhow::{anyhow, bail, Context, Result};
+use bincode;
 use bls12_381::Scalar;
-use borsh::{from_slice, to_vec, BorshDeserialize, BorshSerialize};
 use jmt::{
     proof::{SparseMerkleProof, UpdateMerkleProof},
     storage::{NodeBatch, TreeReader, TreeUpdateBatch, TreeWriter},
@@ -22,9 +22,7 @@ pub fn hash(data: &[u8]) -> Digest {
     Digest(hasher.finalize())
 }
 
-#[derive(
-    Debug, Clone, BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Copy,
-)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Copy)]
 pub struct Digest([u8; 32]);
 
 impl Digest {
@@ -116,7 +114,7 @@ impl Serialize for Proof {
     where
         S: serde::Serializer,
     {
-        let bytes = borsh::to_vec(self).map_err(serde::ser::Error::custom)?;
+        let bytes = bincode::serialize(self).map_err(serde::ser::Error::custom)?;
         serializer.serialize_bytes(&bytes)
     }
 }
@@ -132,28 +130,28 @@ impl<'de> Deserialize<'de> for Proof {
             type Value = Proof;
 
             fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-                formatter.write_str("a byte array containing Borsh-serialized Proof")
+                formatter.write_str("a byte array containing serialized Proof")
             }
 
             fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
             where
                 E: serde::de::Error,
             {
-                Proof::try_from_slice(v).map_err(serde::de::Error::custom)
+                bincode::deserialize(v).map_err(serde::de::Error::custom)
             }
         }
 
         deserializer.deserialize_bytes(ProofVisitor)
     }
 }
 
-#[derive(BorshSerialize, BorshDeserialize, Debug, Clone)]
+#[derive(Debug, Clone)]
 pub enum Proof {
     Update(UpdateProof),
     Insert(InsertProof),
 }
 
-#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
+#[derive(Debug, Clone)]
 pub struct NonMembershipProof {
     pub root: Digest,
     pub proof: SparseMerkleProof<Hasher>,
@@ -166,7 +164,7 @@ impl NonMembershipProof {
     }
 }
 
-#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
+#[derive(Debug, Clone)]
 pub struct InsertProof {
     pub non_membership_proof: NonMembershipProof,
 
@@ -181,7 +179,7 @@ impl InsertProof {
             .verify()
             .context("Invalid NonMembershipProof")?;
 
-        let value = to_vec(&self.value).unwrap();
+        let value = bincode::serialize(&self.value).unwrap();
 
         self.membership_proof.clone().verify_existence(
             self.new_root.into(),
@@ -193,7 +191,7 @@ impl InsertProof {
     }
 }
 
-#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)]
+#[derive(Debug, Clone)]
 pub struct UpdateProof {
     pub old_root: RootHash,
     pub new_root: RootHash,
@@ -206,7 +204,7 @@ pub struct UpdateProof {
 
 impl UpdateProof {
     pub fn verify(&self) -> Result<()> {
-        let new_value = to_vec(&self.new_value).unwrap();
+        let new_value = bincode::serialize(&self.new_value).unwrap();
 
         self.proof.clone().verify_update(
             self.old_root,
@@ -278,11 +276,12 @@ where
     }
 
     fn serialize_value(value: &Hashchain) -> Result<Vec<u8>> {
-        to_vec(value).map_err(|e| anyhow!("Failed to serialize value: {}", e))
+        bincode::serialize(value).map_err(|e| anyhow!("Failed to serialize value: {}", e))
     }
 
     fn deserialize_value(bytes: &[u8]) -> Result<Hashchain> {
-        from_slice::<Hashchain>(bytes).map_err(|e| anyhow!("Failed to deserialize value: {}", e))
+        bincode::deserialize::<Hashchain>(bytes)
+            .map_err(|e| anyhow!("Failed to deserialize value: {}", e))
     }
 }
 

crates/common/src/tree.rs

@@ -1,7 +1,6 @@
 use anyhow::{anyhow, Context, Result};
 use bellman::{groth16, Circuit, ConstraintSystem, SynthesisError};
 use bls12_381::{Bls12, G1Affine, G2Affine, Scalar};
-use borsh::{BorshDeserialize, BorshSerialize};
 use prism_errors::{GeneralError, PrismError};
 use std::fmt;
 
@@ -38,11 +37,11 @@ impl Circuit<Scalar> for ProofVariantCircuit {
 }
 
 /// G1 represents a compressed [`bls12_381::G1Affine`]
-#[derive(BorshSerialize, BorshDeserialize, Clone)]
+#[derive(Clone)]
 pub struct G1([u8; 48]);
 
 /// G2 represents a compressed [`bls12_381::G2Affine`]
-#[derive(BorshSerialize, BorshDeserialize, Clone)]
+#[derive(Clone)]
 pub struct G2([u8; 96]);
 
 // Debug impls for the Affines print their hex representation
@@ -84,7 +83,7 @@ impl TryFrom<G2> for bls12_381::G2Affine {
     }
 }
 
-#[derive(Clone, BorshSerialize, BorshDeserialize, Debug)]
+#[derive(Clone, Debug)]
 pub struct Bls12Proof {
     pub a: G1,
     pub b: G2,
@@ -113,7 +112,7 @@ impl From<groth16::Proof<Bls12>> for Bls12Proof {
     }
 }
 
-#[derive(Clone, BorshSerialize, BorshDeserialize, Debug)]
+#[derive(Clone, Debug)]
 pub struct VerifyingKey {
     pub alpha_g1: G1,
     pub beta_g1: G1,

crates/groth16/src/lib.rs

@@ -21,6 +21,7 @@ ed25519 = { workspace = true }
 base64 = { workspace = true }
 tokio = { workspace = true }
 bellman = { workspace = true }
+bincode = { workspace = true }
 bls12_381 = { workspace = true }
 rand = { workspace = true }
 hex = { workspace = true }

crates/prism/Cargo.toml

@@ -3,13 +3,12 @@ use crate::{
     consts::CHANNEL_BUFFER_SIZE,
     da::{DataAvailabilityLayer, FinalizedEpoch},
 };
-use prism_errors::{DataAvailabilityError, GeneralError};
 use anyhow::{anyhow, bail, Context, Result};
 use async_trait::async_trait;
-use borsh::from_slice;
 use celestia_rpc::{BlobClient, Client, HeaderClient};
 use celestia_types::{blob::GasPrice, nmt::Namespace, Blob};
 use prism_common::operation::Operation;
+use prism_errors::{DataAvailabilityError, GeneralError};
 use std::{self, sync::Arc};
 use tokio::{
     sync::{
@@ -19,11 +18,13 @@ use tokio::{
     task::spawn,
 };
 
+use bincode;
+
 impl TryFrom<&Blob> for FinalizedEpoch {
     type Error = anyhow::Error;
 
     fn try_from(value: &Blob) -> Result<Self, Self::Error> {
-        from_slice::<Self>(&value.data).context(format!(
+        bincode::deserialize(&value.data).context(format!(
             "Failed to decode blob into FinalizedEpoch: {value:?}"
         ))
     }
@@ -140,7 +141,7 @@ impl DataAvailabilityLayer for CelestiaConnection {
         let blobs: Result<Vec<Blob>, DataAvailabilityError> = epochs
             .iter()
             .map(|epoch| {
-                let data = borsh::to_vec(epoch).map_err(|e| {
+                let data = bincode::serialize(epoch).map_err(|e| {
                     DataAvailabilityError::GeneralError(GeneralError::ParsingError(format!(
                         "serializing epoch {}: {}",
                         epoch.height, e
@@ -199,7 +200,7 @@ impl DataAvailabilityLayer for CelestiaConnection {
         let blobs: Result<Vec<Blob>, _> = operations
             .iter()
             .map(|operation| {
-                let data = borsh::to_vec(operation)
+                let data = bincode::serialize(operation)
                     .context(format!("Failed to serialize operation {}", operation))
                     .map_err(|e| {
                         DataAvailabilityError::GeneralError(GeneralError::ParsingError(

crates/prism/src/da/celestia.rs

@@ -1,7 +1,7 @@
 use crate::utils::SignedContent;
 use anyhow::Result;
 use async_trait::async_trait;
-use borsh::{BorshDeserialize, BorshSerialize};
+use bincode;
 use ed25519::Signature;
 use prism_common::{operation::Operation, tree::Digest};
 use prism_errors::GeneralError;
@@ -13,7 +13,7 @@ pub mod celestia;
 pub mod memory;
 
 // FinalizedEpoch is the data structure that represents the finalized epoch data, and is posted to the DA layer.
-#[derive(BorshSerialize, BorshDeserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct FinalizedEpoch {
     pub height: u64,
     pub prev_commitment: Digest,
@@ -34,7 +34,7 @@ impl SignedContent for FinalizedEpoch {
     fn get_plaintext(&self) -> Result<Vec<u8>> {
         let mut copy = self.clone();
         copy.signature = None;
-        borsh::to_vec(&copy).map_err(|e| GeneralError::EncodingError(e.to_string()).into())
+        bincode::serialize(&copy).map_err(|e| GeneralError::EncodingError(e.to_string()).into())
     }
 
     fn get_public_key(&self) -> Result<String> {

crates/prism/src/da/mod.rs

@@ -1,6 +1,7 @@
 use crate::cfg::CelestiaConfig;
 use anyhow::{Context, Result};
 use async_trait::async_trait;
+use prism_common::tree::Digest;
 use prism_errors::{DataAvailabilityError, GeneralError};
 use sp1_sdk::{ProverClient, SP1VerifyingKey};
 use std::{self, sync::Arc, time::Duration};
@@ -99,7 +100,27 @@ impl LightClient {
                                     }
                                 }
 
-                                // TODO: compare commitment to epoch_json.proof.public_values
+                                let prev_commitment = &epoch_json.prev_commitment;
+                                let current_commitment = &epoch_json.current_commitment;
+
+                                let mut public_values = epoch_json.proof.public_values.clone();
+                                let proof_prev_commitment: Digest = public_values.read();
+                                let proof_current_commitment: Digest = public_values.read();
+
+                                if prev_commitment != &proof_prev_commitment
+                                    || current_commitment != &proof_current_commitment
+                                {
+                                    error!(
+                                        "Commitment mismatch: 
+                                        prev_commitment: {:?}, proof_prev_commitment: {:?},
+                                        current_commitment: {:?}, proof_current_commitment: {:?}",
+                                        prev_commitment,
+                                        proof_prev_commitment,
+                                        current_commitment,
+                                        proof_current_commitment
+                                    );
+                                    panic!("Commitment mismatch in epoch {}", epoch_json.height);
+                                }
 
                                 match self.client.verify(&epoch_json.proof, &self.verifying_key) {
                                     Ok(_) => {