zk tracer: add a bool pass through instead of using if let idiom. As a consequence we change weaker matches into stronger unwraps.

example/zk.rs

@@ -65,7 +65,7 @@ fn main() -> Result<()> {
     let public_inputs = vec![*value_coords.x(), *value_coords.y()];
 
     // Create the circuit
-    let circuit = ZkCircuit::new(prover_witnesses, &zkbin.clone());
+    let mut circuit = ZkCircuit::new(prover_witnesses, &zkbin.clone());
     circuit.enable_trace();
 
     let now = std::time::Instant::now();

src/zk/tracer.rs

@@ -18,55 +18,74 @@ pub enum DebugOpValue {
 pub struct ZkTracer {
     pub opvalues: RefCell<Option<Vec<DebugOpValue>>>,
     init_allowed: bool,
+    is_enabled: bool,
 }
 
 impl ZkTracer {
     pub(crate) fn new(init_allowed: bool) -> Self {
-        Self { opvalues: RefCell::new(None), init_allowed }
+        Self { opvalues: RefCell::new(None), init_allowed, is_enabled: false }
     }
 
-    pub(crate) fn init(&self) {
+    pub(crate) fn init(&mut self) {
         if !self.init_allowed {
-            return
+            panic!("Cannot initialize tracer for verifier circuit!");
         }
+        self.is_enabled = true;
         *self.opvalues.borrow_mut() = Some(Vec::new());
     }
 
     pub(crate) fn clear(&self) {
-        if let Some(opvalues) = self.opvalues.borrow_mut().deref_mut() {
-            opvalues.clear();
+        if !self.is_enabled {
+            return
         }
+
+        self.opvalues.borrow_mut().as_mut().unwrap().clear();
+    }
+
+    fn push(&self, value: DebugOpValue) {
+        let mut binding = self.opvalues.borrow_mut();
+        let opvalues = binding.as_mut().unwrap();
+        opvalues.push(value);
     }
 
     pub(crate) fn push_ecpoint(
         &self,
         point: &ecc_gadget::Point<pallas::Affine, ecc_gadget::chip::EccChip<OrchardFixedBases>>,
     ) {
-        if let Some(opvalues) = self.opvalues.borrow_mut().deref_mut() {
-            let (mut x, mut y) = (pallas::Base::ZERO, pallas::Base::ZERO);
-            point.inner().x().value().map(|rx| x = *rx);
-            point.inner().y().value().map(|ry| y = *ry);
-            opvalues.push(DebugOpValue::EcPoint(x, y));
+        if !self.is_enabled {
+            return
         }
+
+        let (mut x, mut y) = (pallas::Base::ZERO, pallas::Base::ZERO);
+        point.inner().x().value().map(|rx| x = *rx);
+        point.inner().y().value().map(|ry| y = *ry);
+        self.push(DebugOpValue::EcPoint(x, y));
     }
 
     pub(crate) fn push_base(&self, value: &AssignedCell<pallas::Base, pallas::Base>) {
-        if let Some(opvalues) = self.opvalues.borrow_mut().deref_mut() {
-            let mut x = pallas::Base::ZERO;
-            value.value().map(|rx| x = *rx);
-            opvalues.push(DebugOpValue::Base(x));
+        if !self.is_enabled {
+            return
         }
+
+        let mut x = pallas::Base::ZERO;
+        value.value().map(|rx| x = *rx);
+        self.push(DebugOpValue::Base(x));
     }
 
     pub(crate) fn push_void(&self) {
-        if let Some(opvalues) = self.opvalues.borrow_mut().deref_mut() {
-            opvalues.push(DebugOpValue::Void);
+        if !self.is_enabled {
+            return
         }
+
+        self.push(DebugOpValue::Void);
     }
 
     pub(crate) fn assert_correct(&self, opcodes_len: usize) {
-        if let Some(opvalues) = self.opvalues.borrow().deref() {
-            assert_eq!(opvalues.len(), opcodes_len);
+        if !self.is_enabled {
+            return
         }
+
+        let opvalues_len = self.opvalues.borrow().as_ref().map_or(0, |v| v.len());
+        assert_eq!(opvalues_len, opcodes_len);
     }
 }

src/zk/vm.rs

@@ -282,7 +282,7 @@ impl ZkCircuit {
         }
     }
 
-    pub fn enable_trace(&self) {
+    pub fn enable_trace(&mut self) {
         self.tracer.init();
     }
 }