refactor: rename 'BlindedMessages' to 'PreMintSecrets'

In the nuts 'BlindedMessages' is a Vec<BlindedMessage>
using it another way is confusing this avoids that.

bindings/cashu-ffi/src/cashu.udl

@@ -98,7 +98,7 @@ interface Token {
 	
 };
 
-interface BlindedMessages {
+interface PreMintSecrets {
     [Throws=CashuError, Name=random]
 	constructor(Id keyset_id, Amount amount);
     [Throws=CashuError, Name=blank]

bindings/cashu-ffi/src/lib.rs

@@ -7,9 +7,9 @@ mod ffi {
 
     pub use crate::error::CashuError;
     pub use crate::nuts::nut00::blinded_message::BlindedMessage;
-    pub use crate::nuts::nut00::blinded_messages::BlindedMessages;
     pub use crate::nuts::nut00::blinded_signature::BlindedSignature;
     pub use crate::nuts::nut00::mint_proofs::MintProofs;
+    pub use crate::nuts::nut00::premint_secrets::PreMintSecrets;
     pub use crate::nuts::nut00::proof::mint::Proof as MintProof;
     pub use crate::nuts::nut00::proof::Proof;
     pub use crate::nuts::nut00::token::Token;

bindings/cashu-ffi/src/nuts/nut00/blinded_messages.rs

@@ -1,86 +0,0 @@
-use std::ops::Deref;
-use std::sync::Arc;
-
-use cashu::nuts::nut00::wallet::BlindedMessages as BlindedMessagesSdk;
-
-use crate::error::Result;
-use crate::{Amount, BlindedMessage, Id, Secret, SecretKey};
-
-pub struct BlindedMessages {
-    inner: BlindedMessagesSdk,
-}
-
-impl Deref for BlindedMessages {
-    type Target = BlindedMessagesSdk;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl BlindedMessages {
-    pub fn random(keyset_id: Arc<Id>, amount: Arc<Amount>) -> Result<Self> {
-        Ok(Self {
-            inner: BlindedMessagesSdk::random(
-                *keyset_id.as_ref().deref(),
-                *amount.as_ref().deref(),
-            )?,
-        })
-    }
-
-    pub fn blank(keyset_id: Arc<Id>, fee_reserve: Arc<Amount>) -> Result<Self> {
-        Ok(Self {
-            inner: BlindedMessagesSdk::blank(
-                *keyset_id.as_ref().deref(),
-                *fee_reserve.as_ref().deref(),
-            )?,
-        })
-    }
-
-    pub fn blinded_messages(&self) -> Vec<Arc<BlindedMessage>> {
-        self.inner
-            .blinded_messages
-            .clone()
-            .into_iter()
-            .map(|b| Arc::new(b.into()))
-            .collect()
-    }
-
-    pub fn secrets(&self) -> Vec<Arc<Secret>> {
-        self.inner
-            .secrets
-            .clone()
-            .into_iter()
-            .map(|s| Arc::new(s.into()))
-            .collect()
-    }
-
-    pub fn rs(&self) -> Vec<Arc<SecretKey>> {
-        self.inner
-            .rs
-            .clone()
-            .into_iter()
-            .map(|s| Arc::new(s.into()))
-            .collect()
-    }
-
-    pub fn amounts(&self) -> Vec<Arc<Amount>> {
-        self.inner
-            .amounts
-            .clone()
-            .into_iter()
-            .map(|a| Arc::new(a.into()))
-            .collect()
-    }
-}
-
-impl From<cashu::nuts::nut00::wallet::BlindedMessages> for BlindedMessages {
-    fn from(inner: cashu::nuts::nut00::wallet::BlindedMessages) -> BlindedMessages {
-        BlindedMessages { inner }
-    }
-}
-
-impl From<BlindedMessages> for cashu::nuts::nut00::wallet::BlindedMessages {
-    fn from(blinded_messages: BlindedMessages) -> cashu::nuts::nut00::wallet::BlindedMessages {
-        blinded_messages.inner
-    }
-}

bindings/cashu-ffi/src/nuts/nut00/mod.rs

@@ -1,6 +1,6 @@
 pub mod blinded_message;
-pub mod blinded_messages;
 pub mod blinded_signature;
 pub mod mint_proofs;
+pub mod premint_secrets;
 pub mod proof;
 pub mod token;

bindings/cashu-ffi/src/nuts/nut00/premint_secrets.rs

@@ -0,0 +1,78 @@
+use std::ops::Deref;
+use std::sync::Arc;
+
+use cashu::nuts::nut00::wallet::PreMintSecrets as PreMintSecretsSdk;
+
+use crate::error::Result;
+use crate::{Amount, BlindedMessage, Id, Secret, SecretKey};
+
+pub struct PreMintSecrets {
+    inner: PreMintSecretsSdk,
+}
+
+impl Deref for PreMintSecrets {
+    type Target = PreMintSecretsSdk;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl PreMintSecrets {
+    pub fn random(keyset_id: Arc<Id>, amount: Arc<Amount>) -> Result<Self> {
+        Ok(Self {
+            inner: PreMintSecretsSdk::random(
+                *keyset_id.as_ref().deref(),
+                *amount.as_ref().deref(),
+            )?,
+        })
+    }
+
+    pub fn blank(keyset_id: Arc<Id>, fee_reserve: Arc<Amount>) -> Result<Self> {
+        Ok(Self {
+            inner: PreMintSecretsSdk::blank(
+                *keyset_id.as_ref().deref(),
+                *fee_reserve.as_ref().deref(),
+            )?,
+        })
+    }
+
+    pub fn blinded_messages(&self) -> Vec<Arc<BlindedMessage>> {
+        self.inner
+            .iter()
+            .map(|premint| Arc::new(premint.blinded_message.clone().into()))
+            .collect()
+    }
+
+    pub fn secrets(&self) -> Vec<Arc<Secret>> {
+        self.inner
+            .iter()
+            .map(|premint| Arc::new(premint.secret.clone().into()))
+            .collect()
+    }
+
+    pub fn rs(&self) -> Vec<Arc<SecretKey>> {
+        self.inner
+            .iter()
+            .map(|premint| Arc::new(premint.r.clone().into()))
+            .collect()
+    }
+
+    pub fn amounts(&self) -> Vec<Arc<Amount>> {
+        self.inner
+            .iter()
+            .map(|premint| Arc::new(premint.amount.into()))
+            .collect()
+    }
+}
+
+impl From<cashu::nuts::nut00::wallet::PreMintSecrets> for PreMintSecrets {
+    fn from(inner: cashu::nuts::nut00::wallet::PreMintSecrets) -> PreMintSecrets {
+        PreMintSecrets { inner }
+    }
+}
+
+impl From<PreMintSecrets> for cashu::nuts::nut00::wallet::PreMintSecrets {
+    fn from(blinded_messages: PreMintSecrets) -> cashu::nuts::nut00::wallet::PreMintSecrets {
+        blinded_messages.inner
+    }
+}

bindings/cashu-js/src/nuts/nut00/blinded_messages.rs

@@ -1,6 +1,6 @@
 use std::ops::Deref;
 
-use cashu::nuts::nut00::wallet::BlindedMessages;
+use cashu::nuts::nut00::wallet::PreMintSecrets;
 use wasm_bindgen::prelude::*;
 
 use crate::error::{into_err, Result};
@@ -9,11 +9,11 @@ use crate::types::JsAmount;
 
 #[wasm_bindgen(js_name = BlindedMessages)]
 pub struct JsBlindedMessages {
-    inner: BlindedMessages,
+    inner: PreMintSecrets,
 }
 
 impl Deref for JsBlindedMessages {
-    type Target = BlindedMessages;
+    type Target = PreMintSecrets;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
@@ -24,15 +24,14 @@ impl JsBlindedMessages {
     #[wasm_bindgen(js_name = random)]
     pub fn random(keyset_id: JsId, amount: JsAmount) -> Result<JsBlindedMessages> {
         Ok(JsBlindedMessages {
-            inner: BlindedMessages::random(*keyset_id.deref(), *amount.deref())
-                .map_err(into_err)?,
+            inner: PreMintSecrets::random(*keyset_id.deref(), *amount.deref()).map_err(into_err)?,
         })
     }
 
     #[wasm_bindgen(js_name = blank)]
     pub fn blank(keyset_id: JsId, fee_reserve: JsAmount) -> Result<JsBlindedMessages> {
         Ok(JsBlindedMessages {
-            inner: BlindedMessages::blank(*keyset_id.deref(), *fee_reserve.deref())
+            inner: PreMintSecrets::blank(*keyset_id.deref(), *fee_reserve.deref())
                 .map_err(into_err)?,
         })
     }
@@ -40,24 +39,24 @@ impl JsBlindedMessages {
     /// Blinded Messages
     #[wasm_bindgen(getter)]
     pub fn blinded_messages(&self) -> Result<JsValue> {
-        serde_wasm_bindgen::to_value(&self.inner.blinded_messages).map_err(into_err)
+        serde_wasm_bindgen::to_value(&self.inner.blinded_messages()).map_err(into_err)
     }
 
     /// Secrets
     #[wasm_bindgen(getter)]
     pub fn secrets(&self) -> Result<JsValue> {
-        serde_wasm_bindgen::to_value(&self.inner.secrets).map_err(into_err)
+        serde_wasm_bindgen::to_value(&self.inner.secrets()).map_err(into_err)
     }
 
     /// rs
     #[wasm_bindgen(getter)]
     pub fn rs(&self) -> Result<JsValue> {
-        serde_wasm_bindgen::to_value(&self.inner.rs).map_err(into_err)
+        serde_wasm_bindgen::to_value(&self.inner.rs()).map_err(into_err)
     }
 
     /// Amounts
     #[wasm_bindgen(getter)]
     pub fn amounts(&self) -> Result<JsValue> {
-        serde_wasm_bindgen::to_value(&self.inner.amounts).map_err(into_err)
+        serde_wasm_bindgen::to_value(&self.inner.amounts()).map_err(into_err)
     }
 }

bindings/cashu-sdk-ffi/src/cashu_sdk.udl

@@ -101,7 +101,7 @@ interface Token {
 	
 };
 
-interface BlindedMessages {
+interface PreMintSecrets {
     [Throws=CashuError, Name=random]
 	constructor(Id keyset_id, Amount amount);
     [Throws=CashuError, Name=blank]
@@ -307,7 +307,7 @@ interface Wallet {
     [Throws=CashuSdkError]
 	sequence<Proof> receive(string encoded_token);
     [Throws=CashuSdkError]
-	sequence<Proof> process_split_response(BlindedMessages blinded_messages, sequence<BlindedSignature> promises);
+	sequence<Proof> process_split_response(PreMintSecrets blinded_messages, sequence<BlindedSignature> promises);
     [Throws=CashuSdkError]
 	SendProofs send(Amount amount, sequence<Proof> proofs);
     [Throws=CashuSdkError]

bindings/cashu-sdk-ffi/src/lib.rs

@@ -5,12 +5,12 @@ mod wallet;
 
 mod ffi {
     pub use cashu_ffi::{
-        Amount, BlindedMessage, BlindedMessages, BlindedSignature, Bolt11Invoice, CashuError,
-        CheckFeesRequest, CheckFeesResponse, CheckSpendableRequest, CheckSpendableResponse, Id,
-        InvoiceStatus, KeyPair, KeySet, KeySetInfo, KeySetResponse, Keys, KeysResponse,
-        MeltRequest, MeltResponse, MintInfo, MintKeySet, MintProof, MintProofs, MintRequest,
-        MintVersion, Nut05MeltRequest, Nut05MeltResponse, PostMintResponse, Proof, PublicKey,
-        RequestMintResponse, Secret, SecretKey, SplitRequest, SplitResponse, Token,
+        Amount, BlindedMessage, BlindedSignature, Bolt11Invoice, CashuError, CheckFeesRequest,
+        CheckFeesResponse, CheckSpendableRequest, CheckSpendableResponse, Id, InvoiceStatus,
+        KeyPair, KeySet, KeySetInfo, KeySetResponse, Keys, KeysResponse, MeltRequest, MeltResponse,
+        MintInfo, MintKeySet, MintProof, MintProofs, MintRequest, MintVersion, Nut05MeltRequest,
+        Nut05MeltResponse, PostMintResponse, PreMintSecrets, Proof, PublicKey, RequestMintResponse,
+        Secret, SecretKey, SplitRequest, SplitResponse, Token,
     };
 
     pub use crate::error::CashuSdkError;

bindings/cashu-sdk-ffi/src/wallet.rs

@@ -2,7 +2,7 @@ use std::ops::Deref;
 use std::sync::Arc;
 
 use cashu_ffi::{
-    BlindedMessages, BlindedSignature, Bolt11Invoice, Proof, RequestMintResponse, Token,
+    BlindedSignature, Bolt11Invoice, PreMintSecrets, Proof, RequestMintResponse, Token,
 };
 use cashu_sdk::client::minreq_client::HttpClient;
 use cashu_sdk::types::ProofsStatus;
@@ -88,7 +88,7 @@ impl Wallet {
 
     pub fn process_split_response(
         &self,
-        blinded_messages: Arc<BlindedMessages>,
+        blinded_messages: Arc<PreMintSecrets>,
         promises: Vec<Arc<BlindedSignature>>,
     ) -> Result<Vec<Arc<Proof>>> {
         Ok(self