refactor: add_blind_signature to add_blind_signatures

CHANGELOG.md

@@ -27,8 +27,10 @@
 ### Summary
 
 ### Changed
-- cdk(wallet): `fn send` returns `Token` so the user can use the struct of convert it to a v3 or v4 string.
+- cdk(wallet): `fn send` returns `Token` so the user can use the struct of convert it to a v3 or v4 string ([thesimplekid]).
 - cdk(wallet): Publicly export `MultiMintWallet` ([thesimplekid]).
+- cdk-database: Get `pending` and `spent` `proofs` by `ys` or `secrets` instead of a single proofs ([thesimplekid]).
+- cdk-database: Change `add_blind_signature` to `add_blind_signatures` ([thesimplekid]).
 
 ### Added
 - cdk(NUT-11): Add `Copy` on `SigFlag` ([thesimplekid]).

crates/cdk-redb/src/mint/mod.rs

@@ -660,10 +660,10 @@ impl MintDatabase for MintRedbDatabase {
         Ok(())
     }
 
-    async fn add_blinded_signature(
+    async fn add_blind_signatures(
         &self,
-        blinded_message: PublicKey,
-        blinded_signature: BlindSignature,
+        blinded_messages: &[PublicKey],
+        blind_signatures: &[BlindSignature],
     ) -> Result<(), Self::Err> {
         let db = self.db.lock().await;
         let write_txn = db.begin_write().map_err(Error::from)?;
@@ -672,14 +672,18 @@ impl MintDatabase for MintRedbDatabase {
             let mut table = write_txn
                 .open_table(BLINDED_SIGNATURES)
                 .map_err(Error::from)?;
-            table
-                .insert(
-                    blinded_message.to_bytes(),
-                    serde_json::to_string(&blinded_signature)
-                        .map_err(Error::from)?
-                        .as_str(),
-                )
-                .map_err(Error::from)?;
+
+            for (blinded_message, blind_signature) in blinded_messages.iter().zip(blind_signatures)
+            {
+                table
+                    .insert(
+                        blinded_message.to_bytes(),
+                        serde_json::to_string(&blind_signature)
+                            .map_err(Error::from)?
+                            .as_str(),
+                    )
+                    .map_err(Error::from)?;
+            }
         }
 
         write_txn.commit().map_err(Error::from)?;

crates/cdk-sqlite/src/mint/mod.rs

@@ -689,25 +689,30 @@ AND state="PENDING";
         Ok(())
     }
 
-    async fn add_blinded_signature(
+    async fn add_blind_signatures(
         &self,
-        blinded_message: PublicKey,
-        blinded_signature: BlindSignature,
+        blinded_messages: &[PublicKey],
+        blinded_signatures: &[BlindSignature],
     ) -> Result<(), Self::Err> {
-        sqlx::query(
-            r#"
+        let mut transaction = self.pool.begin().await.map_err(Error::from)?;
+        for (message, signature) in blinded_messages.iter().zip(blinded_signatures) {
+            sqlx::query(
+                r#"
 INSERT INTO blind_signature
 (y, amount, keyset_id, c)
 VALUES (?, ?, ?, ?);
         "#,
-        )
-        .bind(blinded_message.to_bytes().to_vec())
-        .bind(u64::from(blinded_signature.amount) as i64)
-        .bind(blinded_signature.keyset_id.to_string())
-        .bind(blinded_signature.c.to_bytes().to_vec())
-        .execute(&self.pool)
-        .await
-        .map_err(Error::from)?;
+            )
+            .bind(message.to_bytes().to_vec())
+            .bind(u64::from(signature.amount) as i64)
+            .bind(signature.keyset_id.to_string())
+            .bind(signature.c.to_bytes().to_vec())
+            .execute(&mut transaction)
+            .await
+            .map_err(Error::from)?;
+        }
+
+        transaction.commit().await.map_err(Error::from)?;
 
         Ok(())
     }

crates/cdk/src/cdk_database/mint_memory.rs

@@ -315,15 +315,17 @@ impl MintDatabase for MintMemoryDatabase {
         Ok(())
     }
 
-    async fn add_blinded_signature(
+    async fn add_blind_signatures(
         &self,
-        blinded_message: PublicKey,
-        blinded_signature: BlindSignature,
+        blinded_message: &[PublicKey],
+        blind_signatures: &[BlindSignature],
     ) -> Result<(), Self::Err> {
-        self.blinded_signatures
-            .write()
-            .await
-            .insert(blinded_message.to_bytes(), blinded_signature);
+        let mut current_blinded_signatures = self.blinded_signatures.write().await;
+
+        for (blinded_message, blind_signature) in blinded_message.iter().zip(blind_signatures) {
+            current_blinded_signatures.insert(blinded_message.to_bytes(), blind_signature.clone());
+        }
+
         Ok(())
     }
 

crates/cdk/src/cdk_database/mod.rs

@@ -246,10 +246,10 @@ pub trait MintDatabase {
     async fn remove_pending_proofs(&self, secret: Vec<&Secret>) -> Result<(), Self::Err>;
 
     /// Add [`BlindSignature`]
-    async fn add_blinded_signature(
+    async fn add_blind_signatures(
         &self,
-        blinded_message: PublicKey,
-        blinded_signature: BlindSignature,
+        blinded_messages: &[PublicKey],
+        blind_signatures: &[BlindSignature],
     ) -> Result<(), Self::Err>;
     /// Get [`BlindSignature`]
     async fn get_blinded_signature(

crates/cdk/src/mint/mod.rs

@@ -495,15 +495,23 @@ impl Mint {
 
         let mut blind_signatures = Vec::with_capacity(mint_request.outputs.len());
 
-        for blinded_message in mint_request.outputs.into_iter() {
-            let blinded_signature = self.blind_sign(&blinded_message).await?;
-            self.localstore
-                .add_blinded_signature(blinded_message.blinded_secret, blinded_signature.clone())
-                .await?;
-            blind_signatures.push(blinded_signature);
+        for blinded_message in mint_request.outputs.iter() {
+            let blind_signature = self.blind_sign(blinded_message).await?;
+            blind_signatures.push(blind_signature);
         }
 
         self.localstore
+            .add_blind_signatures(
+                &mint_request
+                    .outputs
+                    .iter()
+                    .map(|p| p.blinded_secret)
+                    .collect::<Vec<PublicKey>>(),
+                &blind_signatures,
+            )
+            .await?;
+
+        self.localstore
             .update_mint_quote_state(&mint_request.quote, MintQuoteState::Issued)
             .await?;
 
@@ -704,14 +712,22 @@ impl Mint {
 
         let mut promises = Vec::with_capacity(swap_request.outputs.len());
 
-        for blinded_message in swap_request.outputs {
-            let blinded_signature = self.blind_sign(&blinded_message).await?;
-            self.localstore
-                .add_blinded_signature(blinded_message.blinded_secret, blinded_signature.clone())
-                .await?;
+        for blinded_message in swap_request.outputs.iter() {
+            let blinded_signature = self.blind_sign(blinded_message).await?;
             promises.push(blinded_signature);
         }
 
+        self.localstore
+            .add_blind_signatures(
+                &swap_request
+                    .outputs
+                    .iter()
+                    .map(|o| o.blinded_secret)
+                    .collect::<Vec<PublicKey>>(),
+                &promises,
+            )
+            .await?;
+
         Ok(SwapResponse::new(promises))
     }
 
@@ -1008,20 +1024,25 @@ impl Mint {
                 amounts.sort_by(|a, b| b.cmp(a));
             }
 
-            for (amount, blinded_message) in amounts.iter().zip(outputs) {
-                let mut blinded_message = blinded_message;
+            let mut outputs = outputs;
+
+            for (amount, blinded_message) in amounts.iter().zip(&mut outputs) {
                 blinded_message.amount = *amount;
 
-                let blinded_signature = self.blind_sign(&blinded_message).await?;
-                self.localstore
-                    .add_blinded_signature(
-                        blinded_message.blinded_secret,
-                        blinded_signature.clone(),
-                    )
-                    .await?;
+                let blinded_signature = self.blind_sign(blinded_message).await?;
                 change_sigs.push(blinded_signature)
             }
 
+            self.localstore
+                .add_blind_signatures(
+                    &outputs[0..change_sigs.len()]
+                        .iter()
+                        .map(|o| o.blinded_secret)
+                        .collect::<Vec<PublicKey>>(),
+                    &change_sigs,
+                )
+                .await?;
+
             change = Some(change_sigs);
         } else {
             tracing::info!(