feat: Diff Tracking SP1 patches

pcs/Cargo.toml

@@ -28,6 +28,10 @@ jf-utils = { git = "https://github.com/EspressoSystems/jellyfish", tag = "0.4.5"
 merlin = { workspace = true }
 rayon = { version = "1.5.0", optional = true }
 
+[target.'cfg(all(target_os = "zkvm", target_vendor = "succinct"))'.dependencies]
+sp1-zkvm = { git = "https://github.com/succinctlabs/sp1.git", tag = "v1.1.0" }
+ark-bn254 = { workspace = true }
+
 [dev-dependencies]
 ark-bls12-381 = { workspace = true }
 ark-bn254 = { workspace = true }

pcs/src/univariate_kzg/mod.rs

@@ -32,12 +32,15 @@ use ark_std::{
     vec::Vec,
     One, UniformRand, Zero,
 };
+use core::any::TypeId;
 use jf_utils::par_utils::parallelizable_slice_iter;
 #[cfg(feature = "parallel")]
 use rayon::prelude::*;
 use srs::{UnivariateProverParam, UnivariateUniversalParams, UnivariateVerifierParam};
 
 pub(crate) mod srs;
+#[cfg(all(target_os = "zkvm", target_vendor = "succinct"))]
+mod succinct;
 
 /// KZG Polynomial Commitment Scheme on univariate polynomial.
 pub struct UnivariateKzgPCS<E> {
@@ -104,6 +107,15 @@ impl<E: Pairing> PolynomialCommitmentScheme for UnivariateKzgPCS<E> {
             )));
         }
 
+        #[cfg(all(target_os = "zkvm", target_vendor = "succinct"))]
+        if TypeId::of::<E>() == TypeId::of::<ark_bn254::Bn254>() {
+            let points: &[ark_bn254::G1Affine] =
+                unsafe { ark_std::mem::transmute(&prover_param.powers_of_g[..]) };
+            let scalars: &[ark_bn254::Fr] = unsafe { ark_std::mem::transmute(poly.coeffs()) };
+            let commitment =
+                unsafe { ark_std::mem::transmute_copy(&succinct::msm(points, scalars)) };
+            return Ok(Commitment(commitment));
+        }
         let (num_leading_zeros, plain_coeffs) = skip_leading_zeros_and_convert_to_bigints(poly);
 
         #[cfg(feature = "kzg-print-trace")]

pcs/src/univariate_kzg/succinct.rs

@@ -0,0 +1,67 @@
+use ark_ec::pairing::Pairing;
+use ark_ff::{BigInt, BigInteger, PrimeField, Zero};
+
+#[derive(Clone, Copy, Debug)]
+pub struct BnAffinePoint(pub BigInt<4>, pub BigInt<4>);
+
+pub fn wrap_g1affine(p: &G1Affine) -> BnAffinePoint {
+    BnAffinePoint(p.x.into_bigint(), p.y.into_bigint())
+}
+
+pub fn unwrap_g1affine(p: &BnAffinePoint) -> G1Affine {
+    G1Affine {
+        x: p.0.into(),
+        y: p.1.into(),
+        infinity: false,
+    }
+}
+
+pub fn msm(p: &[G1Affine], s: &[ScalarField]) -> G1Affine {
+    let mut iter = p.iter().zip(s).filter(|(_, s)| !s.is_zero());
+    let mut result = {
+        let (p, s) = iter.next().unwrap();
+        let mut p = wrap_g1affine(p);
+        bn254_double_and_add(&mut p, s);
+        p
+    };
+    iter.for_each(|(p, s)| {
+        let mut p = wrap_g1affine(p);
+        bn254_double_and_add(&mut p, s);
+        bn254_add(&mut result, &p);
+    });
+    unwrap_g1affine(&result)
+}
+
+pub fn bn254_add(p: &mut BnAffinePoint, q: &BnAffinePoint) {
+    sp1_zkvm::syscalls::syscall_bn254_add(
+        p as *mut _ as *mut [u32; 16],
+        q as *const _ as *const [u32; 16],
+    );
+}
+
+pub fn bn254_double_and_add(p: &mut BnAffinePoint, s: &ScalarField) {
+    let mut t = *p;
+    let mut b = s.into_bigint().to_bits_le().into_iter();
+    let mut q = {
+        b.by_ref().take_while(|b| !b).for_each(|_| {
+            sp1_zkvm::syscalls::syscall_bn254_double(&mut t as *mut _ as *mut [u32; 16]);
+        });
+        t
+    };
+    b.for_each(|b| {
+        // double in place
+        sp1_zkvm::syscalls::syscall_bn254_double(&mut t as *mut _ as *mut [u32; 16]);
+        if b {
+            sp1_zkvm::syscalls::syscall_bn254_add(
+                &mut q as *mut _ as *mut [u32; 16],
+                &t as *const _ as *const [u32; 16],
+            );
+        }
+    });
+
+    *p = q
+}
+
+pub type E = ark_bn254::Bn254;
+pub type G1Affine = <E as Pairing>::G1Affine;
+pub type ScalarField = <E as Pairing>::ScalarField;

vid/src/advz/payload_prover.rs

@@ -51,9 +51,10 @@ pub struct SmallRangeProof<P> {
 /// A proof intended for use on large payload subslices.
 ///
 /// Metadata needed to recover a KZG commitment.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[serde(bound = "F: CanonicalSerialize + CanonicalDeserialize")]
-pub struct LargeRangeProof<F> {
+#[derive(
+    Clone, Debug, Eq, PartialEq, CanonicalSerialize, CanonicalDeserialize, Serialize, Deserialize,
+)]
+pub struct LargeRangeProof<F: CanonicalSerialize + CanonicalDeserialize> {
     #[serde(with = "canonical")]
     prefix_elems: Vec<F>,
     #[serde(with = "canonical")]