Simplify API

utils/cw-proof/src/verifier/cw.rs

@@ -1,3 +1,4 @@
+use alloc::borrow::Cow;
 use alloc::vec::Vec;
 
 use ics23::CommitmentProof;
@@ -5,10 +6,13 @@ use ics23::CommitmentProof;
 use crate::error::ProofError;
 use crate::verifier::{ics23::Ics23MembershipVerifier, multi::MultiVerifier, Verifier};
 
-#[derive(Clone, Debug)]
+type Key = Vec<u8>;
-pub struct CwVerifier(MultiVerifier<Ics23MembershipVerifier<Vec<u8>>, 2>);
+type Value<'a> = Cow<'a, [u8]>;
 
-impl CwVerifier {
+#[derive(Clone, Debug)]
+pub struct CwVerifier<'a>(MultiVerifier<Ics23MembershipVerifier<Key, Value<'a>>, 2>);
+
+impl CwVerifier<'_> {
     pub fn verify(
         &self,
         proofs: &[CommitmentProof; 2],
@@ -20,7 +24,8 @@ impl CwVerifier {
             return Err(ProofError::EmptyMerkleRoot);
         }
 
-        let verified = self.0.verify_against_root(proofs, keys, value, root)?;
+        let value = Cow::Borrowed(value);
+        let verified = self.0.verify_against_root(proofs, keys, &value, root)?;
         if !verified {
             return Err(ProofError::VerificationFailure);
         }
@@ -29,7 +34,7 @@ impl CwVerifier {
     }
 }
 
-impl Default for CwVerifier {
+impl Default for CwVerifier<'_> {
     fn default() -> Self {
         let mv = MultiVerifier::new([
             Ics23MembershipVerifier::new(ics23::iavl_spec()),

utils/cw-proof/src/verifier/ics23.rs

@@ -10,12 +10,12 @@ use crate::error::ProofError;
 use crate::verifier::Verifier;
 
 #[derive(Clone, Debug)]
-pub struct Ics23MembershipVerifier<K> {
+pub struct Ics23MembershipVerifier<K, V> {
     spec: ProofSpec,
-    _phantom: PhantomData<K>,
+    _phantom: PhantomData<(K, V)>,
 }
 
-impl<K> Ics23MembershipVerifier<K> {
+impl<K, V> Ics23MembershipVerifier<K, V> {
     pub fn new(spec: ProofSpec) -> Self {
         Self {
             spec,
@@ -24,22 +24,22 @@ impl<K> Ics23MembershipVerifier<K> {
     }
 }
 
-impl<K> Verifier for Ics23MembershipVerifier<K>
+impl<K, V> Verifier for Ics23MembershipVerifier<K, V>
 where
     K: AsRef<[u8]>,
+    V: AsRef<[u8]>,
 {
     type Proof = CommitmentProof;
     type Root = Vec<u8>;
     type Key = K;
-    type Value = Vec<u8>;
+    type Value = V;
-    type ValueRef = [u8];
     type Error = ProofError;
 
     fn verify(
         &self,
         commitment_proof: &Self::Proof,
         key: &Self::Key,
-        value: &Self::ValueRef,
+        value: &Self::Value,
     ) -> Result<Self::Root, Self::Error> {
         if value.as_ref().is_empty() {
             return Err(ProofError::EmptyVerifiedValue);
@@ -57,7 +57,7 @@ where
             &self.spec,
             &root,
             key.as_ref(),
-            value,
+            value.as_ref(),
         ) {
             return Err(ProofError::VerificationFailure);
         }

utils/cw-proof/src/verifier/mod.rs

@@ -1,6 +1,3 @@
-use alloc::borrow::ToOwned;
-use core::borrow::Borrow;
-
 pub mod cw;
 pub mod ics23;
 pub mod multi;
@@ -9,22 +6,21 @@ trait Verifier {
     type Proof;
     type Root: Eq;
     type Key;
-    type Value: Borrow<Self::ValueRef>;
+    type Value;
-    type ValueRef: ?Sized + ToOwned<Owned = Self::Value>;
     type Error;
 
     fn verify(
         &self,
         proof: &Self::Proof,
         key: &Self::Key,
-        value: &Self::ValueRef,
+        value: &Self::Value,
     ) -> Result<Self::Root, Self::Error>;
 
     fn verify_against_root(
         &self,
         proof: &Self::Proof,
         key: &Self::Key,
-        value: &Self::ValueRef,
+        value: &Self::Value,
         root: &Self::Root,
     ) -> Result<bool, Self::Error> {
         let found_root = self.verify(proof, key, value)?;

utils/cw-proof/src/verifier/multi.rs

@@ -1,6 +1,3 @@
-use alloc::borrow::ToOwned;
-use core::borrow::Borrow;
-
 use crate::verifier::Verifier;
 
 #[derive(Clone, Debug)]
@@ -19,27 +16,27 @@ impl<V, const N: usize> Verifier for MultiVerifier<V, N>
 where
     V: Verifier,
     V::Root: Into<V::Value> + Clone,
+    V::Value: Clone,
 {
     type Proof = [V::Proof; N];
     type Root = V::Root;
     type Key = [V::Key; N];
     type Value = V::Value;
-    type ValueRef = V::ValueRef;
     type Error = V::Error;
 
     fn verify(
         &self,
         proofs: &Self::Proof,
         keys: &Self::Key,
-        value: &Self::ValueRef,
+        value: &Self::Value,
     ) -> Result<Self::Root, Self::Error> {
         let mut root = None;
-        let mut value: V::Value = value.to_owned();
+        let mut value: V::Value = value.clone();
 
         for (idx, verifier) in self.verifiers.iter().enumerate() {
             let proof = &proofs[idx];
             let key = &keys[N - idx - 1];
-            let sub_root = verifier.verify(proof, key, value.borrow())?;
+            let sub_root = verifier.verify(proof, key, &value)?;
 
             value = sub_root.clone().into();
             root = Some(sub_root);