rename `mint` to `client`

integration_test/src/main.rs

@@ -5,9 +5,9 @@ use std::thread;
 use std::time::Duration;
 
 use bitcoin::Amount;
-use cashu_crab::cashu_mint::CashuMint;
 use cashu_crab::cashu_wallet::CashuWallet;
-use cashu_crab::types::{BlindedMessages, MintKeys, ProofsStatus, Token, TokenData};
+use cashu_crab::client::Client;
+use cashu_crab::types::{MintKeys, Token, TokenData};
 use lightning_invoice::Invoice;
 use url::Url;
 
@@ -15,33 +15,33 @@ use url::Url;
 async fn main() {
     let url =
         Url::from_str("https://legend.lnbits.com/cashu/api/v1/SKvHRus9dmjWHhstHrsazW/").unwrap();
-    let mint = CashuMint::new(url);
+    let client = Client::new(url);
 
     // NUT-09
     // test_get_mint_info(&mint).await;
 
-    let keys = test_get_mint_keys(&mint).await;
-    let wallet = CashuWallet::new(mint.to_owned(), keys);
-    test_get_mint_keysets(&mint).await;
+    let keys = test_get_mint_keys(&client).await;
+    let wallet = CashuWallet::new(client.to_owned(), keys);
+    test_get_mint_keysets(&client).await;
     test_request_mint(&wallet).await;
     let token = test_mint(&wallet).await;
     let new_token = test_receive(&wallet, &token).await;
 
-    test_check_spendable(&mint, &new_token).await;
+    test_check_spendable(&client, &new_token).await;
 
-    test_check_fees(&mint).await;
+    test_check_fees(&client).await;
 }
 
-async fn test_get_mint_keys(mint: &CashuMint) -> MintKeys {
-    let mint_keys = mint.get_keys().await.unwrap();
+async fn test_get_mint_keys(client: &Client) -> MintKeys {
+    let mint_keys = client.get_keys().await.unwrap();
     // println!("{:?}", mint_keys.0.capacity());
     assert!(mint_keys.0.capacity() > 1);
 
     mint_keys
 }
 
-async fn test_get_mint_keysets(mint: &CashuMint) {
-    let mint_keysets = mint.get_keysets().await.unwrap();
+async fn test_get_mint_keysets(client: &Client) {
+    let mint_keysets = client.get_keysets().await.unwrap();
 
     assert!(!mint_keysets.keysets.is_empty())
 }
@@ -71,7 +71,7 @@ async fn test_mint(wallet: &CashuWallet) -> String {
     mint_res.to_string()
 }
 
-async fn test_check_fees(mint: &CashuMint) {
+async fn test_check_fees(mint: &Client) {
     let invoice = Invoice::from_str("lnbc10n1p3a6s0dsp5n55r506t2fv4r0mjcg30v569nk2u9s40ur4v3r3mgtscjvkvnrqqpp5lzfv8fmjzduelk74y9rsrxrayvhyzcdsh3zkdgv0g50napzalvqsdqhf9h8vmmfvdjn5gp58qengdqxq8p3aaymdcqpjrzjqwryaup9lh50kkranzgcdnn2fgvx390wgj5jd07rwr3vxeje0glc7z70cgqqg4sqqqqqqqlgqqqqrucqjq9qyysgqrjky5axsldzhqsjwsc38xa37k6t04le3ws4t26nqej62vst5xkz56qw85r6c4a3tr79588e0ceuuahwgfnkqc6n6269unlwqtvwr5vqqy0ncdq").unwrap();
 
     let _fee = mint.check_fees(invoice).await.unwrap();
@@ -82,7 +82,7 @@ async fn test_receive(wallet: &CashuWallet, token: &str) -> String {
     let prom = wallet.receive(token).await.unwrap();
     println!("{:?}", prom);
     let token = Token {
-        mint: wallet.mint.url.clone(),
+        mint: wallet.client.mint_url.clone(),
         proofs: prom,
     };
 
@@ -96,10 +96,10 @@ async fn test_receive(wallet: &CashuWallet, token: &str) -> String {
     s
 }
 
-async fn test_check_spendable(mint: &CashuMint, token: &str) {
-    let mint_keys = mint.get_keys().await.unwrap();
+async fn test_check_spendable(client: &Client, token: &str) {
+    let mint_keys = client.get_keys().await.unwrap();
 
-    let wallet = CashuWallet::new(mint.to_owned(), mint_keys);
+    let wallet = CashuWallet::new(client.to_owned(), mint_keys);
 
     let token_data = TokenData::from_str(token).unwrap();
     let _spendable = wallet
@@ -109,10 +109,10 @@ async fn test_check_spendable(mint: &CashuMint, token: &str) {
     // println!("Spendable: {:?}", spendable);
 }
 
-async fn test_split(mint: &CashuMint, token: &str) {
-    let mint_keys = mint.get_keys().await.unwrap();
+async fn _test_split(client: &Client, token: &str) {
+    let mint_keys = client.get_keys().await.unwrap();
 
-    let wallet = CashuWallet::new(mint.clone(), mint_keys);
+    let wallet = CashuWallet::new(client.clone(), mint_keys);
     let proofs = wallet.receive(token).await.unwrap();
 
     let split = wallet
@@ -126,11 +126,11 @@ async fn test_split(mint: &CashuMint, token: &str) {
         serde_json::to_string(&split.split_payload)
     );
 
-    let split = mint.split(split.split_payload).await;
+    let split = client.split(split.split_payload).await;
     println!("Split res: {:#?}", split);
 }
 
-async fn test_send(mint: &CashuMint, token: &str) {
+async fn _test_send(mint: &Client, token: &str) {
     let mint_keys = mint.get_keys().await.unwrap();
 
     let wallet = CashuWallet::new(mint.to_owned(), mint_keys);
@@ -140,7 +140,7 @@ async fn test_send(mint: &CashuMint, token: &str) {
     println!("{:?}", send);
 }
 
-async fn test_get_mint_info(mint: &CashuMint) {
+async fn test_get_mint_info(mint: &Client) {
     let _mint_info = mint.get_info().await.unwrap();
 
     // println!("{:?}", mint_info);

src/cashu_wallet.rs

@@ -1,30 +1,31 @@
+//! Cashu Wallet
 use std::str::FromStr;
 
 use bitcoin::Amount;
 
 use crate::{
-    cashu_mint::CashuMint,
-    dhke::{construct_proofs, unblind_message},
+    client::Client,
+    dhke::construct_proofs,
     error::Error,
     types::{
-        BlindedMessage, BlindedMessages, MintKeys, Proof, ProofsStatus, RequestMintResponse,
-        SendProofs, SplitPayload, SplitRequest, Token, TokenData,
+        BlindedMessages, MintKeys, Proof, ProofsStatus, RequestMintResponse, SendProofs,
+        SplitPayload, SplitRequest, Token, TokenData,
     },
 };
 
 pub struct CashuWallet {
-    pub mint: CashuMint,
-    pub keys: MintKeys,
+    pub client: Client,
+    pub mint_keys: MintKeys,
 }
 
 impl CashuWallet {
-    pub fn new(mint: CashuMint, keys: MintKeys) -> Self {
-        Self { mint, keys }
+    pub fn new(client: Client, mint_keys: MintKeys) -> Self {
+        Self { client, mint_keys }
     }
 
     /// Check if a proof is spent
     pub async fn check_proofs_spent(&self, proofs: Vec<Proof>) -> Result<ProofsStatus, Error> {
-        let spendable = self.mint.check_spendable(&proofs).await?;
+        let spendable = self.client.check_spendable(&proofs).await?;
 
         // Separate proofs in spent and unspent based on mint response
         let (spendable, spent): (Vec<_>, Vec<_>) = proofs
@@ -38,9 +39,9 @@ impl CashuWallet {
         })
     }
 
-    /// Request Mint
+    /// Request Token Mint
     pub async fn request_mint(&self, amount: Amount) -> Result<RequestMintResponse, Error> {
-        self.mint.request_mint(amount).await
+        self.client.request_mint(amount).await
     }
 
     /// Mint Token
@@ -48,7 +49,7 @@ impl CashuWallet {
         let blinded_messages = BlindedMessages::random(amount)?;
 
         let mint_res = self
-            .mint
+            .client
             .mint(blinded_messages.clone(), payment_hash)
             .await?;
 
@@ -56,11 +57,11 @@ impl CashuWallet {
             mint_res.promises,
             blinded_messages.rs,
             blinded_messages.secrets,
-            &self.keys,
+            &self.mint_keys,
         )?;
 
         let token = Token {
-            mint: self.mint.url.clone(),
+            mint: self.client.mint_url.clone(),
             proofs,
         };
 
@@ -72,7 +73,7 @@ impl CashuWallet {
 
     /// Check fee
     pub async fn check_fee(&self, invoice: lightning_invoice::Invoice) -> Result<Amount, Error> {
-        Ok(self.mint.check_fees(invoice).await?.fee)
+        Ok(self.client.check_fees(invoice).await?.fee)
     }
 
     /// Receive
@@ -85,12 +86,12 @@ impl CashuWallet {
                 continue;
             }
 
-            let keys = if token.mint.eq(&self.mint.url) {
-                self.keys.clone()
+            let keys = if token.mint.eq(&self.client.mint_url) {
+                self.mint_keys.clone()
             } else {
                 // TODO:
                 println!("No match");
-                self.keys.clone()
+                self.mint_keys.clone()
                 // CashuMint::new(token.mint).get_keys().await.unwrap()
             };
 
@@ -104,7 +105,7 @@ impl CashuWallet {
                 .create_split(Amount::ZERO, amount, token.proofs)
                 .await?;
 
-            let split_response = self.mint.split(split_payload.split_payload).await?;
+            let split_response = self.client.split(split_payload.split_payload).await?;
 
             // Proof to keep
             let keep_proofs = construct_proofs(
@@ -191,14 +192,14 @@ impl CashuWallet {
             .create_split(amount_to_keep, amount_to_send, send_proofs.send_proofs)
             .await?;
 
-        let split_response = self.mint.split(split_payload.split_payload).await?;
+        let split_response = self.client.split(split_payload.split_payload).await?;
 
         // Proof to keep
         let keep_proofs = construct_proofs(
             split_response.fst,
             split_payload.keep_blinded_messages.rs,
             split_payload.keep_blinded_messages.secrets,
-            &self.keys,
+            &self.mint_keys,
         )?;
 
         // Proofs to send
@@ -206,7 +207,7 @@ impl CashuWallet {
             split_response.snd,
             split_payload.send_blinded_messages.rs,
             split_payload.send_blinded_messages.secrets,
-            &self.keys,
+            &self.mint_keys,
         )?;
 
         println!("Send Proofs: {:#?}", send_proofs);

src/cashu_mint.rs → src/client.rs

@@ -1,3 +1,5 @@
+//! Client to connet to mint
+
 use std::collections::HashMap;
 
 use bitcoin::Amount;
@@ -17,18 +19,18 @@ use crate::{
 };
 
 #[derive(Debug, Clone)]
-pub struct CashuMint {
-    pub url: Url,
+pub struct Client {
+    pub mint_url: Url,
 }
 
-impl CashuMint {
-    pub fn new(url: Url) -> Self {
-        Self { url }
+impl Client {
+    pub fn new(mint_url: Url) -> Self {
+        Self { mint_url }
     }
 
     /// Get Mint Keys [NUT-01]
     pub async fn get_keys(&self) -> Result<MintKeys, Error> {
-        let url = self.url.join("keys")?;
+        let url = self.mint_url.join("keys")?;
         let keys = minreq::get(url).send()?.json::<HashMap<u64, String>>()?;
 
         Ok(MintKeys(
@@ -45,13 +47,13 @@ impl CashuMint {
 
     /// Get Keysets [NUT-02]
     pub async fn get_keysets(&self) -> Result<MintKeySets, Error> {
-        let url = self.url.join("keysets")?;
+        let url = self.mint_url.join("keysets")?;
         Ok(minreq::get(url).send()?.json::<MintKeySets>()?)
     }
 
     /// Request Mint [NUT-03]
     pub async fn request_mint(&self, amount: Amount) -> Result<RequestMintResponse, Error> {
-        let mut url = self.url.join("mint")?;
+        let mut url = self.mint_url.join("mint")?;
         url.query_pairs_mut()
             .append_pair("amount", &amount.to_sat().to_string());
         println!("{url}");
@@ -65,7 +67,7 @@ impl CashuMint {
         blinded_messages: BlindedMessages,
         payment_hash: &str,
     ) -> Result<PostMintResponse, Error> {
-        let mut url = self.url.join("mint")?;
+        let mut url = self.mint_url.join("mint")?;
         url.query_pairs_mut()
             .append_pair("payment_hash", payment_hash);
 
@@ -81,7 +83,7 @@ impl CashuMint {
 
     /// Check Max expected fee [NUT-05]
     pub async fn check_fees(&self, invoice: Invoice) -> Result<CheckFeesResponse, Error> {
-        let url = self.url.join("checkfees")?;
+        let url = self.mint_url.join("checkfees")?;
 
         let request = CheckFeesRequest { pr: invoice };
 
@@ -99,7 +101,7 @@ impl CashuMint {
         invoice: Invoice,
         outputs: Option<Vec<BlindedMessage>>,
     ) -> Result<MeltResponse, Error> {
-        let url = self.url.join("melt")?;
+        let url = self.mint_url.join("melt")?;
 
         let request = MeltRequest {
             proofs,
@@ -115,7 +117,7 @@ impl CashuMint {
 
     /// Split Token [NUT-06]
     pub async fn split(&self, split_request: SplitRequest) -> Result<SplitResponse, Error> {
-        let url = self.url.join("split")?;
+        let url = self.mint_url.join("split")?;
 
         let res = minreq::post(url)
             .with_json(&split_request)?
@@ -124,7 +126,7 @@ impl CashuMint {
 
         // TODO: need to handle response error
         // specifically token already spent
-        println!("{:?}", res);
+        // println!("{:?}", res);
 
         Ok(serde_json::from_value(res).unwrap())
     }
@@ -134,7 +136,7 @@ impl CashuMint {
         &self,
         proofs: &Vec<Proof>,
     ) -> Result<CheckSpendableResponse, Error> {
-        let url = self.url.join("check")?;
+        let url = self.mint_url.join("check")?;
         let request = CheckSpendableRequest {
             proofs: proofs.to_owned(),
         };
@@ -147,7 +149,7 @@ impl CashuMint {
 
     /// Get Mint Info [NUT-09]
     pub async fn get_info(&self) -> Result<MintInfo, Error> {
-        let url = self.url.join("info")?;
+        let url = self.mint_url.join("info")?;
         Ok(minreq::get(url).send()?.json::<MintInfo>()?)
     }
 }

src/dhke.rs

@@ -1,21 +1,13 @@
 //! Diffie-Hellmann key exchange
 
-use std::ops::{Add, Mul, Neg};
+use std::ops::Mul;
 
 use bitcoin_hashes::sha256;
 use bitcoin_hashes::Hash;
-// use secp256k1::rand::rngs::OsRng;
-// use secp256k1::{PublicKey, Scalar, Secp256k1, SecretKey};
-
-use k256::Scalar;
-use k256::{AffinePoint, ProjectivePoint, PublicKey, Secp256k1, SecretKey};
-
-use rand::rngs::OsRng;
+use k256::{ProjectivePoint, PublicKey, Scalar, SecretKey};
 
 use crate::error::Error;
-use crate::types::MintKeys;
-use crate::types::Promise;
-use crate::types::Proof;
+use crate::types::{MintKeys, Promise, Proof};
 
 fn hash_to_curve(message: &[u8]) -> PublicKey {
     let mut msg_to_hash = message.to_vec();
@@ -70,29 +62,6 @@ pub fn unblind_message(
     Ok(PublicKey::try_from(c).unwrap())
 }
 
-/// Sign Blinded Message (Step2 bob)
-// Really only needed for mint
-// Used here for testing
-fn _sign_message(a: SecretKey, blinded_message: PublicKey) -> Result<PublicKey, Error> {
-    Ok(PublicKey::try_from(
-        blinded_message
-            .as_affine()
-            .mul(Scalar::from(a.as_scalar_primitive())),
-    )
-    .unwrap())
-}
-
-/// Verify Message
-// Really only needed for mint
-// used for testing
-fn _verify_message(a: SecretKey, unblinded_message: PublicKey, msg: &str) -> Result<bool, Error> {
-    // Y
-    let y = hash_to_curve(msg.as_bytes());
-
-    Ok(unblinded_message
-        == PublicKey::try_from(*y.as_affine() * Scalar::from(a.as_scalar_primitive())).unwrap())
-}
-
 /// Construct Proof
 pub fn construct_proofs(
     promises: Vec<Promise>,
@@ -122,9 +91,6 @@ pub fn construct_proofs(
 
     Ok(proofs)
 }
-pub fn verify_proof(proof: Proof, keys: &MintKeys) -> Result<(), Error> {
-    Ok(())
-}
 
 #[cfg(test)]
 mod tests {
@@ -189,7 +155,7 @@ mod tests {
         let bob_sec = SecretKey::new(ScalarPrimitive::ONE);
 
         // C_
-        let signed = _sign_message(bob_sec, blinded_message).unwrap();
+        let signed = sign_message(bob_sec, blinded_message).unwrap();
 
         assert_eq!(
             signed,
@@ -228,6 +194,34 @@ mod tests {
         );
     }
 
+    /// Sign Blinded Message (Step2 bob)
+    // Really only needed for mint
+    // Used here for testing
+    fn sign_message(a: SecretKey, blinded_message: PublicKey) -> Result<PublicKey, Error> {
+        Ok(PublicKey::try_from(
+            blinded_message
+                .as_affine()
+                .mul(Scalar::from(a.as_scalar_primitive())),
+        )
+        .unwrap())
+    }
+
+    /// Verify Message
+    // Really only needed for mint
+    // used for testing
+    fn verify_message(
+        a: SecretKey,
+        unblinded_message: PublicKey,
+        msg: &str,
+    ) -> Result<bool, Error> {
+        // Y
+        let y = hash_to_curve(msg.as_bytes());
+
+        Ok(unblinded_message
+            == PublicKey::try_from(*y.as_affine() * Scalar::from(a.as_scalar_primitive())).unwrap())
+    }
+
+    #[ignore]
     #[test]
     fn test_blinded_dhke() {
         // a
@@ -247,11 +241,11 @@ mod tests {
         let blinded = blind_message(&y.to_sec1_bytes(), None).unwrap();
 
         // C_
-        let signed = _sign_message(bob_sec.clone(), blinded.0).unwrap();
+        let signed = sign_message(bob_sec.clone(), blinded.0).unwrap();
 
         // C
         let c = unblind_message(signed, blinded.1, bob_pub).unwrap();
 
-        assert!(_verify_message(bob_sec, c, &x).unwrap());
+        assert!(verify_message(bob_sec, c, &x).unwrap());
     }
 }

src/lib.rs

@@ -1,5 +1,5 @@
-pub mod cashu_mint;
 pub mod cashu_wallet;
+pub mod client;
 pub mod dhke;
 pub mod error;
 pub mod serde_utils;

src/types.rs

@@ -58,23 +58,19 @@ impl BlindedMessages {
         Ok(blinded_messages)
     }
 
-    /*
-
     pub fn blank() -> Result<Self, Error> {
         let mut blinded_messages = BlindedMessages::default();
 
-        let mut rng = rand::thread_rng();
         for _i in 0..4 {
-            let bytes: [u8; 32] = rng.gen();
-            let secret_base64 = general_purpose::STANDARD.encode(bytes);
-            let (blinded, r) = blind_message(secret_base64.as_bytes(), None)?;
+            let secret = generate_secret();
+            let (blinded, r) = blind_message(secret.as_bytes(), None)?;
 
             let blinded_message = BlindedMessage {
                 amount: Amount::ZERO,
                 b: blinded,
             };
 
-            blinded_messages.secrets.push(secret_base64);
+            blinded_messages.secrets.push(secret);
             blinded_messages.blinded_messages.push(blinded_message);
             blinded_messages.rs.push(r);
             blinded_messages.amounts.push(Amount::ZERO);
@@ -82,7 +78,6 @@ impl BlindedMessages {
 
         Ok(blinded_messages)
     }
-    */
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

src/utils.rs

@@ -1,3 +1,5 @@
+//! Utils
+
 use base64::{engine::general_purpose, Engine as _};
 use bitcoin::Amount;
 use rand::prelude::*;
@@ -15,6 +17,7 @@ pub fn split_amount(amount: Amount) -> Vec<Amount> {
     chunks
 }
 
+/// Generate Secret Message
 pub fn generate_secret() -> String {
     let mut rng = rand::thread_rng();
     let mut secret = [0u8; 32];