fix: audit fixes

plonky2x/core/Cargo.toml

@@ -14,7 +14,7 @@ ci = []
 
 [dependencies]
 plonky2 = { git = "https://github.com/mir-protocol/plonky2.git", default-features = false, rev = "2d36559d" }
-curta = { git = "https://github.com/succinctlabs/curta.git" }
+curta = { git = "https://github.com/succinctlabs/curta.git", branch = "tamir/audit_fixes" }
 plonky2x-derive = { path = "../derive" }
 
 num = { version = "0.4", default-features = false }

plonky2x/core/src/backend/circuit/serialization/hints.rs

@@ -52,7 +52,6 @@ use crate::frontend::eth::beacon::vars::{
     BeaconBalancesVariable, BeaconHeaderVariable, BeaconValidatorVariable,
     BeaconValidatorsVariable, BeaconWithdrawalVariable, BeaconWithdrawalsVariable,
 };
-use crate::frontend::eth::mpt::generators::LteGenerator;
 use crate::frontend::eth::storage::generators::{
     EthBlockGenerator, EthLogGenerator, EthStorageKeyGenerator, EthStorageProofHint,
 };
@@ -368,9 +367,6 @@ where
         let comparison_generator_id = ComparisonGenerator::<L::Field, D>::id();
         r.register_simple::<ComparisonGenerator<L::Field, D>>(comparison_generator_id);
 
-        let le_generator_id = LteGenerator::<L, D>::id();
-        r.register_simple::<LteGenerator<L, D>>(le_generator_id);
-
         r.register_hint::<BeaconBalanceWitnessHint>();
 
         r.register_async_hint::<BeaconAllWithdrawalsHint>();

plonky2x/core/src/frontend/curta/builder.rs

@@ -90,7 +90,7 @@ mod tests {
 
         const NUM_ARITHMETIC_COLUMNS: usize = 0;
         const NUM_FREE_COLUMNS: usize = 18;
-        const EXTENDED_COLUMNS: usize = 24;
+        const EXTENDED_COLUMNS: usize = 36;
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]

plonky2x/core/src/frontend/curta/proof.rs

@@ -929,7 +929,7 @@ mod tests {
         let hint = ProofReadHint { proof };
         let output_stream = builder.hint(input_stream, hint);
         let proof_variable = output_stream.read_stark_proof(&mut builder, &stark, &config);
-        let public_input_variable = output_stream.read_exact_unsafe(&mut builder, 3);
+        let public_input_variable = output_stream.read_exact(&mut builder, 3);
 
         builder.verify_stark_proof(
             &config,

plonky2x/core/src/frontend/ecc/curve25519/curta/accelerator.rs

@@ -1,9 +1,8 @@
-use super::request::EcOpRequest;
+use super::request::{EcOpRequest, EcOpResponse};
 use super::Curve;
-use crate::frontend::curta::ec::point::AffinePointVariable;
 
 #[derive(Debug, Clone)]
 pub struct EcOpAccelerator {
     pub ec_op_requests: Vec<EcOpRequest<Curve>>,
-    pub ec_op_responses: Vec<Option<AffinePointVariable<Curve>>>,
+    pub ec_op_responses: Vec<EcOpResponse<Curve>>,
 }

plonky2x/core/src/frontend/ecc/curve25519/curta/builder.rs

@@ -1,10 +1,13 @@
+use curta::chip::ec::EllipticCurveParameters;
+
 use super::accelerator::EcOpAccelerator;
 use super::proof_hint::EcOpProofHint;
-use super::request::EcOpRequest;
+use super::request::{EcOpRequest, EcOpResponse};
 use super::result_hint::EcOpResultHint;
 use super::stark::{Ed25519OpVariable, Ed25519Stark};
 use super::Curve;
 use crate::frontend::curta::ec::point::AffinePointVariable;
+use crate::frontend::curta::field::variable::FieldVariable;
 use crate::frontend::hint::synchronous::Async;
 use crate::prelude::{CircuitBuilder, PlonkParameters, VariableStream};
 
@@ -39,17 +42,23 @@ impl<L: PlonkParameters<D>, const D: usize> CircuitBuilder<L, D> {
 
             let output_stream = self.hint(input_stream, result_hint);
 
-            match &request {
-                EcOpRequest::Add(_, _)
-                | EcOpRequest::ScalarMul(_, _)
-                | EcOpRequest::Decompress(_) => {
-                    let result = output_stream.read::<AffinePointVariable<Curve>>(self);
-                    self.assert_is_equal(
-                        result,
-                        response.clone().expect("response should not be None"),
-                    );
+            match response {
+                EcOpResponse::Add(c) => {
+                    let c_hint = output_stream.read_unsafe::<AffinePointVariable<Curve>>(self);
+                    self.assert_is_equal(c_hint, c.clone());
+                }
+                EcOpResponse::ScalarMul(c) => {
+                    let c_hint = output_stream.read_unsafe::<AffinePointVariable<Curve>>(self);
+                    self.assert_is_equal(c_hint, c.clone());
                 }
-                EcOpRequest::IsValid(_) => {}
+                EcOpResponse::Decompress(point, root) => {
+                    let point_hint = output_stream.read_unsafe::<AffinePointVariable<Curve>>(self);
+                    let root_hint = output_stream
+                        .read::<FieldVariable<<Curve as EllipticCurveParameters>::BaseField>>(self);
+                    self.assert_is_equal(point_hint, point.clone());
+                    self.assert_is_equal(root_hint, root.clone());
+                }
+                EcOpResponse::IsValid => {}
             }
         }
 
@@ -63,42 +72,40 @@ impl<L: PlonkParameters<D>, const D: usize> CircuitBuilder<L, D> {
             .zip(accelerator.ec_op_responses.iter())
         {
             requests.push(request.req_type());
-            match &request {
-                EcOpRequest::Add(a, b) => {
-                    let response = response.as_ref().unwrap();
-                    input_stream.write(&**a);
-                    input_stream.write(&**b);
-                    input_stream.write(response);
-                    ec_ops.push(Ed25519OpVariable::Add(
-                        *a.clone(),
-                        *b.clone(),
-                        response.clone(),
-                    ))
+            match (request, response) {
+                (EcOpRequest::Add(a, b), EcOpResponse::Add(c)) => {
+                    input_stream.write(a.as_ref());
+                    input_stream.write(b.as_ref());
+                    input_stream.write(c);
+                    ec_ops.push(Ed25519OpVariable::Add(*a.clone(), *b.clone(), c.clone()))
                 }
-                EcOpRequest::ScalarMul(scalar, point) => {
-                    let response = response.as_ref().unwrap();
-                    input_stream.write(&**scalar);
-                    input_stream.write(&**point);
+                (EcOpRequest::ScalarMul(scalar, point), EcOpResponse::ScalarMul(response)) => {
+                    input_stream.write(scalar.as_ref());
+                    input_stream.write(point.as_ref());
                     input_stream.write(response);
                     ec_ops.push(Ed25519OpVariable::ScalarMul(
                         *scalar.clone(),
                         *point.clone(),
                         response.clone(),
                     ))
                 }
-                EcOpRequest::Decompress(compressed_point) => {
-                    let point = response.as_ref().unwrap();
-                    input_stream.write(&**compressed_point);
+                (
+                    EcOpRequest::Decompress(compressed_point),
+                    EcOpResponse::Decompress(point, root),
+                ) => {
+                    input_stream.write(compressed_point.as_ref());
                     input_stream.write(point);
                     ec_ops.push(Ed25519OpVariable::Decompress(
                         compressed_point.clone(),
                         point.clone(),
+                        root.clone(),
                     ))
                 }
-                EcOpRequest::IsValid(point) => {
-                    input_stream.write(&**point);
+                (EcOpRequest::IsValid(point), EcOpResponse::IsValid) => {
+                    input_stream.write(point.as_ref());
                     ec_ops.push(Ed25519OpVariable::IsValid(*point.clone()))
                 }
+                _ => panic!("invalid request/response pair"),
             }
         }
 

plonky2x/core/src/frontend/ecc/curve25519/curta/request.rs

@@ -2,6 +2,7 @@ use curta::chip::ec::EllipticCurve;
 use serde::{Deserialize, Serialize};
 
 use crate::frontend::curta::ec::point::{AffinePointVariable, CompressedEdwardsYVariable};
+use crate::frontend::curta::field::variable::FieldVariable;
 use crate::prelude::U256Variable;
 
 #[derive(Clone, Debug, Copy, Serialize, Deserialize)]
@@ -25,6 +26,14 @@ pub enum EcOpRequest<E: EllipticCurve> {
     IsValid(Box<AffinePointVariable<E>>),
 }
 
+#[derive(Debug, Clone)]
+pub enum EcOpResponse<E: EllipticCurve> {
+    Add(AffinePointVariable<E>),
+    ScalarMul(AffinePointVariable<E>),
+    Decompress(AffinePointVariable<E>, FieldVariable<E::BaseField>),
+    IsValid,
+}
+
 impl<E: EllipticCurve> EcOpRequest<E> {
     /// Returns the type of the request.
     pub const fn req_type(&self) -> EcOpRequestType {