Deprecate pks

contracts/cw721-base/src/contract.rs

@@ -510,13 +510,13 @@ fn query_tokens(
     let start = start_after.map(Bound::exclusive);
 
     let owner_addr = deps.api.addr_validate(&owner)?;
-    let res: Result<Vec<_>, _> = tokens()
+    let pks: Vec<_> = tokens()
         .idx
         .owner
-        .pks(deps.storage, owner_addr, start, None, Order::Ascending)
+        .prefix(owner_addr)
+        .keys(deps.storage, start, None, Order::Ascending)
         .take(limit)
         .collect();
-    let pks = res?;
 
     let res: Result<Vec<_>, _> = pks.iter().map(|v| String::from_utf8(v.to_vec())).collect();
     let tokens = res.map_err(StdError::invalid_utf8)?;

packages/storage-plus/README.md

@@ -573,20 +573,19 @@ Notice this uses `prefix()`, explained above in the `Map` section.
 Now `tokens` contains `(token_id, TokenInfo)` pairs for the given `owner`.
 The pk values are `Vec<u8>`, as this is a limitation of the current implementation.
 
-Another example that is slightly similar, but returning only the `token_id`s, using the `pks()` method:
+Another example that is similar, but returning only the `token_id`s, using the `keys()` method:
 ```rust
-    let res: Result<Vec<_>, _> = tokens()
+    let pks: Vec<_> = tokens()
         .idx
         .owner
-        .pks(
+        .prefix(owner_addr)
+        .keys(
             deps.storage,
-            owner_addr,
             start,
             None,
             Order::Ascending,
         )
         .take(limit)
         .collect();
-    let pks = res?;
 ```
 Now `pks` contains `token_id` values (as `Vec<u8>`s) for the given `owner`.

packages/storage-plus/src/indexed_map.rs

@@ -603,13 +603,8 @@ mod test {
          -> usize {
             map.idx
                 .name
-                .pks(
-                    store,
-                    name.as_bytes().to_vec(),
-                    None,
-                    None,
-                    Order::Ascending,
-                )
+                .prefix(name.as_bytes().to_vec())
+                .keys(store, None, None, Order::Ascending)
                 .count()
         };
 

packages/storage-plus/src/indexed_snapshot.rs

@@ -603,13 +603,8 @@ mod test {
          -> usize {
             map.idx
                 .name
-                .pks(
-                    store,
-                    name.as_bytes().to_vec(),
-                    None,
-                    None,
-                    Order::Ascending,
-                )
+                .prefix(name.as_bytes().to_vec())
+                .keys(store, None, None, Order::Ascending)
                 .count()
         };
 

packages/storage-plus/src/indexes.rs

@@ -142,43 +142,24 @@ where
         k.joined_key()
     }
 
-    // FIXME?: Move to Prefix<T> for ergonomics
-    pub fn pks<'c>(
-        &self,
-        store: &'c dyn Storage,
-        p: K::Prefix,
-        min: Option<Bound>,
-        max: Option<Bound>,
-        order: Order,
-    ) -> Box<dyn Iterator<Item = StdResult<Vec<u8>>> + 'c>
-    where
-        T: 'c,
-    {
-        let prefix = self.prefix(p);
-        let mapped = prefix.range(store, min, max, order).map(|res| {
-            let t = res?;
-            Ok(t.0)
-        });
-        Box::new(mapped)
-    }
-
     #[cfg(test)]
     pub fn count(&self, store: &dyn Storage, p: K::Prefix) -> usize {
-        self.pks(store, p, None, None, Order::Ascending).count()
+        let prefix = self.prefix(p);
+        prefix.keys(store, None, None, Order::Ascending).count()
     }
 
     #[cfg(test)]
     pub fn all_pks(&self, store: &dyn Storage, p: K::Prefix) -> Vec<Vec<u8>> {
-        self.pks(store, p, None, None, Order::Ascending)
-            .collect::<StdResult<Vec<Vec<u8>>>>()
-            .unwrap()
+        let prefix = self.prefix(p);
+        prefix
+            .keys(store, None, None, Order::Ascending)
+            .collect::<Vec<Vec<u8>>>()
     }
 
     #[cfg(test)]
-    pub fn all_items(&self, store: &dyn Storage, prefix: K::Prefix) -> StdResult<Vec<Pair<T>>> {
-        self.prefix(prefix)
-            .range(store, None, None, Order::Ascending)
-            .collect()
+    pub fn all_items(&self, store: &dyn Storage, p: K::Prefix) -> StdResult<Vec<Pair<T>>> {
+        let prefix = self.prefix(p);
+        prefix.range(store, None, None, Order::Ascending).collect()
     }
 }
 
@@ -204,6 +185,17 @@ where
         self.sub_prefix(K::SubPrefix::new())
             .range(store, min, max, order)
     }
+
+    pub fn keys<'c>(
+        &'c self,
+        store: &'c dyn Storage,
+        min: Option<Bound>,
+        max: Option<Bound>,
+        order: Order,
+    ) -> Box<dyn Iterator<Item = Vec<u8>> + 'c> {
+        self.sub_prefix(K::SubPrefix::new())
+            .keys(store, min, max, order)
+    }
 }
 
 #[derive(Deserialize, Serialize)]
@@ -319,4 +311,15 @@ where
         self.sub_prefix(K::SubPrefix::new())
             .range(store, min, max, order)
     }
+
+    pub fn keys<'c>(
+        &self,
+        store: &'c dyn Storage,
+        min: Option<Bound>,
+        max: Option<Bound>,
+        order: Order,
+    ) -> Box<dyn Iterator<Item = Vec<u8>> + 'c> {
+        self.sub_prefix(K::SubPrefix::new())
+            .keys(store, min, max, order)
+    }
 }

packages/storage-plus/src/prefix.rs

@@ -117,10 +117,7 @@ where
         min: Option<Bound>,
         max: Option<Bound>,
         order: Order,
-    ) -> Box<dyn Iterator<Item = Vec<u8>> + 'a>
-    where
-        T: 'a,
-    {
+    ) -> Box<dyn Iterator<Item = Vec<u8>> + 'a> {
         let mapped =
             range_with_prefix(store, &self.storage_prefix, min, max, order).map(|(k, _)| k);
         Box::new(mapped)