remove unused public spend key wallet method

assets/schema.json

@@ -139,33 +139,6 @@
         }
       }
     },
-    "PublicSpendKeyArgs": {
-      "description": "The arguments of the public_spend_key function",
-      "type": "object",
-      "required": [
-        "idx",
-        "seed"
-      ],
-      "properties": {
-        "idx": {
-          "description": "The index of the public spend key",
-          "type": "integer",
-          "format": "uint64",
-          "minimum": 0
-        },
-        "seed": {
-          "description": "Seed used to derive the keys of the wallet",
-          "type": "array",
-          "items": {
-            "type": "integer",
-            "format": "uint8",
-            "minimum": 0
-          },
-          "maxItems": 64,
-          "minItems": 64
-        }
-      }
-    },
     "ExecuteArgs": {
       "description": "The arguments of the execute function",
       "type": "object",
@@ -326,6 +299,42 @@
         }
       }
     },
+    "PublicSpendKeysArgs": {
+      "description": "The arguments of the public_spend_keys function",
+      "type": "object",
+      "required": [
+        "seed"
+      ],
+      "properties": {
+        "seed": {
+          "description": "Seed used to derive the keys of the wallet",
+          "type": "array",
+          "items": {
+            "type": "integer",
+            "format": "uint8",
+            "minimum": 0
+          },
+          "maxItems": 64,
+          "minItems": 64
+        }
+      }
+    },
+    "PublicSpendKeysResponse": {
+      "description": "The response of the public_spend_keys function",
+      "type": "object",
+      "required": [
+        "keys"
+      ],
+      "properties": {
+        "keys": {
+          "description": "The Base58 public spend keys of the wallet.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
     "ViewKeysArgs": {
       "description": "The arguments of the view_keys function",
       "type": "object",

build.rs

@@ -41,7 +41,9 @@ fn main() {
 
 use alloc::vec::Vec;
 use alloc::string::String;
-use serde::{Serialize, Deserialize};"#;
+use serde::{Serialize, Deserialize};
+
+"#;
 
     let contents = header.to_owned() + &contents;
 

src/ffi.rs

@@ -60,36 +60,6 @@ pub fn seed(args: i32, len: i32) -> i64 {
     utils::compose(true, ptr, len)
 }
 
-/// Computes the public spend key from the given seed/index pair.
-///
-/// Expects as argument a fat pointer to a JSON string representing
-/// [types::PublicSpendKeyArgs].
-///
-/// Will return a triplet (status, ptr, len) pointing to the Base58
-/// representation of the public spend key.
-#[no_mangle]
-pub fn public_spend_key(args: i32, len: i32) -> i64 {
-    let types::PublicSpendKeyArgs { idx, seed } =
-        match utils::take_args(args, len) {
-            Some(a) => a,
-            None => return utils::fail(),
-        };
-
-    let seed = match utils::sanitize_seed(seed) {
-        Some(s) => s,
-        None => return utils::fail(),
-    };
-
-    let psk = key::derive_psk(&seed, idx);
-    let psk = bs58::encode(psk.to_bytes()).into_string();
-
-    let ptr = psk.as_ptr() as u32;
-    let len = psk.len() as u32;
-
-    mem::forget(psk);
-    utils::compose(true, ptr, len)
-}
-
 /// Computes the total balance of the given notes.
 ///
 /// Expects as argument a fat pointer to a JSON string representing
@@ -344,6 +314,34 @@ pub fn filter_notes(args: i32, len: i32) -> i64 {
     utils::rkyv_into_ptr(notes)
 }
 
+/// Returns a list of [PublicSpendKey] that belongs to this wallet.
+///
+/// Expects as argument a fat pointer to a JSON string representing
+/// [types::PublicSpendKeysArgs].
+///
+/// Will return a triplet (status, ptr, len) pointing to JSON string
+/// representing [types::PublicSpendKeysResponse].
+#[no_mangle]
+pub fn public_spend_keys(args: i32, len: i32) -> i64 {
+    let types::PublicSpendKeysArgs { seed } = match utils::take_args(args, len)
+    {
+        Some(a) => a,
+        None => return utils::fail(),
+    };
+
+    let seed = match utils::sanitize_seed(seed) {
+        Some(s) => s,
+        None => return utils::fail(),
+    };
+
+    let keys = (0..=MAX_KEY)
+        .map(|idx| key::derive_psk(&seed, idx as u64))
+        .map(|psk| bs58::encode(psk.to_bytes()).into_string())
+        .collect();
+
+    utils::into_ptr(types::PublicSpendKeysResponse { keys })
+}
+
 /// Returns a list of [ViewKey] that belongs to this wallet.
 ///
 /// Expects as argument a fat pointer to a JSON string representing

src/types.rs

@@ -10,9 +10,10 @@
 
 #![allow(missing_docs)]
 
-use alloc::string::String;
 use alloc::vec::Vec;
-use serde::{Deserialize, Serialize};
+use alloc::string::String;
+use serde::{Serialize, Deserialize};
+
 #[doc = " The arguments of the balance function"]
 #[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
 pub struct BalanceArgs {
@@ -116,14 +117,18 @@ pub enum OutputType {
     Transparent,
     Obfuscated,
 }
-#[doc = " The arguments of the public_spend_key function"]
+#[doc = " The arguments of the public_spend_keys function"]
 #[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
-pub struct PublicSpendKeyArgs {
-    #[doc = " The index of the public spend key"]
-    pub idx: u64,
+pub struct PublicSpendKeysArgs {
     #[doc = " Seed used to derive the keys of the wallet"]
     pub seed: Vec<u8>,
 }
+#[doc = " The response of the public_spend_keys function"]
+#[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
+pub struct PublicSpendKeysResponse {
+    #[doc = " The Base58 public spend keys of the wallet."]
+    pub keys: Vec<String>,
+}
 #[doc = " The arguments of the seed function"]
 #[derive(Clone, PartialEq, Debug, Deserialize, Serialize)]
 pub struct SeedArgs {

tests/wallet.rs

@@ -8,7 +8,7 @@
 
 use dusk_bytes::Serializable;
 use dusk_pki::PublicSpendKey;
-use dusk_wallet_core::{tx, types, utils, MAX_LEN, RNG_SEED};
+use dusk_wallet_core::{tx, types, utils, MAX_KEY, MAX_LEN, RNG_SEED};
 use rusk_abi::ContractId;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -45,29 +45,6 @@ fn balance_works() {
     assert_eq!(maximum, 359);
 }
 
-#[test]
-fn public_spend_key_works() {
-    let seed = [0xfa; RNG_SEED];
-
-    let mut wallet = Wallet::default();
-
-    let psk = wallet
-        .call(
-            "public_spend_key",
-            json!({
-                "seed": seed.to_vec(),
-                "idx": 3
-            }),
-        )
-        .take_memory();
-
-    let psk = bs58::decode(psk).into_vec().unwrap();
-    let mut psk_array = [0u8; PublicSpendKey::SIZE];
-
-    psk_array.copy_from_slice(&psk);
-    PublicSpendKey::from_bytes(&psk_array).unwrap();
-}
-
 #[test]
 fn execute_works() {
     let seed = [0xfa; RNG_SEED];
@@ -76,16 +53,15 @@ fn execute_works() {
 
     let mut wallet = Wallet::default();
 
-    let psk = wallet
+    let types::PublicSpendKeysResponse { keys } = wallet
         .call(
-            "public_spend_key",
+            "public_spend_keys",
             json!({
                 "seed": seed.to_vec(),
-                "idx":5
             }),
         )
-        .take_memory();
-    let psk = String::from_utf8(psk).unwrap();
+        .take_contents();
+    let psk = &keys[0];
 
     let mut contract = ContractId::uninitialized();
     contract.as_bytes_mut().iter_mut().for_each(|b| *b = 0xfa);
@@ -105,7 +81,7 @@ fn execute_works() {
         "openings": openings,
         "output": {
             "note_type": "Transparent",
-            "receiver": psk.clone(),
+            "receiver": psk,
             "ref_id": 15,
             "value": 10,
         },
@@ -183,6 +159,31 @@ fn filter_notes_works() {
     assert_eq!(notes, filtered);
 }
 
+#[test]
+fn public_spend_keys_works() {
+    let seed = [0xfa; RNG_SEED];
+
+    let mut wallet = Wallet::default();
+
+    let types::PublicSpendKeysResponse { keys } = wallet
+        .call(
+            "public_spend_keys",
+            json!({
+                "seed": seed.to_vec(),
+            }),
+        )
+        .take_contents();
+
+    for key in &keys {
+        let key = bs58::decode(key).into_vec().unwrap();
+        let mut key_array = [0u8; PublicSpendKey::SIZE];
+        key_array.copy_from_slice(&key);
+        PublicSpendKey::from_bytes(&key_array).unwrap();
+    }
+
+    assert_eq!(keys.len(), MAX_KEY + 1);
+}
+
 #[test]
 fn view_keys_works() {
     let seed = [0xfa; RNG_SEED];