Refactor witness::Witness

- Remove unused methods
- Push fields directly into the witness vector, instead of allocating
  a temporary vector

Author: sebastiencs

ledger/src/proofs/transaction.rs

@@ -3777,14 +3777,14 @@ pub fn compute_witness<C: ProofConstants, F: FieldWitness>(
     w: &Witness<F>,
 ) -> [Vec<F>; COLUMNS] {
     if !w.ocaml_aux.is_empty() {
-        assert_eq!(w.aux.len(), w.ocaml_aux.len());
+        assert_eq!(w.aux().len(), w.ocaml_aux.len());
     };
 
     let external_values = |i: usize| {
         if i < C::PRIMARY_LEN {
             w.primary[i]
         } else {
-            w.aux[i - C::PRIMARY_LEN]
+            w.aux()[i - C::PRIMARY_LEN]
         }
     };
 
@@ -4011,7 +4011,7 @@ mod tests_with_wasm {
 
         assert_eq!(res, (131085.into(), 65636.into(), 1866.into()));
         assert_eq!(
-            witness.aux,
+            witness.aux(),
             &[
                 0.into(),
                 0.into(),

ledger/src/proofs/witness.rs

@@ -7,8 +7,8 @@ use super::{
 
 #[derive(Debug)]
 pub struct Witness<F: FieldWitness> {
-    pub primary: Vec<F>,
-    pub(super) aux: Vec<F>,
+    pub(super) primary: Vec<F>,
+    aux: Vec<F>,
     // Following fields are used to compare our witness with OCaml
     pub ocaml_aux: Vec<F>,
     ocaml_aux_index: usize,
@@ -33,86 +33,57 @@ impl<F: FieldWitness> Witness<F> {
         }
     }
 
-    pub fn push<I: Into<F>>(&mut self, field: I) {
-        let field = {
-            let field: F = field.into();
-            // dbg!(field)
-            field
-        };
-        self.assert_ocaml_aux(&[field]);
-        self.aux.push(field);
-    }
-
-    pub fn extend<I: Into<F>, V: Iterator<Item = I>>(&mut self, field: V) {
-        let fields = {
-            let fields: Vec<F> = field.map(Into::into).collect();
-            self.assert_ocaml_aux(&fields);
-            // eprintln!("extend[{}]={:#?}", fields.len(), fields);
-            fields
-        };
-        self.aux.extend(fields)
+    pub(super) fn aux(&self) -> &[F] {
+        &self.aux
     }
 
     pub fn exists<T>(&mut self, data: T) -> T
     where
         T: ToFieldElements<F> + Check<F>,
     {
-        // data.to_field_elements(&mut self.aux);
-        let mut fields = data.to_field_elements_owned();
-        self.assert_ocaml_aux(&fields);
-
-        // eprintln!("index={:?} w{:?}", self.aux.len() + 67, &fields);
-        if self.ocaml_aux.len() > 0 {
-            eprintln!(
-                "index={:?} w{:?}",
-                self.aux.len() + self.primary.capacity(),
-                &fields
-            );
-        }
-        self.aux.append(&mut fields);
-
+        let data = self.exists_no_check(data);
         data.check(self);
         data
     }
 
+    /// Same as `Self::exists`, but do not call `Check::check` on `data`
+    /// We use this wherever `seal` is used in OCaml, or on `if_` conditions
     pub fn exists_no_check<T>(&mut self, data: T) -> T
     where
         T: ToFieldElements<F>,
     {
-        // data.to_field_elements(&mut self.aux);
-        let mut fields = data.to_field_elements_owned();
-        self.assert_ocaml_aux(&fields);
-
-        // eprintln!("index={:?} w{:?}", self.aux.len() + 67, &fields);
-        if self.ocaml_aux.len() > 0 {
-            eprintln!(
-                "index={:?} w{:?}",
-                self.aux.len() + self.primary.capacity(),
-                &fields
-            );
-        }
-        self.aux.append(&mut fields);
+        #[cfg(test)]
+        let start = self.aux.len();
+
+        data.to_field_elements(&mut self.aux);
+
+        #[cfg(test)]
+        self.assert_ocaml_aux(start);
 
         data
     }
 
     /// Compare our witness with OCaml
-    fn assert_ocaml_aux(&mut self, new_fields: &[F]) {
+    #[cfg(test)]
+    fn assert_ocaml_aux(&mut self, start_offset: usize) {
         if self.ocaml_aux.is_empty() {
             return;
         }
 
-        // let len = new_fields.len();
-        // let before = self.aux.len();
-        // let ocaml = &self.ocaml_aux[before..before + len];
-        // eprintln!("w{:?} ocaml{:?} {:?}", new_fields, ocaml, new_fields == ocaml);
-
+        let new_fields = &self.aux[start_offset..];
         let len = new_fields.len();
-        let before = self.aux.len();
-        assert_eq!(before, self.ocaml_aux_index);
-        assert_eq!(new_fields, &self.ocaml_aux[before..before + len]);
+        let ocaml_fields = &self.ocaml_aux[start_offset..start_offset + len];
+
+        assert_eq!(start_offset, self.ocaml_aux_index);
+        assert_eq!(new_fields, ocaml_fields);
 
         self.ocaml_aux_index += len;
+
+        eprintln!(
+            "index={:?} w{:?}",
+            self.aux.len() + self.primary.capacity(),
+            &self.aux[start_offset..]
+        );
     }
 
     /// Helper