Borrow/ToOwned impl for Verifier::Value

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

@@ -6,7 +6,7 @@ use crate::error::ProofError;
 use crate::verifier::{ics23::Ics23MembershipVerifier, multi::MultiVerifier, Verifier};
 
 #[derive(Clone, Debug)]
-pub struct CwVerifier(MultiVerifier<Ics23MembershipVerifier<Vec<u8>, Vec<u8>>, 2>);
+pub struct CwVerifier(MultiVerifier<Ics23MembershipVerifier<Vec<u8>>, 2>);
 
 impl CwVerifier {
     pub fn verify(
@@ -14,7 +14,7 @@ impl CwVerifier {
         proofs: &[CommitmentProof; 2],
         root: &Vec<u8>,
         keys: &[Vec<u8>; 2],
-        value: &Vec<u8>,
+        value: &[u8],
     ) -> Result<(), ProofError> {
         if root.is_empty() {
             return Err(ProofError::EmptyMerkleRoot);

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, V> {
+pub struct Ics23MembershipVerifier<K> {
     spec: ProofSpec,
-    _phantom: PhantomData<(K, V)>,
+    _phantom: PhantomData<K>,
 }
 
-impl<K, V> Ics23MembershipVerifier<K, V> {
+impl<K> Ics23MembershipVerifier<K> {
     pub fn new(spec: ProofSpec) -> Self {
         Self {
             spec,
@@ -24,22 +24,22 @@ impl<K, V> Ics23MembershipVerifier<K, V> {
     }
 }
 
-impl<K, V> Verifier for Ics23MembershipVerifier<K, V>
+impl<K> Verifier for Ics23MembershipVerifier<K>
 where
     K: AsRef<[u8]>,
-    V: AsRef<[u8]>,
 {
     type Proof = CommitmentProof;
     type Root = Vec<u8>;
     type Key = K;
-    type Value = V;
+    type Value = Vec<u8>;
+    type ValueRef = [u8];
     type Error = ProofError;
 
     fn verify(
         &self,
         commitment_proof: &Self::Proof,
         key: &Self::Key,
-        value: &Self::Value,
+        value: &Self::ValueRef,
     ) -> 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.as_ref(),
+            value,
         ) {
             return Err(ProofError::VerificationFailure);
         }

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

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

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

@@ -1,3 +1,6 @@
+use alloc::borrow::ToOwned;
+use core::borrow::Borrow;
+
 use crate::verifier::Verifier;
 
 #[derive(Clone, Debug)]
@@ -15,28 +18,28 @@ impl<V, const N: usize> MultiVerifier<V, N> {
 impl<V, const N: usize> Verifier for MultiVerifier<V, N>
 where
     V: Verifier,
-    V::Value: Clone,
     V::Root: Into<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::Value,
+        value: &Self::ValueRef,
     ) -> Result<Self::Root, Self::Error> {
         let mut root = None;
-        let mut value = value.clone();
+        let mut value: V::Value = value.to_owned();
 
         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)?;
+            let sub_root = verifier.verify(proof, key, value.borrow())?;
 
             value = sub_root.clone().into();
             root = Some(sub_root);