aljaz/cdk
1
0
Fork 0
mirror of https://github.com/aljazceru/cdk.git synced 2025-12-20 14:14:49 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor: add_blind_signature to add_blind_signatures

Browse Source
This commit is contained in:
thesimplekid
2024-07-16 01:31:35 +01:00
parent ed007c475e
commit d45019ae8b
6 changed files with 89 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@@ -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]).

12
crates/cdk-redb/src/mint/mod.rs
View File

@@ -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,15 +672,19 @@ impl MintDatabase for MintRedbDatabase {
let mut table = write_txn
.open_table(BLINDED_SIGNATURES)
.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(&blinded_signature)
serde_json::to_string(&blind_signature)
.map_err(Error::from)?
.as_str(),
)
.map_err(Error::from)?;
}
}
write_txn.commit().map_err(Error::from)?;

21
crates/cdk-sqlite/src/mint/mod.rs
View File

@@ -689,11 +689,13 @@ 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> {
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
@@ -701,13 +703,16 @@ INSERT INTO blind_signature
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)
.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(())
}

16
crates/cdk/src/cdk_database/mint_memory.rs
View File

@@ -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(())
}

6
crates/cdk/src/cdk_database/mod.rs
View File

@@ -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(

61
crates/cdk/src/mint/mod.rs
View File

@@ -495,14 +495,22 @@ 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!(