spacedb 0.1.2

A cryptographically verifiable data store and universal accumulator for the Spaces protocol.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#[cfg(feature = "wasm")]
mod wasm_api {
    use alloc::format;
    use js_sys::{Array, Uint8Array};
    use wasm_bindgen::prelude::{JsValue, wasm_bindgen};

    use crate::subtree::ValueOrHash;
    use crate::{Sha256Hasher, subtree::SubTree as NativeSubTree};

    #[wasm_bindgen]
    pub struct SubTree {
        inner: NativeSubTree<Sha256Hasher>,
    }

    #[wasm_bindgen]
    impl SubTree {
        /// Creates a new SubTree.
        /// If `data` is provided (as a Uint8Array), the subtree is initialized from it;
        /// if omitted, an empty subtree is created.
        #[wasm_bindgen(constructor)]
        pub fn new(data: Option<Uint8Array>) -> Result<SubTree, JsValue> {
            match data {
                Some(array) => {
                    let buf = array.to_vec();
                    NativeSubTree::from_slice(&buf)
                        .map(|inner| SubTree { inner })
                        .map_err(|err| {
                            JsValue::from_str(&format!("Deserialization error: {:?}", err))
                        })
                }
                None => Ok(SubTree {
                    inner: NativeSubTree::empty(),
                }),
            }
        }

        /// Serializes the SubTree to a Uint8Array.
        #[wasm_bindgen]
        pub fn to_bytes(&self) -> Result<Uint8Array, JsValue> {
            let bytes = self
                .inner
                .to_vec()
                .map_err(|err| JsValue::from_str(&format!("Serialization error: {:?}", err)))?;
            Ok(Uint8Array::from(&bytes[..]))
        }

        /// Returns the root hash as a Uint8Array.
        #[wasm_bindgen]
        pub fn compute_root(&self) -> Result<Uint8Array, JsValue> {
            self.inner
                .compute_root()
                .map(|hash| Uint8Array::from(&hash[..]))
                .map_err(|err| JsValue::from_str(&format!("Error retrieving root: {:?}", err)))
        }

        /// Returns true if the subtree is empty.
        #[wasm_bindgen]
        pub fn is_empty(&self) -> bool {
            self.inner.is_empty()
        }

        /// Returns true if the subtree contains the given key.
        #[wasm_bindgen]
        pub fn contains(&self, key: &[u8]) -> Result<bool, JsValue> {
            if key.len() != 32 {
                return Err(JsValue::from_str("Invalid key length; expected 32 bytes"));
            }
            let mut key_arr = [0u8; 32];
            key_arr.copy_from_slice(key);
            self.inner
                .contains(&key_arr)
                .map_err(|err| JsValue::from_str(&format!("Contains error: {:?}", err)))
        }

        /// Inserts a full value associated with the given key.
        #[wasm_bindgen]
        pub fn insert_value(&mut self, key: &[u8], value: &[u8]) -> Result<(), JsValue> {
            if key.len() != 32 {
                return Err(JsValue::from_str("Invalid key length; expected 32 bytes"));
            }
            let mut key_arr = [0u8; 32];
            key_arr.copy_from_slice(key);
            self.inner
                .insert(key_arr, ValueOrHash::Value(value.to_vec()))
                .map_err(|err| JsValue::from_str(&format!("Insert error: {:?}", err)))
        }

        /// Inserts a hash associated with the given key.
        #[wasm_bindgen]
        pub fn insert_hash(&mut self, key: &[u8], hash: &[u8]) -> Result<(), JsValue> {
            if key.len() != 32 {
                return Err(JsValue::from_str("Invalid key length; expected 32 bytes"));
            }
            if hash.len() != 32 {
                return Err(JsValue::from_str("Invalid hash length; expected 32 bytes"));
            }
            let mut key_arr = [0u8; 32];
            key_arr.copy_from_slice(key);
            let mut hash_arr = [0u8; 32];
            hash_arr.copy_from_slice(hash);
            self.inner
                .insert(key_arr, ValueOrHash::Hash(hash_arr))
                .map_err(|err| JsValue::from_str(&format!("Insert error: {:?}", err)))
        }

        /// Deletes the key from the subtree, consuming this subtree and returning a new one.
        #[wasm_bindgen]
        pub fn delete(self, key: &[u8]) -> Result<SubTree, JsValue> {
            if key.len() != 32 {
                return Err(JsValue::from_str("Invalid key length; expected 32 bytes"));
            }
            let mut key_arr = [0u8; 32];
            key_arr.copy_from_slice(key);
            self.inner
                .delete(&key_arr)
                .map(|new_tree| SubTree { inner: new_tree })
                .map_err(|err| JsValue::from_str(&format!("Delete error: {:?}", err)))
        }

        /// Returns an array of [key, value] pairs.
        /// Each key and value is a Uint8Array.
        #[wasm_bindgen]
        pub fn entries(&self) -> Result<Array, JsValue> {
            let arr = Array::new();
            for (key, value) in self.inner.iter() {
                let key_arr = Uint8Array::from(&key[..]);
                let value_arr = Uint8Array::from(&value[..]);
                let pair = Array::of2(&key_arr.into(), &value_arr.into());
                arr.push(&pair.into());
            }
            Ok(arr)
        }
    }
}