From d822ac890097baba76996b93f1aea6a96e8d377f Mon Sep 17 00:00:00 2001 From: Eshel Date: Wed, 8 Feb 2023 16:32:22 +0200 Subject: [PATCH 1/5] {Keymap, KeymapBuilder}::new() accepts str instead of bytes, Keymap::add_suffix() accepts str instead of bytes --- packages/storage/Readme.md | 22 +++++++------- packages/storage/src/keymap.rs | 54 +++++++++++++++++----------------- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/packages/storage/Readme.md b/packages/storage/Readme.md index 187017a..fdd83f6 100644 --- a/packages/storage/Readme.md +++ b/packages/storage/Readme.md @@ -268,8 +268,8 @@ use secret_toolkit::storage::{Keymap, KeymapBuilder}; # #[derive(Serialize, Deserialize)] # struct Foo { vote_for: String }; # -pub static ADDR_VOTE: Keymap = Keymap::new(b"vote"); -pub static BET_STORE: Keymap = Keymap::new(b"bet"); +pub static ADDR_VOTE: Keymap = Keymap::new("vote"); +pub static BET_STORE: Keymap = Keymap::new("bet"); ``` > ❗ Initializing the object as const instead of static will also work but be less efficient since the variable won't be able to cache length data. @@ -288,9 +288,9 @@ For example, suppose that in your contract, a user can make multiple bets. Then, # struct BetInfo { bet_outcome: u32, amount: u32 }; # let info = mock_info("sender", &[]); # -pub static BET_STORE: Keymap = Keymap::new(b"bet"); +pub static BET_STORE: Keymap = Keymap::new("bet"); // The compiler knows that user_bet_store is AppendStore -let user_count_store = BET_STORE.add_suffix(info.sender.to_string().as_bytes()); +let user_count_store = BET_STORE.add_suffix(info.sender.as_str()); ``` #### **Advanced Init** @@ -311,10 +311,10 @@ The following is used to produce a Keymap without an iterator in `state.rs` # struct Foo { vote: u32 }; # pub static JSON_ADDR_VOTE: Keymap = - KeymapBuilder::new(b"json_vote").without_iter().build(); + KeymapBuilder::new("json_vote").without_iter().build(); pub static BINCODE_ADDR_VOTE: Keymap = - KeymapBuilder::new(b"bincode_vote").without_iter().build(); + KeymapBuilder::new("bincode_vote").without_iter().build(); ``` The following is used to produce a Keymap with modified index page size: @@ -327,10 +327,10 @@ The following is used to produce a Keymap with modified index page size: # #[derive(Serialize, Deserialize)] # struct Foo { vote: u32 }; # -pub static ADDR_VOTE: Keymap = KeymapBuilder::new(b"page_vote").with_page_size(13).build(); +pub static ADDR_VOTE: Keymap = KeymapBuilder::new("page_vote").with_page_size(13).build(); pub static JSON_VOTE: Keymap = - KeymapBuilder::new(b"page_vote").with_page_size(3).build(); + KeymapBuilder::new("page_vote").with_page_size(3).build(); ``` #### **Read/Write** @@ -348,7 +348,7 @@ To insert, remove, read from the keymap, do the following: # # let mut deps = mock_dependencies(); # let info = mock_info("sender", &[]); -# pub static ADDR_VOTE: Keymap = KeymapBuilder::new(b"page_vote").with_page_size(13).build(); +# pub static ADDR_VOTE: Keymap = KeymapBuilder::new("page_vote").with_page_size(13).build(); # let user_addr: Addr = info.sender; @@ -384,7 +384,7 @@ Here are some select examples from the unit tests: fn test_keymap_iter_keys() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = Keymap::new(b"test"); + let keymap: Keymap = Keymap::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -422,7 +422,7 @@ fn test_keymap_iter_keys() -> StdResult<()> { fn test_keymap_iter() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let keymap: Keymap, Foo> = Keymap::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, diff --git a/packages/storage/src/keymap.rs b/packages/storage/src/keymap.rs index df39c12..b88c5af 100644 --- a/packages/storage/src/keymap.rs +++ b/packages/storage/src/keymap.rs @@ -64,9 +64,9 @@ where Ser: Serde, { /// Creates a KeymapBuilder with default features - pub const fn new(namespace: &'a [u8]) -> Self { + pub const fn new(namespace: &'a str) -> Self { Self { - namespace, + namespace: namespace.as_bytes(), page_size: DEFAULT_PAGE_SIZE, key_type: PhantomData, item_type: PhantomData, @@ -158,9 +158,9 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: Keymap<'a, K, T, Ser> { /// constructor - pub const fn new(namespace: &'a [u8]) -> Self { + pub const fn new(namespace: &'a str) -> Self { Self { - namespace, + namespace: namespace.as_bytes(), prefix: None, page_size: DEFAULT_PAGE_SIZE, length: Mutex::new(None), @@ -173,8 +173,8 @@ impl<'a, K: Serialize + DeserializeOwned, T: Serialize + DeserializeOwned, Ser: /// This is used to produce a new Keymap. This can be used when you want to associate an Keymap to each user /// and you still get to define the Keymap as a static constant - pub fn add_suffix(&self, suffix: &[u8]) -> Self { - let suffix = to_length_prefixed(suffix); + pub fn add_suffix(&self, suffix: &str) -> Self { + let suffix = to_length_prefixed(suffix.as_bytes()); let prefix = self.prefix.as_deref().unwrap_or(self.namespace); let prefix = [prefix, suffix.as_slice()].concat(); Self { @@ -998,7 +998,7 @@ mod tests { let total_items = 1000; - let keymap: Keymap, i32> = Keymap::new(b"test"); + let keymap: Keymap, i32> = Keymap::new("test"); for i in 0..total_items { let key: Vec = (i as i32).to_be_bytes().to_vec(); @@ -1016,7 +1016,7 @@ mod tests { let total_items = 100; - let keymap: Keymap = Keymap::new(b"test"); + let keymap: Keymap = Keymap::new("test"); for i in 0..total_items { keymap.insert(&mut storage, &i, &i)?; @@ -1037,7 +1037,7 @@ mod tests { let page_size: u32 = 5; let total_items: u32 = 50; - let keymap: Keymap, u32> = Keymap::new(b"test"); + let keymap: Keymap, u32> = Keymap::new("test"); for i in 0..total_items { let key: Vec = (i as i32).to_be_bytes().to_vec(); @@ -1066,7 +1066,7 @@ mod tests { let page_size = 50; let total_items = 10; - let keymap: Keymap = Keymap::new(b"test"); + let keymap: Keymap = Keymap::new("test"); for i in 0..total_items { keymap.insert(&mut storage, &(i as i32), &i)?; @@ -1087,7 +1087,7 @@ mod tests { fn test_keymap_insert_multiple() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let keymap: Keymap, Foo> = Keymap::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1112,7 +1112,7 @@ mod tests { fn test_keymap_contains() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let keymap: Keymap, Foo> = Keymap::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1130,7 +1130,7 @@ mod tests { fn test_keymap_iter() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let keymap: Keymap, Foo> = Keymap::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1158,7 +1158,7 @@ mod tests { fn test_keymap_iter_keys() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = Keymap::new(b"test"); + let keymap: Keymap = Keymap::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1189,7 +1189,7 @@ mod tests { fn test_keymap_overwrite() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = Keymap::new(b"test"); + let keymap: Keymap, Foo> = Keymap::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1213,8 +1213,8 @@ mod tests { fn test_keymap_suffixed_basics() -> StdResult<()> { let mut storage = MockStorage::new(); - let original_keymap: Keymap = Keymap::new(b"test"); - let keymap = original_keymap.add_suffix(b"test_suffix"); + let original_keymap: Keymap = Keymap::new("test"); + let keymap = original_keymap.add_suffix("test_suffix"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1233,8 +1233,8 @@ mod tests { assert_eq!(foo1, read_foo1); assert_eq!(foo2, read_foo2); - let alternative_keymap: Keymap = Keymap::new(b"alternative"); - let alt_same_suffix = alternative_keymap.add_suffix(b"test_suffix"); + let alternative_keymap: Keymap = Keymap::new("alternative"); + let alt_same_suffix = alternative_keymap.add_suffix("test_suffix"); assert!(alt_same_suffix.is_empty(&storage)?); @@ -1264,7 +1264,7 @@ mod tests { fn test_keymap_length_with_page_size(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = KeymapBuilder::new(b"test") + let keymap: Keymap = KeymapBuilder::new("test") .with_page_size(page_size) .build(); let foo1 = Foo { @@ -1321,7 +1321,7 @@ mod tests { fn test_keymap_without_iter_custom_page(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = KeymapBuilder::new(b"test") + let keymap: Keymap = KeymapBuilder::new("test") .with_page_size(page_size) .without_iter() .build(); @@ -1361,7 +1361,7 @@ mod tests { let page_size: u32 = 5; let total_items: u32 = 50; - let keymap: Keymap, u32> = KeymapBuilder::new(b"test").with_page_size(13).build(); + let keymap: Keymap, u32> = KeymapBuilder::new("test").with_page_size(13).build(); for i in 0..total_items { let key: Vec = (i as i32).to_be_bytes().to_vec(); @@ -1390,7 +1390,7 @@ mod tests { let page_size = 50; let total_items = 10; - let keymap: Keymap = KeymapBuilder::new(b"test").with_page_size(3).build(); + let keymap: Keymap = KeymapBuilder::new("test").with_page_size(3).build(); for i in 0..total_items { keymap.insert(&mut storage, &(i as i32), &i)?; @@ -1411,7 +1411,7 @@ mod tests { fn test_keymap_custom_page_iter() -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap, Foo> = KeymapBuilder::new(b"test").with_page_size(2).build(); + let keymap: Keymap, Foo> = KeymapBuilder::new("test").with_page_size(2).build(); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -1455,7 +1455,7 @@ mod tests { fn test_keymap_custom_page_reverse_iterator(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let keymap: Keymap = KeymapBuilder::new(b"test") + let keymap: Keymap = KeymapBuilder::new("test") .with_page_size(page_size) .build(); keymap.insert(&mut storage, &1234, &1234)?; @@ -1505,7 +1505,7 @@ mod tests { // Check the default behavior is Bincode2 let mut storage = MockStorage::new(); - let keymap: Keymap = KeymapBuilder::new(b"test") + let keymap: Keymap = KeymapBuilder::new("test") .with_page_size(page_size) .build(); keymap.insert(&mut storage, &1234, &1234)?; @@ -1523,7 +1523,7 @@ mod tests { // Check that overriding the serializer with Json works let mut storage = MockStorage::new(); - let json_keymap: Keymap = KeymapBuilder::new(b"test2") + let json_keymap: Keymap = KeymapBuilder::new("test2") .with_page_size(page_size) .build(); json_keymap.insert(&mut storage, &1234, &1234)?; From f8c0945f3cdd471bdfedff27c74a7a91375399bf Mon Sep 17 00:00:00 2001 From: Eshel Date: Sun, 12 Feb 2023 23:14:14 +0200 Subject: [PATCH 2/5] Item's new() now accepts str instead of bytes --- packages/storage/src/item.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/packages/storage/src/item.rs b/packages/storage/src/item.rs index 155debe..b47d19e 100644 --- a/packages/storage/src/item.rs +++ b/packages/storage/src/item.rs @@ -23,9 +23,9 @@ where impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> Item<'a, T, Ser> { /// constructor - pub const fn new(key: &'a [u8]) -> Self { + pub const fn new(key: &'a str) -> Self { Self { - storage_key: key, + storage_key: key.as_bytes(), prefix: None, item_type: PhantomData, serialization_type: PhantomData, @@ -160,7 +160,7 @@ mod tests { #[test] fn test_item() -> StdResult<()> { let mut storage = MockStorage::new(); - let item: Item = Item::new(b"test"); + let item: Item = Item::new("test"); assert!(item.is_empty(&storage)); assert_eq!(item.may_load(&storage)?, None); @@ -180,7 +180,7 @@ mod tests { #[test] fn test_suffix() -> StdResult<()> { let mut storage = MockStorage::new(); - let item: Item = Item::new(b"test"); + let item: Item = Item::new("test"); let item1 = item.add_suffix(b"suffix1"); let item2 = item.add_suffix(b"suffix2"); @@ -204,7 +204,7 @@ mod tests { #[test] fn test_update() -> StdResult<()> { let mut storage = MockStorage::new(); - let item: Item = Item::new(b"test"); + let item: Item = Item::new("test"); assert!(item.update(&mut storage, |x| Ok(x + 1)).is_err()); item.save(&mut storage, &7)?; @@ -219,7 +219,7 @@ mod tests { // Check the default behavior is Bincode2 let mut storage = MockStorage::new(); - let item: Item = Item::new(b"test"); + let item: Item = Item::new("test"); item.save(&mut storage, &1234)?; let key = b"test"; @@ -228,7 +228,7 @@ mod tests { // Check that overriding the serializer with Json works let mut storage = MockStorage::new(); - let json_item: Item = Item::new(b"test2"); + let json_item: Item = Item::new("test2"); json_item.save(&mut storage, &1234)?; let key = b"test2"; From 2971a56b1d7f8f6812923cc14bb7f7342409f67f Mon Sep 17 00:00:00 2001 From: Eshel Date: Sun, 12 Feb 2023 23:17:09 +0200 Subject: [PATCH 3/5] KeySet's new() now accepts str instead of bytes --- packages/storage/src/keyset.rs | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/packages/storage/src/keyset.rs b/packages/storage/src/keyset.rs index 83b1cb0..71b099c 100644 --- a/packages/storage/src/keyset.rs +++ b/packages/storage/src/keyset.rs @@ -122,9 +122,9 @@ where impl<'a, K: Serialize + DeserializeOwned, Ser: Serde> Keyset<'a, K, Ser> { /// constructor - pub const fn new(prefix: &'a [u8]) -> Self { + pub const fn new(prefix: &'a str) -> Self { Self { - namespace: prefix, + namespace: prefix.as_bytes(), prefix: None, page_size: DEFAULT_PAGE_SIZE, length: Mutex::new(None), @@ -635,7 +635,7 @@ mod tests { let total_items = 1000; - let keyset: Keyset = Keyset::new(b"test"); + let keyset: Keyset = Keyset::new("test"); for i in 0..total_items { keyset.insert(&mut storage, &i)?; @@ -652,7 +652,7 @@ mod tests { let total_items = 100; - let keyset: Keyset = Keyset::new(b"test"); + let keyset: Keyset = Keyset::new("test"); for i in 0..total_items { keyset.insert(&mut storage, &i)?; @@ -673,7 +673,7 @@ mod tests { let page_size: u32 = 5; let total_items: u32 = 50; - let keyset: Keyset = Keyset::new(b"test"); + let keyset: Keyset = Keyset::new("test"); for i in 0..total_items { keyset.insert(&mut storage, &i)?; @@ -699,7 +699,7 @@ mod tests { let page_size = 50; let total_items = 10; - let keyset: Keyset = Keyset::new(b"test"); + let keyset: Keyset = Keyset::new("test"); for i in 0..total_items { keyset.insert(&mut storage, &i)?; @@ -720,7 +720,7 @@ mod tests { fn test_keyset_insert_multiple() -> StdResult<()> { let mut storage = MockStorage::new(); - let keyset: Keyset = Keyset::new(b"test"); + let keyset: Keyset = Keyset::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -745,7 +745,7 @@ mod tests { fn test_keyset_iter() -> StdResult<()> { let mut storage = MockStorage::new(); - let keyset: Keyset = Keyset::new(b"test"); + let keyset: Keyset = Keyset::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -773,7 +773,7 @@ mod tests { fn test_keyset_iter_keys() -> StdResult<()> { let mut storage = MockStorage::new(); - let keyset: Keyset = Keyset::new(b"test"); + let keyset: Keyset = Keyset::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, @@ -801,7 +801,7 @@ mod tests { fn test_keyset_suffixed_basics() -> StdResult<()> { let mut storage = MockStorage::new(); - let original_keyset: Keyset = Keyset::new(b"test"); + let original_keyset: Keyset = Keyset::new("test"); let keyset = original_keyset.add_suffix(b"test_suffix"); let foo1 = Foo { string: "string one".to_string(), @@ -821,7 +821,7 @@ mod tests { assert!(read_foo1); assert!(read_foo2); - let alternative_keyset: Keyset = Keyset::new(b"alternative"); + let alternative_keyset: Keyset = Keyset::new("alternative"); let alt_same_suffix = alternative_keyset.add_suffix(b"test_suffix"); assert!(alt_same_suffix.is_empty(&storage)?); @@ -848,7 +848,7 @@ mod tests { fn test_keyset_length() -> StdResult<()> { let mut storage = MockStorage::new(); - let keyset: Keyset = Keyset::new(b"test"); + let keyset: Keyset = Keyset::new("test"); let foo1 = Foo { string: "string one".to_string(), number: 1111, From e3c154874353a3f82ca666c2c2643a5259f4260d Mon Sep 17 00:00:00 2001 From: Eshel Date: Sun, 12 Feb 2023 23:22:29 +0200 Subject: [PATCH 4/5] AppendStore's+DequeStore's new()+new_with_length() now accept str instead of bytes --- packages/storage/src/append_store.rs | 32 ++++++++++++++-------------- packages/storage/src/deque_store.rs | 26 +++++++++++----------- 2 files changed, 29 insertions(+), 29 deletions(-) diff --git a/packages/storage/src/append_store.rs b/packages/storage/src/append_store.rs index 78b2b3c..4a0d869 100644 --- a/packages/storage/src/append_store.rs +++ b/packages/storage/src/append_store.rs @@ -36,9 +36,9 @@ where impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> { /// constructor - pub const fn new(namespace: &'a [u8]) -> Self { + pub const fn new(namespace: &'a str) -> Self { Self { - namespace, + namespace: namespace.as_bytes(), prefix: None, page_size: DEFAULT_PAGE_SIZE, length: Mutex::new(None), @@ -47,12 +47,12 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> AppendStore<'a, T, Ser> { } } - pub const fn new_with_page_size(namespace: &'a [u8], page_size: u32) -> Self { + pub const fn new_with_page_size(namespace: &'a str, page_size: u32) -> Self { if page_size == 0 { panic!("zero index page size used in append_store") } Self { - namespace, + namespace: namespace.as_bytes(), prefix: None, page_size, length: Mutex::new(None), @@ -447,7 +447,7 @@ mod tests { #[test] fn test_push_pop() -> StdResult<()> { let mut storage = MockStorage::new(); - let append_store: AppendStore = AppendStore::new(b"test"); + let append_store: AppendStore = AppendStore::new("test"); append_store.push(&mut storage, &1234)?; append_store.push(&mut storage, &2143)?; append_store.push(&mut storage, &3412)?; @@ -465,7 +465,7 @@ mod tests { #[test] fn test_length() -> StdResult<()> { let mut storage = MockStorage::new(); - let append_store: AppendStore = AppendStore::new_with_page_size(b"test", 3); + let append_store: AppendStore = AppendStore::new_with_page_size("test", 3); assert!(append_store.length.lock().unwrap().eq(&None)); assert_eq!(append_store.get_len(&storage)?, 0); @@ -498,7 +498,7 @@ mod tests { #[test] fn test_iterator() -> StdResult<()> { let mut storage = MockStorage::new(); - let append_store: AppendStore = AppendStore::new(b"test"); + let append_store: AppendStore = AppendStore::new("test"); append_store.push(&mut storage, &1234)?; append_store.push(&mut storage, &2143)?; append_store.push(&mut storage, &3412)?; @@ -531,7 +531,7 @@ mod tests { #[test] fn test_reverse_iterator() -> StdResult<()> { let mut storage = MockStorage::new(); - let append_store: AppendStore = AppendStore::new(b"test"); + let append_store: AppendStore = AppendStore::new("test"); append_store.push(&mut storage, &1234)?; append_store.push(&mut storage, &2143)?; append_store.push(&mut storage, &3412)?; @@ -570,7 +570,7 @@ mod tests { #[test] fn test_json_push_pop() -> StdResult<()> { let mut storage = MockStorage::new(); - let append_store: AppendStore = AppendStore::new(b"test"); + let append_store: AppendStore = AppendStore::new("test"); append_store.push(&mut storage, &1234)?; append_store.push(&mut storage, &2143)?; append_store.push(&mut storage, &3412)?; @@ -589,7 +589,7 @@ mod tests { fn test_suffixed_pop() -> StdResult<()> { let mut storage = MockStorage::new(); let suffix: &[u8] = b"test_suffix"; - let original_store: AppendStore = AppendStore::new(b"test"); + let original_store: AppendStore = AppendStore::new("test"); let append_store = original_store.add_suffix(suffix); append_store.push(&mut storage, &1234)?; append_store.push(&mut storage, &2143)?; @@ -616,7 +616,7 @@ mod tests { fn test_suffixed_reverse_iter_with_size(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); let suffix: &[u8] = b"test_suffix"; - let original_store: AppendStore = AppendStore::new_with_page_size(b"test", page_size); + let original_store: AppendStore = AppendStore::new_with_page_size("test", page_size); let append_store = original_store.add_suffix(suffix); append_store.push(&mut storage, &1234)?; @@ -660,7 +660,7 @@ mod tests { fn test_suffix_iter() -> StdResult<()> { let mut storage = MockStorage::new(); let suffix: &[u8] = b"test_suffix"; - let original_store: AppendStore = AppendStore::new(b"test"); + let original_store: AppendStore = AppendStore::new("test"); let append_store = original_store.add_suffix(suffix); append_store.push(&mut storage, &1234)?; @@ -704,7 +704,7 @@ mod tests { // Check the default behavior is Bincode2 let mut storage = MockStorage::new(); - let append_store: AppendStore = AppendStore::new_with_page_size(b"test", page_size); + let append_store: AppendStore = AppendStore::new_with_page_size("test", page_size); append_store.push(&mut storage, &1234)?; let key = [append_store.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); @@ -721,7 +721,7 @@ mod tests { // Check that overriding the serializer with Json works let mut storage = MockStorage::new(); let json_append_store: AppendStore = - AppendStore::new_with_page_size(b"test2", page_size); + AppendStore::new_with_page_size("test2", page_size); json_append_store.push(&mut storage, &1234)?; let key = [json_append_store.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); @@ -751,7 +751,7 @@ mod tests { fn test_removes_with_size(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: AppendStore = AppendStore::new_with_page_size(b"test", page_size); + let deque_store: AppendStore = AppendStore::new_with_page_size("test", page_size); deque_store.push(&mut storage, &1)?; deque_store.push(&mut storage, &2)?; deque_store.push(&mut storage, &3)?; @@ -815,7 +815,7 @@ mod tests { #[test] fn test_paging() -> StdResult<()> { let mut storage = MockStorage::new(); - let append_store: AppendStore = AppendStore::new(b"test"); + let append_store: AppendStore = AppendStore::new("test"); let page_size: u32 = 5; let total_items: u32 = 50; diff --git a/packages/storage/src/deque_store.rs b/packages/storage/src/deque_store.rs index 8db35ac..28626b6 100644 --- a/packages/storage/src/deque_store.rs +++ b/packages/storage/src/deque_store.rs @@ -40,9 +40,9 @@ where impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> DequeStore<'a, T, Ser> { /// constructor - pub const fn new(prefix: &'a [u8]) -> Self { + pub const fn new(prefix: &'a str) -> Self { Self { - namespace: prefix, + namespace: prefix.as_bytes(), prefix: None, page_size: DEFAULT_PAGE_SIZE, length: Mutex::new(None), @@ -53,12 +53,12 @@ impl<'a, T: Serialize + DeserializeOwned, Ser: Serde> DequeStore<'a, T, Ser> { } /// constructor with indexes size - pub const fn new_with_page_size(prefix: &'a [u8], page_size: u32) -> Self { + pub const fn new_with_page_size(prefix: &'a str, page_size: u32) -> Self { if page_size == 0 { panic!("zero index page size used in deque_store") } Self { - namespace: prefix, + namespace: prefix.as_bytes(), prefix: None, page_size, length: Mutex::new(None), @@ -590,7 +590,7 @@ mod tests { fn test_pushs_pops_with_size(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", page_size); + let deque_store: DequeStore = DequeStore::new_with_page_size("test", page_size); deque_store.push_front(&mut storage, &4)?; deque_store.push_back(&mut storage, &5)?; deque_store.push_front(&mut storage, &3)?; @@ -626,7 +626,7 @@ mod tests { #[test] fn test_remove() -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new(b"test"); + let deque_store: DequeStore = DequeStore::new("test"); deque_store.push_front(&mut storage, &2143)?; deque_store.push_back(&mut storage, &3412)?; deque_store.push_back(&mut storage, &3333)?; @@ -649,7 +649,7 @@ mod tests { fn test_removes_with_page_size(size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", size); + let deque_store: DequeStore = DequeStore::new_with_page_size("test", size); deque_store.push_front(&mut storage, &2)?; deque_store.push_back(&mut storage, &3)?; deque_store.push_back(&mut storage, &4)?; @@ -723,7 +723,7 @@ mod tests { fn test_overwrite_with_page_size(size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", size); + let deque_store: DequeStore = DequeStore::new_with_page_size("test", size); deque_store.push_front(&mut storage, &2)?; deque_store.push_back(&mut storage, &3)?; deque_store.push_back(&mut storage, &4)?; @@ -820,7 +820,7 @@ mod tests { #[test] fn test_iterator() -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new(b"test"); + let deque_store: DequeStore = DequeStore::new("test"); deque_store.push_front(&mut storage, &2143)?; deque_store.push_back(&mut storage, &3333)?; @@ -866,7 +866,7 @@ mod tests { fn test_reverse_iterator_with_size(page_size: u32) -> StdResult<()> { let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", page_size); + let deque_store: DequeStore = DequeStore::new_with_page_size("test", page_size); deque_store.push_front(&mut storage, &2143)?; deque_store.push_back(&mut storage, &3412)?; deque_store.push_back(&mut storage, &3333)?; @@ -917,7 +917,7 @@ mod tests { // Check the default behavior is Bincode2 let mut storage = MockStorage::new(); - let deque_store: DequeStore = DequeStore::new_with_page_size(b"test", page_size); + let deque_store: DequeStore = DequeStore::new_with_page_size("test", page_size); deque_store.push_back(&mut storage, &1234)?; let key = [deque_store.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); @@ -934,7 +934,7 @@ mod tests { // Check that overriding the serializer with Json works let mut storage = MockStorage::new(); let json_deque_store: DequeStore = - DequeStore::new_with_page_size(b"test2", page_size); + DequeStore::new_with_page_size("test2", page_size); json_deque_store.push_back(&mut storage, &1234)?; let key = [json_deque_store.as_slice(), INDEXES, &0_u32.to_be_bytes()].concat(); @@ -955,7 +955,7 @@ mod tests { #[test] fn test_paging() -> StdResult<()> { let mut storage = MockStorage::new(); - let append_store: DequeStore = DequeStore::new(b"test"); + let append_store: DequeStore = DequeStore::new("test"); let page_size: u32 = 5; let total_items: u32 = 50; From 455c345c64f7a58b9ab0890743b99a658bf5761e Mon Sep 17 00:00:00 2001 From: Eshel Date: Mon, 13 Feb 2023 18:52:50 +0200 Subject: [PATCH 5/5] fixed readme tests --- packages/storage/Readme.md | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/packages/storage/Readme.md b/packages/storage/Readme.md index fdd83f6..8324379 100644 --- a/packages/storage/Readme.md +++ b/packages/storage/Readme.md @@ -39,7 +39,7 @@ And initialize it using the following lines: ```rust # use cosmwasm_std::Addr; # use secret_toolkit_storage::Item; -pub static OWNER: Item = Item::new(b"owner"); +pub static OWNER: Item = Item::new("owner"); ``` This uses Bincode2 to serde Addr by default. To specify the Serde algorithm as Json, first import it from `secret-toolkit::serialization` @@ -58,8 +58,8 @@ then # #[derive(Serialize, Deserialize)] # enum SomeEnum {}; # -pub static OWNER: Item = Item::new(b"owner"); -pub static SOME_ENUM: Item = Item::new(b"some_enum"); +pub static OWNER: Item = Item::new("owner"); +pub static SOME_ENUM: Item = Item::new("some_enum"); ``` #### **Read/Write** @@ -70,7 +70,7 @@ The way to read/write to/from storage is to use its methods. These methods are ` # use cosmwasm_std::{Addr, testing::mock_dependencies, StdError}; # use secret_toolkit_storage::Item; # -# pub static OWNER: Item = Item::new(b"owner"); +# pub static OWNER: Item = Item::new("owner"); # # let mut deps = mock_dependencies(); # OWNER.save(&mut deps.storage, &Addr::unchecked("owner-addr"))?; @@ -84,7 +84,7 @@ let owner_addr = OWNER.load(&deps.storage)?; # use cosmwasm_std::{Addr, testing::{mock_dependencies, mock_info}, StdError}; # use secret_toolkit_storage::Item; # -# pub static OWNER: Item = Item::new(b"owner"); +# pub static OWNER: Item = Item::new("owner"); # # let mut deps = mock_dependencies(); # let info = mock_info("sender", &[]); @@ -97,7 +97,7 @@ OWNER.save(&mut deps.storage, &info.sender)?; # use cosmwasm_std::{Addr, testing::mock_dependencies, StdError}; # use secret_toolkit_storage::Item; # -# pub static OWNER: Item = Item::new(b"owner"); +# pub static OWNER: Item = Item::new("owner"); # # let mut deps = mock_dependencies(); # @@ -110,7 +110,7 @@ let may_addr = OWNER.may_load(&deps.storage)?; # use cosmwasm_std::{Addr, testing::mock_dependencies, StdError}; # use secret_toolkit_storage::Item; # -# pub static OWNER: Item = Item::new(b"owner"); +# pub static OWNER: Item = Item::new("owner"); # # let mut deps = mock_dependencies(); # @@ -122,7 +122,7 @@ let may_addr = OWNER.remove(&mut deps.storage); # use cosmwasm_std::{Addr, testing::{mock_dependencies, mock_info}, StdError}; # use secret_toolkit_storage::Item; # -# pub static OWNER: Item = Item::new(b"owner"); +# pub static OWNER: Item = Item::new("owner"); # # let mut deps = mock_dependencies(); # let info = mock_info("sender", &[]); @@ -157,7 +157,7 @@ use secret_toolkit::storage::{AppendStore}; ```rust # use secret_toolkit_storage::AppendStore; # use cosmwasm_std::StdError; -pub static COUNT_STORE: AppendStore = AppendStore::new(b"count"); +pub static COUNT_STORE: AppendStore = AppendStore::new("count"); # Ok::<(), StdError>(()) ``` @@ -169,7 +169,7 @@ Often times we need these storage objects to be associated to a user address or # use secret_toolkit_storage::AppendStore; # use cosmwasm_std::testing::mock_info; # let info = mock_info("sender", &[]); -# pub static COUNT_STORE: AppendStore = AppendStore::new(b"count"); +# pub static COUNT_STORE: AppendStore = AppendStore::new("count"); # // The compiler knows that user_count_store is AppendStore let user_count_store = COUNT_STORE.add_suffix(info.sender.to_string().as_bytes()); @@ -179,7 +179,7 @@ Sometimes when iterating these objects, we may want to load the next `n` objects ```rust # use secret_toolkit_storage::AppendStore; -pub static COUNT_STORE: AppendStore = AppendStore::new_with_page_size(b"count", 5); +pub static COUNT_STORE: AppendStore = AppendStore::new_with_page_size("count", 5); ``` #### **Read/Write** @@ -193,7 +193,7 @@ AppendStore also implements a readonly iterator feature. This feature is also us ```rust # use cosmwasm_std::{StdError, testing::mock_dependencies}; # use secret_toolkit_storage::AppendStore; -# pub static COUNT_STORE: AppendStore = AppendStore::new_with_page_size(b"count", 5); +# pub static COUNT_STORE: AppendStore = AppendStore::new_with_page_size("count", 5); # let deps = mock_dependencies(); # let iter = COUNT_STORE.iter(&deps.storage)?; @@ -205,7 +205,7 @@ More examples can be found in the unit tests. And the paging wrapper is used in ```rust # use cosmwasm_std::{StdError, testing::mock_dependencies}; # use secret_toolkit_storage::AppendStore; -# pub static COUNT_STORE: AppendStore = AppendStore::new_with_page_size(b"count", 5); +# pub static COUNT_STORE: AppendStore = AppendStore::new_with_page_size("count", 5); # let deps = mock_dependencies(); # let start_page: u32 = 0; @@ -229,7 +229,7 @@ use secret_toolkit::storage::{DequeStore}; ```rust # use secret_toolkit_storage::DequeStore; -pub static COUNT_STORE: DequeStore = DequeStore::new(b"count"); +pub static COUNT_STORE: DequeStore = DequeStore::new("count"); ``` > ❗ Initializing the object as const instead of static will also work but be less efficient since the variable won't be able to cache length data. @@ -463,7 +463,7 @@ use secret_toolkit::storage::{Keyset, KeysetBuilder}; ```rust # use secret_toolkit_storage::Keyset; # use cosmwasm_std::Addr; -pub static WHITELIST: Keyset = Keyset::new(b"whitelist"); +pub static WHITELIST: Keyset = Keyset::new("whitelist"); ``` > ❗ Initializing the object as const instead of static will also work but be less efficient since the variable won't be able to cache length data.