chore: Update dependencies and SDK versions

Author: zwong91

CHANGELOG.md

@@ -5,11 +5,3 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-
-## [2.0.3](https://github.com/utnet-org/utility-sdk-rs/compare/unc-sdk-v2.0.2...unc-sdk-v2.0.3) - 2024-05-28
-
-### Other
-- Update variable
-- Update deprecated items to use the correct version number
-- trybuild testcase compilation_tests
-- Update unc-sdk and unc-sys dependencies to version 2.0.2

Cargo.toml

@@ -9,7 +9,7 @@ members = [
 exclude = ["examples/"]
 
 [workspace.package]
-version = "2.0.5"
+version = "2.0.6"
 
 # Special triple # comment for ci.
 [patch.crates-io]

unc-contract-standards/Cargo.toml

@@ -13,7 +13,7 @@ Utility smart contracts standard library.
 """
 
 [dependencies]
-unc-sdk = { path = "../unc-sdk", version = "2.0.5", default-features = false, features = ["legacy"] }
+unc-sdk = { path = "../unc-sdk", version = "2.0.6", default-features = false, features = ["legacy"] }
 
 [dev-dependencies]
 unc-sdk = { path = "../unc-sdk", default-features = false, features = ["unit-testing"] }

unc-sdk/Cargo.toml

@@ -21,8 +21,8 @@ required-features = ["abi", "unstable"]
 # Provide unc_bidgen macros.
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-unc-sdk-macros = { path = "../unc-sdk-macros", version = "2.0.5" }
-unc-sys = { path = "../unc-sys", version = "2.0.5" }
+unc-sdk-macros = { path = "../unc-sdk-macros", version = "2.0.6" }
+unc-sys = { path = "../unc-sys", version = "2.0.6" }
 base64 = "0.22.0"
 borsh = { version = "1.0.0", features = ["derive"] }
 bs58 = "0.5"

unc-sdk/src/store/key.rs

@@ -16,9 +16,9 @@ pub trait ToKey: self::private::Sealed {
     /// Output type for the generated lookup key.
     type KeyType: AsRef<[u8]>;
 
-    fn to_key<Q: ?Sized>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
+    fn to_key<Q>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
     where
-        Q: BorshSerialize;
+        Q: ?Sized + BorshSerialize;
 }
 
 /// Sha256 hash helper which hashes through a syscall. This type satisfies the [`ToKey`] trait.
@@ -28,9 +28,9 @@ pub enum Sha256 {}
 impl ToKey for Sha256 {
     type KeyType = [u8; 32];
 
-    fn to_key<Q: ?Sized>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
+    fn to_key<Q>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
     where
-        Q: BorshSerialize,
+        Q: ?Sized + BorshSerialize,
     {
         // Prefix the serialized bytes, then hash the combined value.
         buffer.extend(prefix);
@@ -47,9 +47,9 @@ pub enum Keccak256 {}
 impl ToKey for Keccak256 {
     type KeyType = [u8; 32];
 
-    fn to_key<Q: ?Sized>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
+    fn to_key<Q>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
     where
-        Q: BorshSerialize,
+        Q: ?Sized + BorshSerialize,
     {
         // Prefix the serialized bytes, then hash the combined value.
         buffer.extend(prefix);
@@ -65,9 +65,9 @@ pub enum Identity {}
 impl ToKey for Identity {
     type KeyType = Vec<u8>;
 
-    fn to_key<Q: ?Sized>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
+    fn to_key<Q>(prefix: &[u8], key: &Q, buffer: &mut Vec<u8>) -> Self::KeyType
     where
-        Q: BorshSerialize,
+        Q: ?Sized + BorshSerialize,
     {
         // Prefix the serialized bytes and return a copy of this buffer.
         buffer.extend(prefix);

unc-sdk/src/store/lookup_map/mod.rs

@@ -211,9 +211,9 @@ where
         V::try_from_slice(bytes).unwrap_or_else(|_| env::panic_str(ERR_ELEMENT_DESERIALIZATION))
     }
 
-    fn load_element<Q: ?Sized>(prefix: &[u8], key: &Q) -> (H::KeyType, Option<V>)
+    fn load_element<Q>(prefix: &[u8], key: &Q) -> (H::KeyType, Option<V>)
     where
-        Q: BorshSerialize,
+        Q: ?Sized + BorshSerialize,
         K: Borrow<Q>,
     {
         let key = H::to_key(prefix, key, &mut Vec::new());
@@ -237,10 +237,10 @@ where
     /// assert_eq!(map.get(&1), Some(&"a".to_string()));
     /// assert_eq!(map.get(&2), None);
     /// ```
-    pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
+    pub fn get<Q>(&self, k: &Q) -> Option<&V>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         //* ToOwned bound, which forces a clone, is required to be able to keep the key in the cache
         let cached = self.cache.get(k.to_owned());
@@ -252,10 +252,10 @@ where
         entry.value().as_ref()
     }
 
-    pub(crate) fn get_mut_inner<Q: ?Sized>(&mut self, k: &Q) -> &mut CacheEntry<V>
+    pub(crate) fn get_mut_inner<Q>(&mut self, k: &Q) -> &mut CacheEntry<V>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         let prefix = &self.prefix;
         //* ToOwned bound, which forces a clone, is required to be able to keep the key in the cache
@@ -286,10 +286,10 @@ where
     ///     assert_eq!(map[&1], "b".to_string());
     /// }
     /// ```
-    pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V>
+    pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         self.get_mut_inner(k).value_mut().as_mut()
     }
@@ -336,10 +336,10 @@ where
     /// assert_eq!(map.contains_key(&1), true);
     /// assert_eq!(map.contains_key(&2), false);
     /// ```
-    pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
+    pub fn contains_key<Q>(&self, k: &Q) -> bool
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K> + Ord,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K> + Ord,
     {
         // Check cache before checking storage
         let contains = self
@@ -378,10 +378,10 @@ where
     /// assert_eq!(map.remove(&1), Some("a".to_string()));
     /// assert_eq!(map.remove(&1), None);
     /// ```
-    pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V>
+    pub fn remove<Q>(&mut self, k: &Q) -> Option<V>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         self.get_mut_inner(k).replace(None)
     }

unc-sdk/src/store/lookup_set/mod.rs

@@ -107,10 +107,10 @@ where
     ///
     /// The value may be any borrowed form of the set's value type, but
     /// [`BorshSerialize`] on the borrowed form *must* match those for the value type.
-    pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool
+    pub fn contains<Q>(&self, value: &Q) -> bool
     where
         T: Borrow<Q>,
-        Q: BorshSerialize,
+        Q: ?Sized + BorshSerialize,
     {
         let lookup_key = H::to_key(&self.prefix, value, &mut Vec::new());
         env::storage_has_key(lookup_key.as_ref())
@@ -130,10 +130,10 @@ where
     ///
     /// The value may be any borrowed form of the set's value type, but
     /// [`BorshSerialize`] on the borrowed form *must* match those for the value type.
-    pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool
+    pub fn remove<Q>(&mut self, value: &Q) -> bool
     where
         T: Borrow<Q>,
-        Q: BorshSerialize,
+        Q: ?Sized + BorshSerialize,
     {
         let lookup_key = H::to_key(&self.prefix, value, &mut Vec::new());
         env::storage_remove(lookup_key.as_ref())

unc-sdk/src/store/tree_map/mod.rs

@@ -207,10 +207,10 @@ where
     /// The key may be any borrowed form of the map's key type, but
     /// [`BorshSerialize`] and [`ToOwned<Owned = K>`](ToOwned) on the borrowed form *must* match
     /// those for the key type.
-    pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
+    pub fn contains_key<Q>(&self, k: &Q) -> bool
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K> + Ord,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K> + Ord,
     {
         self.values.contains_key(k)
     }
@@ -220,10 +220,10 @@ where
     /// The key may be any borrowed form of the map's key type, but
     /// [`BorshSerialize`] and [`ToOwned<Owned = K>`](ToOwned) on the borrowed form *must* match
     /// those for the key type.
-    pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
+    pub fn get<Q>(&self, k: &Q) -> Option<&V>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         self.values.get(k)
     }
@@ -243,10 +243,10 @@ where
     /// assert_eq!(map.get_key_value(&1), Some((&1, &"a".to_string())));
     /// assert_eq!(map.get_key_value(&2), None);
     /// ```
-    pub fn get_key_value<Q: ?Sized>(&self, k: &Q) -> Option<(&K, &V)>
+    pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>
     where
         K: Borrow<Q> + BorshDeserialize,
-        Q: BorshSerialize + ToOwned<Owned = K> + Ord,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K> + Ord,
     {
         self.values.get(k).map(|v| (expect(self.tree.equal_key(k)), v))
     }
@@ -256,10 +256,10 @@ where
     /// The key may be any borrowed form of the map's key type, but
     /// [`BorshSerialize`] and [`ToOwned<Owned = K>`](ToOwned) on the borrowed form *must* match
     /// those for the key type.
-    pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V>
+    pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         self.values.get_mut(k)
     }
@@ -292,10 +292,10 @@ where
     /// The key may be any borrowed form of the map's key type, but
     /// [`BorshSerialize`] and [`ToOwned<Owned = K>`](ToOwned) on the borrowed form *must* match
     /// those for the key type.
-    pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V>
+    pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
     where
         K: Borrow<Q> + BorshDeserialize,
-        Q: BorshSerialize + ToOwned<Owned = K> + Ord,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K> + Ord,
     {
         self.remove_entry(key).map(|(_, v)| v)
     }
@@ -477,14 +477,14 @@ where
     /// The metadata included in the result includes the indices for the node and parent, as well
     /// as which edge the found node is of the parent, if one.
     #[allow(clippy::type_complexity)]
-    fn lookup_at<Q: ?Sized>(
+    fn lookup_at<Q>(
         &self,
         mut at: FreeListIndex,
         key: &Q,
     ) -> Option<(NodeAndIndex<K>, Option<(FreeListIndex, &Node<K>, Edge)>)>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + Eq + PartialOrd,
+        Q: ?Sized + BorshSerialize + Eq + PartialOrd,
     {
         let mut p = None;
         let mut curr = Some(expect(self.node(at)));
@@ -665,10 +665,10 @@ where
     // - right-most (max) node of the left subtree (containing smaller keys) of node holding `key`
     // - or left-most (min) node of the right subtree (containing larger keys) of node holding `key`
     //
-    fn do_remove<Q: ?Sized>(&mut self, key: &Q) -> Option<K>
+    fn do_remove<Q>(&mut self, key: &Q) -> Option<K>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + Eq + PartialOrd,
+        Q: ?Sized + BorshSerialize + Eq + PartialOrd,
     {
         // r_node - node containing key of interest
         // remove_parent - immediate parent node of r_node
@@ -875,11 +875,12 @@ where
     /// }
     /// assert_eq!(Some((&5, &"b".to_string())), map.range(4..).next());
     /// ```
-    pub fn range<'a, R: 'a, Q: 'a>(&'a self, range: R) -> Range<'a, K, V, H>
+    pub fn range<'a, R: 'a + RangeBounds<Q>, Q: 'a + ?Sized + Ord>(
+        &'a self,
+        range: R,
+    ) -> Range<'a, K, V, H>
     where
         K: BorshDeserialize + Borrow<Q>,
-        Q: ?Sized + Ord,
-        R: RangeBounds<Q>,
     {
         Range::new(self, (range.start_bound(), range.end_bound()))
     }
@@ -947,10 +948,10 @@ where
     /// assert_eq!(map.remove(&1), Some("a".to_string()));
     /// assert_eq!(map.remove(&1), None);
     /// ```
-    pub fn remove_entry<Q: ?Sized>(&mut self, key: &Q) -> Option<(K, V)>
+    pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
     where
         K: Borrow<Q> + BorshDeserialize + Clone,
-        Q: BorshSerialize + ToOwned<Owned = K> + Eq + PartialOrd,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K> + Eq + PartialOrd,
     {
         self.values.remove(key).map(|removed_value| {
             let removed = self.tree.do_remove(key);

unc-sdk/src/store/unordered_map/mod.rs

@@ -444,10 +444,10 @@ where
     /// assert!(map.insert("test".to_string(), 5u8).is_none());
     /// assert_eq!(map.get("test"), Some(&5));
     /// ```
-    pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
+    pub fn get<Q>(&self, k: &Q) -> Option<&V>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         self.values.get(k).map(|v| &v.value)
     }
@@ -469,10 +469,10 @@ where
     /// *map.get_mut("test").unwrap() = 6;
     /// assert_eq!(map["test"], 6);
     /// ```
-    pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V>
+    pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         self.values.get_mut(k).map(|v| &mut v.value)
     }
@@ -530,10 +530,10 @@ where
     ///
     /// assert!(map.contains_key("test"));
     /// ```
-    pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
+    pub fn contains_key<Q>(&self, k: &Q) -> bool
     where
         K: Borrow<Q>,
-        Q: BorshSerialize + ToOwned<Owned = K> + Ord,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K> + Ord,
     {
         self.values.contains_key(k)
     }
@@ -568,10 +568,10 @@ where
     ///
     /// assert_eq!(map.len(), 0);
     /// ```
-    pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V>
+    pub fn remove<Q>(&mut self, k: &Q) -> Option<V>
     where
         K: Borrow<Q> + BorshDeserialize,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         self.remove_entry(k).map(|(_, v)| v)
     }
@@ -603,10 +603,10 @@ where
     /// assert_eq!(map.remove(&1), Some("a".to_string()));
     /// assert_eq!(map.remove(&1), None);
     /// ```
-    pub fn remove_entry<Q: ?Sized>(&mut self, k: &Q) -> Option<(K, V)>
+    pub fn remove_entry<Q>(&mut self, k: &Q) -> Option<(K, V)>
     where
         K: Borrow<Q> + BorshDeserialize,
-        Q: BorshSerialize + ToOwned<Owned = K>,
+        Q: ?Sized + BorshSerialize + ToOwned<Owned = K>,
     {
         // Remove value
         let old_value = self.values.remove(k)?;