Fix AsBytes trait

src/app/store/avl/as_bytes.rs

@@ -1,49 +1,63 @@
 //! # AsBytes trait definition
 //!
-//! This module hosts the `AsBytes` traits, which is used by the AVL Tree to convert value to raw
+//! This module hosts the `AsBytes` trait, which is used by the AVL Tree to convert value to raw
 //! bytes. This is helpful for making the AVL Tree generic over a wide range of data types for its
 //! keys (the values still need to implement `Borrow<[u8]>), as long as they can be interpreted as
 //! a slice of bytes.
 //!
 //! To add support for a new type in the AVL Tree, simply implement the `AsByte` trait for that type.
 
+pub enum ByteSlice<'a> {
+    Slice(&'a [u8]),
+    Vector(Vec<u8>),
+}
+
+impl AsRef<[u8]> for ByteSlice<'_> {
+    fn as_ref(&self) -> &[u8] {
+        match self {
+            ByteSlice::Slice(s) => *s,
+            ByteSlice::Vector(v) => v.as_slice(),
+        }
+    }
+}
+
 /// A trait for objects that can be interpreted as a slice of bytes.
 pub trait AsBytes {
-    fn as_bytes(&self) -> &[u8];
+    fn as_bytes(&self) -> ByteSlice;
 }
 
 impl AsBytes for Vec<u8> {
-    fn as_bytes(&self) -> &[u8] {
-        self.as_slice()
+    fn as_bytes(&self) -> ByteSlice {
+        ByteSlice::Slice(self)
     }
 }
 
 impl AsBytes for [u8] {
-    fn as_bytes(&self) -> &[u8] {
-        self
+    fn as_bytes(&self) -> ByteSlice {
+        ByteSlice::Slice(self)
     }
 }
 
 impl AsBytes for str {
-    fn as_bytes(&self) -> &[u8] {
-        self.as_bytes()
+    fn as_bytes(&self) -> ByteSlice {
+        ByteSlice::Slice(self.as_bytes())
     }
 }
 
 impl AsBytes for &str {
-    fn as_bytes(&self) -> &[u8] {
-        (*self).as_bytes()
+    fn as_bytes(&self) -> ByteSlice {
+        ByteSlice::Slice((*self).as_bytes())
     }
 }
 
 impl AsBytes for String {
-    fn as_bytes(&self) -> &[u8] {
-        self.as_bytes()
+    fn as_bytes(&self) -> ByteSlice {
+        ByteSlice::Slice(self.as_bytes())
     }
 }
 
 impl AsBytes for [u8; 1] {
-    fn as_bytes(&self) -> &[u8] {
-        self
+    fn as_bytes(&self) -> ByteSlice {
+        ByteSlice::Slice(self)
     }
 }

src/app/store/avl/mod.rs

@@ -14,7 +14,7 @@
 
 use tendermint::hash::Algorithm;
 
-pub use as_bytes::AsBytes;
+pub use as_bytes::{AsBytes, ByteSlice};
 pub use node::AvlNode;
 pub use proof::get_proof_spec;
 pub use tree::AvlTree;

src/app/store/avl/node.rs

@@ -36,7 +36,7 @@ where
     fn new(key: K, value: V) -> Self {
         let mut sha = Sha256::new();
         sha.update(proof::LEAF_PREFIX);
-        sha.update(key.as_bytes());
+        sha.update(key.as_bytes().as_ref());
         sha.update(value.borrow());
         let hash = sha.finalize();
         let merkle_hash = Hash::from_bytes(HASH_ALGO, &Sha256::digest(&hash)).unwrap();

src/app/store/avl/tree.rs

@@ -118,7 +118,7 @@ where
                         prefix: proof::LEAF_PREFIX.to_vec(),
                     });
                     let proof = ExistenceProof {
-                        key: node.key.as_bytes().to_owned(),
+                        key: node.key.as_bytes().as_ref().to_owned(),
                         value: node.value.borrow().to_owned(),
                         leaf,
                         path: vec![],

src/app/store/memory.rs

@@ -1,4 +1,4 @@
-use crate::app::store::avl::{AsBytes, AvlTree};
+use crate::app::store::avl::{AsBytes, AvlTree, ByteSlice};
 use crate::app::store::{Height, Path, ProvableStore, Store};
 
 use ics23::CommitmentProof;
@@ -81,7 +81,12 @@ impl Store for InMemoryStore {
         self.pending
             .get_keys()
             .into_iter()
-            .filter_map(|key| key.as_bytes().starts_with(key_prefix).then(|| key.clone()))
+            .filter_map(|key| {
+                key.as_bytes()
+                    .as_ref()
+                    .starts_with(key_prefix.as_ref())
+                    .then(|| key.clone())
+            })
             .collect()
     }
 }
@@ -101,9 +106,8 @@ impl ProvableStore for InMemoryStore {
 }
 
 impl AsBytes for Path {
-    fn as_bytes(&self) -> &[u8] {
-        // self.as_str().as_bytes()
-        todo!()
+    fn as_bytes(&self) -> ByteSlice {
+        ByteSlice::Vector(self.to_string().into_bytes())
     }
 }