make Ptr hashing functions pure

src/circuit/circuit_frame.rs

@@ -131,8 +131,8 @@ impl<F: LurkField> EvaluationStore for Store<F> {
         self.hydrate_scalar_cache()
     }
 
-    fn ptr_eq(&self, left: &Self::Ptr, right: &Self::Ptr) -> Result<bool, Self::Error> {
-        self.ptr_eq(left, right)
+    fn ptr_eq(&self, left: &Self::Ptr, right: &Self::Ptr) -> bool {
+        self.ptr_eq(left, right).unwrap()
     }
 }
 
@@ -178,8 +178,8 @@ impl<'a, F: LurkField, C: Coprocessor<F> + 'a> MultiFrameTrait<'a, F, C> for Mul
     fn io_to_scalar_vector(
         store: &Self::Store,
         io: &<Self::EvalFrame as FrameLike<Ptr<F>, ContPtr<F>>>::FrameIO,
-    ) -> Result<Vec<F>, Self::StoreError> {
-        io.to_vector(store)
+    ) -> Vec<F> {
+        io.to_vector(store).unwrap()
     }
 
     fn compute_witness(&self, s: &Self::Store) -> WitnessCS<F> {

src/cli/commitment.rs

@@ -35,7 +35,7 @@ impl<F: LurkField> HasFieldModulus for Commitment<F> {
 impl<F: LurkField> Commitment<F> {
     pub(crate) fn new(secret: Option<F>, payload: Ptr<F>, store: &Store<F>) -> Result<Self> {
         let secret = secret.unwrap_or(F::NON_HIDING_COMMITMENT_SECRET);
-        let (hash, z_payload) = store.hide_and_return_z_payload(secret, payload)?;
+        let (hash, z_payload) = store.hide_and_return_z_payload(secret, payload);
         let mut z_store = ZStore::<F>::default();
         populate_z_store(&mut z_store, &payload, store, &mut HashMap::default())?;
         z_store.add_comm(hash, secret, z_payload);

src/cli/repl.rs

@@ -315,7 +315,7 @@ impl Repl<F> {
                 &commitment.z_store,
                 &mut Default::default(),
             )?;
-            self.store.hide(*secret, payload)?;
+            self.store.hide(*secret, payload);
             if print_data {
                 println!(
                     "{}",

src/cli/repl/meta_cmd.rs

@@ -144,7 +144,7 @@ impl MetaCmd<F> {
                 .eval_expr(second)
                 .with_context(|| "evaluating second arg")?;
             let (first_io_expr, second_io_expr) = (&first_io[0], &second_io[0]);
-            if !&repl.store.ptr_eq(first_io_expr, second_io_expr)? {
+            if !repl.store.ptr_eq(first_io_expr, second_io_expr) {
                 eprintln!(
                     "`assert-eq` failed. Expected:\n  {} = {}\nGot:\n  {} ≠ {}",
                     first.fmt_to_string(&repl.store, &repl.state.borrow()),

src/coprocessor/mod.rs

@@ -347,7 +347,7 @@ pub(crate) mod test {
                 .get_allocated_const(LEMTag::Expr(ExprTag::Num).to_field())
                 .expect("Num tag should have been allocated");
 
-            let err_cont_z_ptr = s.hash_ptr(&s.cont_error()).expect("hash_ptr failed");
+            let err_cont_z_ptr = s.hash_ptr(&s.cont_error());
             let cont_err = g
                 .get_allocated_ptr_from_z_ptr(&err_cont_z_ptr)
                 .expect("Error pointer should have been allocated");

src/coprocessor/sha256.rs

@@ -143,10 +143,7 @@ impl<F: LurkField> Coprocessor<F> for Sha256Coprocessor<F> {
     }
 
     fn evaluate_lem_simple(&self, s: &LEMStore<F>, args: &[LEMPtr<F>]) -> LEMPtr<F> {
-        let z_ptrs = args
-            .iter()
-            .map(|ptr| s.hash_ptr(ptr).unwrap())
-            .collect::<Vec<_>>();
+        let z_ptrs = args.iter().map(|ptr| s.hash_ptr(ptr)).collect::<Vec<_>>();
         LEMPtr::num(compute_sha256(self.n, &z_ptrs))
     }
 }

src/coprocessor/trie/mod.rs

@@ -133,7 +133,7 @@ impl<F: LurkField> CoCircuit<F> for NewCoprocessor<F> {
 
         // TODO: Use a custom type.
         let root = LEMPtr::num(trie.root);
-        let root_z_ptr = s.hash_ptr(&root).unwrap();
+        let root_z_ptr = s.hash_ptr(&root);
 
         AllocatedPtr::alloc_constant(cs, root_z_ptr)
     }
@@ -169,8 +169,8 @@ impl<F: LurkField> Coprocessor<F> for LookupCoprocessor<F> {
         let key_ptr = &args[1];
 
         // TODO: Check tags.
-        let root_scalar = *s.hash_ptr(root_ptr).unwrap().value();
-        let key_scalar = *s.hash_ptr(key_ptr).unwrap().value();
+        let root_scalar = *s.hash_ptr(root_ptr).value();
+        let key_scalar = *s.hash_ptr(key_ptr).value();
         let trie: StandardTrie<'_, F> =
             Trie::new_with_root(&s.poseidon_cache, &s.inverse_poseidon_cache, root_scalar);
 
@@ -320,9 +320,9 @@ impl<F: LurkField> Coprocessor<F> for InsertCoprocessor<F> {
         let root_ptr = &args[0];
         let key_ptr = &args[1];
         let val_ptr = &args[2];
-        let root_scalar = *s.hash_ptr(root_ptr).unwrap().value();
-        let key_scalar = *s.hash_ptr(key_ptr).unwrap().value();
-        let val_scalar = *s.hash_ptr(val_ptr).unwrap().value();
+        let root_scalar = *s.hash_ptr(root_ptr).value();
+        let key_scalar = *s.hash_ptr(key_ptr).value();
+        let val_scalar = *s.hash_ptr(val_ptr).value();
         let mut trie: StandardTrie<'_, F> =
             Trie::new_with_root(&s.poseidon_cache, &s.inverse_poseidon_cache, root_scalar);
         trie.insert(key_scalar, val_scalar).unwrap();

src/eval/lang.rs

@@ -140,7 +140,7 @@ impl<F: LurkField, C: Coprocessor<F>> Lang<F, C> {
 
         // TODO: this `z_ptr` is not really needed by LEM
         let ptr = store.intern_symbol(&name);
-        let z_ptr = store.hash_ptr(&ptr).unwrap();
+        let z_ptr = store.hash_ptr(&ptr);
         let z_ptr = ZExprPtr::from_parts(lurk::tag::ExprTag::Sym, *z_ptr.value());
 
         self.coprocessors.insert(name, (cproc.into(), z_ptr));

src/lem/circuit.rs

@@ -123,7 +123,7 @@ impl<F: LurkField> GlobalAllocator<F> {
     #[inline]
     pub fn get_allocated_ptr_from_z_ptr(&self, z_ptr: &ZPtr<F>) -> Result<AllocatedPtr<F>> {
         Ok(AllocatedPtr::from_parts(
-            self.get_allocated_const_cloned(z_ptr.tag().to_field())?,
+            self.get_allocated_const_cloned(z_ptr.tag_field())?,
             self.get_allocated_const_cloned(*z_ptr.value())?,
         ))
     }
@@ -217,7 +217,7 @@ pub(crate) fn allocate_slot<F: LurkField, CS: ConstraintSystem<F>>(
             SlotData::PtrVec(ptr_vec) => {
                 let mut component_idx = 0;
                 for ptr in ptr_vec {
-                    let z_ptr = store.hash_ptr(ptr)?;
+                    let z_ptr = store.hash_ptr(ptr);
 
                     // allocate pointer tag
                     preallocated_preimg.push(AllocatedNum::alloc_infallible(
@@ -237,7 +237,7 @@ pub(crate) fn allocate_slot<F: LurkField, CS: ConstraintSystem<F>>(
                 }
             }
             SlotData::FPtr(f, ptr) => {
-                let z_ptr = store.hash_ptr(ptr)?;
+                let z_ptr = store.hash_ptr(ptr);
                 // allocate first component
                 preallocated_preimg.push(AllocatedNum::alloc_infallible(
                     cs.namespace(|| format!("component 0 slot {slot}")),
@@ -382,7 +382,7 @@ impl Block {
                 }
                 Op::Lit(_, lit) => {
                     let lit_ptr = lit.to_ptr(store);
-                    let lit_z_ptr = store.hash_ptr(&lit_ptr).unwrap();
+                    let lit_z_ptr = store.hash_ptr(&lit_ptr);
                     g.new_const(cs, lit_z_ptr.tag_field());
                     g.new_const(cs, *lit_z_ptr.value());
                 }
@@ -579,7 +579,7 @@ fn synthesize_block<F: LurkField, CS: ConstraintSystem<F>, C: Coprocessor<F>>(
                     }
                     collected_ptrs
                         .iter()
-                        .map(|ptr| ctx.store.hash_ptr(ptr).expect("hash_ptr failed"))
+                        .map(|ptr| ctx.store.hash_ptr(ptr))
                         .collect::<Vec<_>>()
                 } else {
                     vec![ZPtr::dummy(); out.len()]
@@ -642,7 +642,7 @@ fn synthesize_block<F: LurkField, CS: ConstraintSystem<F>, C: Coprocessor<F>>(
                 let output_z_ptrs = if not_dummy_and_not_blank {
                     let z_ptrs = ctx.call_outputs[ctx.call_idx]
                         .iter()
-                        .map(|ptr| ctx.store.hash_ptr(ptr).expect("hash_ptr failed"))
+                        .map(|ptr| ctx.store.hash_ptr(ptr))
                         .collect::<Vec<_>>();
                     ctx.call_idx += 1;
                     assert_eq!(z_ptrs.len(), out.len());
@@ -740,7 +740,7 @@ fn synthesize_block<F: LurkField, CS: ConstraintSystem<F>, C: Coprocessor<F>>(
                 let allocated_tag = ctx.global_allocator.get_allocated_const_cloned(lit_tag)?;
                 let allocated_hash = ctx
                     .global_allocator
-                    .get_allocated_const_cloned(*ctx.store.hash_ptr(&lit_ptr)?.value())?;
+                    .get_allocated_const_cloned(*ctx.store.hash_ptr(&lit_ptr).value())?;
                 let allocated_ptr = AllocatedPtr::from_parts(allocated_tag, allocated_hash);
                 bound_allocations.insert_ptr(tgt.clone(), allocated_ptr);
             }
@@ -1217,7 +1217,7 @@ fn synthesize_block<F: LurkField, CS: ConstraintSystem<F>, C: Coprocessor<F>>(
             let mut cases_vec = Vec::with_capacity(cases.len());
             for (sym, block) in cases {
                 let sym_ptr = ctx.store.intern_symbol(sym);
-                let sym_hash = *ctx.store.hash_ptr(&sym_ptr)?.value();
+                let sym_hash = *ctx.store.hash_ptr(&sym_ptr).value();
                 cases_vec.push((sym_hash, block));
             }
 
@@ -1268,7 +1268,7 @@ impl Func {
         assert_eq!(self.output_size, frame.output.len());
         let mut output = Vec::with_capacity(frame.output.len());
         for (i, ptr) in frame.output.iter().enumerate() {
-            let zptr = store.hash_ptr(ptr)?;
+            let zptr = store.hash_ptr(ptr);
             output.push(AllocatedPtr::alloc(
                 &mut cs.namespace(|| format!("var: output[{}]", i)),
                 || Ok(zptr),
@@ -1287,7 +1287,7 @@ impl Func {
     ) -> Result<()> {
         for (i, ptr) in frame.input.iter().enumerate() {
             let param = &self.input_params[i];
-            let zptr = store.hash_ptr(ptr)?;
+            let zptr = store.hash_ptr(ptr);
             let ptr =
                 AllocatedPtr::alloc(&mut cs.namespace(|| format!("var: {param}")), || Ok(zptr))?;
             bound_allocations.insert_ptr(param.clone(), ptr);
@@ -1468,7 +1468,7 @@ impl Func {
                     }
                     Op::Lit(_, lit) => {
                         let lit_ptr = lit.to_ptr(store);
-                        let lit_z_ptr = store.hash_ptr(&lit_ptr).unwrap();
+                        let lit_z_ptr = store.hash_ptr(&lit_ptr);
                         globals.insert(FWrap(lit_z_ptr.tag_field()));
                         globals.insert(FWrap(*lit_z_ptr.value()));
                     }

src/lem/interpreter.rs

@@ -230,7 +230,7 @@ impl Block {
                     let b = bindings.get_ptr(b)?;
                     // In order to compare Ptrs, we *must* resolve the hashes. Otherwise, we risk failing to recognize equality of
                     // compound data with opaque data in either element's transitive closure.
-                    let c = store.hash_ptr(&a)?.value() == store.hash_ptr(&b)?.value();
+                    let c = store.hash_ptr(&a).value() == store.hash_ptr(&b).value();
                     bindings.insert_bool(tgt.clone(), c);
                 }
                 Op::Not(tgt, a) => {
@@ -419,7 +419,7 @@ impl Block {
                     let Ptr::Atom(Tag::Expr(Num), secret) = bindings.get_ptr(sec)? else {
                         bail!("{sec} is not a numeric pointer")
                     };
-                    let tgt_ptr = store.hide(secret, src_ptr)?;
+                    let tgt_ptr = store.hide(secret, src_ptr);
                     hints.commitment.push(Some(SlotData::FPtr(secret, src_ptr)));
                     bindings.insert_ptr(tgt.clone(), tgt_ptr);
                 }

src/lem/multiframe.rs

@@ -110,8 +110,8 @@ impl<F: LurkField> EvaluationStore for Store<F> {
         self.hydrate_z_cache()
     }
 
-    fn ptr_eq(&self, left: &Self::Ptr, right: &Self::Ptr) -> Result<bool, Self::Error> {
-        Ok(self.hash_ptr(left)? == self.hash_ptr(right)?)
+    fn ptr_eq(&self, left: &Self::Ptr, right: &Self::Ptr) -> bool {
+        self.ptr_eq(left, right)
     }
 }
 
@@ -127,7 +127,7 @@ fn assert_eq_ptrs_aptrs<F: LurkField>(
     assert_eq!(ptrs.len(), aptrs.len());
     if !blank {
         for (aptr, ptr) in aptrs.iter().zip(ptrs) {
-            let z_ptr = store.hash_ptr(ptr).expect("hash_ptr failed");
+            let z_ptr = store.hash_ptr(ptr);
             let (Some(alloc_ptr_tag), Some(alloc_ptr_hash)) =
                 (aptr.tag().get_value(), aptr.hash().get_value())
             else {
@@ -274,7 +274,7 @@ fn synthesize_frames_parallel<F: LurkField, CS: ConstraintSystem<F>, C: Coproces
                     .input
                     .iter()
                     .map(|input_ptr| {
-                        let z_ptr = store.hash_ptr(input_ptr).expect("hash_ptr failed");
+                        let z_ptr = store.hash_ptr(input_ptr);
                         AllocatedPtr::alloc(&mut frame_cs, || Ok(z_ptr)).expect("allocation failed")
                     })
                     .collect::<Vec<_>>()
@@ -339,14 +339,14 @@ impl<'a, F: LurkField, C: Coprocessor<F> + 'a> MultiFrameTrait<'a, F, C> for Mul
     fn io_to_scalar_vector(
         store: &Self::Store,
         io: &<Self::EvalFrame as FrameLike<Ptr<F>, Ptr<F>>>::FrameIO,
-    ) -> Result<Vec<F>, Self::StoreError> {
-        store.to_vector(io).map_err(|e| store::Error(e.to_string()))
+    ) -> Vec<F> {
+        store.to_scalar_vector(io)
     }
 
     fn compute_witness(&self, s: &Store<F>) -> WitnessCS<F> {
         let mut wcs = WitnessCS::new();
 
-        let z_scalar = s.to_vector(self.input.as_ref().unwrap()).unwrap();
+        let z_scalar = s.to_scalar_vector(self.input.as_ref().unwrap());
 
         let mut bogus_cs = WitnessCS::<F>::new();
         let z: Vec<AllocatedNum<F>> = z_scalar
@@ -665,7 +665,7 @@ impl<'a, F: LurkField, C: Coprocessor<F>> Circuit<F> for MultiFrame<'a, F, C> {
             |store: &Store<F>, frames: &[Frame<F>], input: &[Ptr<F>], output: &[Ptr<F>]| {
                 let mut allocated_input = Vec::with_capacity(input.len());
                 for (i, ptr) in input.iter().enumerate() {
-                    let z_ptr = store.hash_ptr(ptr).expect("pointer hashing failed");
+                    let z_ptr = store.hash_ptr(ptr);
 
                     let allocated_tag = AllocatedNum::alloc_infallible(
                         &mut cs.namespace(|| format!("allocated tag for input {i}")),
@@ -686,7 +686,7 @@ impl<'a, F: LurkField, C: Coprocessor<F>> Circuit<F> for MultiFrame<'a, F, C> {
 
                 let mut allocated_output = Vec::with_capacity(output.len());
                 for (i, ptr) in output.iter().enumerate() {
-                    let z_ptr = store.hash_ptr(ptr).expect("pointer hashing failed");
+                    let z_ptr = store.hash_ptr(ptr);
 
                     let allocated_tag = AllocatedNum::alloc_infallible(
                         &mut cs.namespace(|| format!("allocated tag for output {i}")),
@@ -758,12 +758,12 @@ impl<'a, F: LurkField, C: Coprocessor<F>> Provable<F> for MultiFrame<'a, F, C> {
         let store = self.store.expect("store missing");
         let mut res = Vec::with_capacity(self.public_input_size());
         for ptr in input {
-            let z_ptr = store.hash_ptr(ptr).expect("pointer hashing failed");
+            let z_ptr = store.hash_ptr(ptr);
             res.push(z_ptr.tag().to_field());
             res.push(*z_ptr.value());
         }
         for ptr in output {
-            let z_ptr = store.hash_ptr(ptr).expect("pointer hashing failed");
+            let z_ptr = store.hash_ptr(ptr);
             res.push(z_ptr.tag().to_field());
             res.push(*z_ptr.value());
         }
@@ -971,7 +971,7 @@ mod tests {
         let frame = frames.first().unwrap();
         let mut input = Vec::with_capacity(frame.input.len());
         for ptr in &frame.input {
-            let z_ptr = store.hash_ptr(ptr).unwrap();
+            let z_ptr = store.hash_ptr(ptr);
             let allocated_tag = AllocatedNum::alloc_infallible(&mut cs, || z_ptr.tag_field());
             allocated_tag.inputize(&mut cs).unwrap();
             let allocated_hash = AllocatedNum::alloc_infallible(&mut cs, || *z_ptr.value());