Add borsh-serialization to verifier (#60)

* feat: add borsh serialization to sp1 groth16 verifier

* feat: add no-op verifier

Author: prajwolrg

Cargo.lock

@@ -13,10 +13,11 @@ rust.unused_must_use = "deny"
 rustdoc.all = "warn"
 
 [dependencies]
-serde.workspace = true
-hex.workspace = true
 blake3 = { version = "1.6.1", default-features = false }
 bn = { version = "0.6.0", package = "substrate-bn" }
+borsh.workspace = true
+hex.workspace = true
+serde.workspace = true
 sha2.workspace = true
 thiserror.workspace = true
 zkaleido.workspace = true

adapters/sp1/groth16-verifier/Cargo.toml

@@ -1,6 +1,7 @@
 use std::fmt;
 
 use bn::{AffineG1, Fq, Group, G1};
+use borsh::{BorshDeserialize, BorshSerialize};
 use serde::{Deserialize, Serialize, Serializer};
 
 use crate::{
@@ -170,3 +171,65 @@ fn get_ys_from_x_g1(x: Fq) -> Result<(Fq, Fq), Error> {
         Ok((neg_y, y))
     }
 }
+
+impl BorshSerialize for SAffineG1 {
+    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        // Convert to projective to access coordinates
+        let mut projective: G1 = (self.0).into();
+        projective.normalize();
+        let (x, y) = (projective.x(), projective.y());
+
+        // Serialize x coordinate
+        let mut x_bytes = [0u8; 32];
+        x.to_big_endian(&mut x_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to serialize x coordinate",
+            )
+        })?;
+        writer.write_all(&x_bytes)?;
+
+        // Serialize y coordinate
+        let mut y_bytes = [0u8; 32];
+        y.to_big_endian(&mut y_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to serialize y coordinate",
+            )
+        })?;
+        writer.write_all(&y_bytes)?;
+
+        Ok(())
+    }
+}
+
+impl BorshDeserialize for SAffineG1 {
+    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+        // Read x coordinate
+        let mut x_bytes = [0u8; 32];
+        reader.read_exact(&mut x_bytes)?;
+        let x = Fq::from_slice(&x_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to deserialize x coordinate",
+            )
+        })?;
+
+        // Read y coordinate
+        let mut y_bytes = [0u8; 32];
+        reader.read_exact(&mut y_bytes)?;
+        let y = Fq::from_slice(&y_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to deserialize y coordinate",
+            )
+        })?;
+
+        let z = Fq::one();
+        let projective = G1::new(x, y, z);
+        let g1 = AffineG1::from_jacobian(projective)
+            .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::InvalidData, "Invalid point"))?;
+
+        Ok(SAffineG1(g1))
+    }
+}

adapters/sp1/groth16-verifier/src/types/g1.rs

@@ -1,6 +1,7 @@
 use std::{cmp::Ordering, fmt};
 
 use bn::{AffineG2, Fq, Fq2, Group, G2};
+use borsh::{BorshDeserialize, BorshSerialize};
 use serde::{Deserialize, Serialize, Serializer};
 
 use crate::{
@@ -218,3 +219,107 @@ fn get_ys_from_x_g2(x: Fq2) -> Result<(Fq2, Fq2), Error> {
         Ok((neg_y, y))
     }
 }
+
+impl BorshSerialize for SAffineG2 {
+    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        let mut projective: G2 = (self.0).into();
+        projective.normalize();
+        let (x, y) = (projective.x(), projective.y());
+
+        // Serialize x coordinate (Fq2: real + imaginary)
+        let mut x_real_bytes = [0u8; 32];
+        x.real().to_big_endian(&mut x_real_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to serialize x real part",
+            )
+        })?;
+        writer.write_all(&x_real_bytes)?;
+
+        let mut x_imag_bytes = [0u8; 32];
+        x.imaginary()
+            .to_big_endian(&mut x_imag_bytes)
+            .map_err(|_| {
+                std::io::Error::new(
+                    std::io::ErrorKind::InvalidData,
+                    "Failed to serialize x imaginary part",
+                )
+            })?;
+        writer.write_all(&x_imag_bytes)?;
+
+        // Serialize y coordinate (Fq2: real + imaginary)
+        let mut y_real_bytes = [0u8; 32];
+        y.real().to_big_endian(&mut y_real_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to serialize y real part",
+            )
+        })?;
+        writer.write_all(&y_real_bytes)?;
+
+        let mut y_imag_bytes = [0u8; 32];
+        y.imaginary()
+            .to_big_endian(&mut y_imag_bytes)
+            .map_err(|_| {
+                std::io::Error::new(
+                    std::io::ErrorKind::InvalidData,
+                    "Failed to serialize y imaginary part",
+                )
+            })?;
+        writer.write_all(&y_imag_bytes)?;
+
+        Ok(())
+    }
+}
+
+impl BorshDeserialize for SAffineG2 {
+    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+        // Read x coordinate components
+        let mut x_real_bytes = [0u8; 32];
+        reader.read_exact(&mut x_real_bytes)?;
+        let x_real = Fq::from_slice(&x_real_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to deserialize x real part",
+            )
+        })?;
+
+        let mut x_imag_bytes = [0u8; 32];
+        reader.read_exact(&mut x_imag_bytes)?;
+        let x_imag = Fq::from_slice(&x_imag_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to deserialize x imaginary part",
+            )
+        })?;
+
+        // Read y coordinate components
+        let mut y_real_bytes = [0u8; 32];
+        reader.read_exact(&mut y_real_bytes)?;
+        let y_real = Fq::from_slice(&y_real_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to deserialize y real part",
+            )
+        })?;
+
+        let mut y_imag_bytes = [0u8; 32];
+        reader.read_exact(&mut y_imag_bytes)?;
+        let y_imag = Fq::from_slice(&y_imag_bytes).map_err(|_| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Failed to deserialize y imaginary part",
+            )
+        })?;
+
+        let x = Fq2::new(x_real, x_imag);
+        let y = Fq2::new(y_real, y_imag);
+        let z = Fq2::one();
+
+        let projective = G2::new(x, y, z);
+        let g2 = AffineG2::from_jacobian(projective)
+            .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::InvalidData, "Invalid point"))?;
+
+        Ok(SAffineG2(g2))
+    }
+}

adapters/sp1/groth16-verifier/src/types/g2.rs

@@ -1,3 +1,4 @@
+use borsh::{BorshDeserialize, BorshSerialize};
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -15,7 +16,7 @@ use crate::{
 pub(crate) const GROTH16_PROOF_LENGTH: usize = 256;
 
 /// Proof for the Groth16 verification.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
 pub(crate) struct Groth16Proof {
     pub(crate) ar: SAffineG1,
     pub(crate) krs: SAffineG1,

adapters/sp1/groth16-verifier/src/types/proof.rs

@@ -1,4 +1,5 @@
 use bn::{AffineG2, G2};
+use borsh::{BorshDeserialize, BorshSerialize};
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -10,22 +11,22 @@ use crate::{
 };
 
 /// G1 elements of the verification key.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
 pub(crate) struct Groth16G1 {
     pub(crate) alpha: SAffineG1,
     pub(crate) k: Vec<SAffineG1>,
 }
 
 /// G2 elements of the verification key.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
 pub(crate) struct Groth16G2 {
     pub(crate) beta: SAffineG2,
     pub(crate) delta: SAffineG2,
     pub(crate) gamma: SAffineG2,
 }
 
 /// Verification key for the Groth16 proof.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
 pub(crate) struct Groth16VerifyingKey {
     pub(crate) g1: Groth16G1,
     pub(crate) g2: Groth16G2,
@@ -108,4 +109,14 @@ mod tests {
 
         assert_eq!(vk, deserialized);
     }
+
+    #[test]
+    fn test_vk_borsh() {
+        let vk = Groth16VerifyingKey::load_from_gnark_bytes(&GROTH16_VK_BYTES).unwrap();
+
+        let serialized = borsh::to_vec(&vk).unwrap();
+        let deserialized: Groth16VerifyingKey = borsh::from_slice(&serialized).unwrap();
+
+        assert_eq!(vk, deserialized);
+    }
 }

adapters/sp1/groth16-verifier/src/types/vk.rs

@@ -1,7 +1,7 @@
 use std::fmt::Debug;
 
-use borsh::BorshDeserialize;
-use serde::{de::DeserializeOwned, Serialize};
+use borsh::{BorshDeserialize, BorshSerialize};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
 use crate::{
     ProofReceipt, ProofReceiptWithMetadata, PublicValues, VerifyingKey, VerifyingKeyCommitment,
@@ -77,3 +77,16 @@ pub trait ZkVmOutputExtractor: Send + Sync + Clone + Debug + 'static {
             .map_err(|e| ZkVmError::OutputExtractionError { source: e.into() })
     }
 }
+
+/// A no-op verifier: its `verify` method does nothing and always returns success.
+///
+/// Use this when you want to bypass verification logic entirely. It performs
+/// no cryptographic checks on the proof receipt.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
+pub struct NoopVerifier;
+
+impl ZkVmVerifier for NoopVerifier {
+    fn verify(&self, _receipt: &ProofReceipt) -> ZkVmResult<()> {
+        Ok(())
+    }
+}