aljaz/cdk
1
0
Fork 0
mirror of https://github.com/aljazceru/cdk.git synced 2026-02-23 14:06:56 +01:00
Code Issues Packages Projects Releases Wiki Activity

wallet: remove amount in split request

Browse Source
This commit is contained in:
thesimplekid
2023-07-09 10:22:12 -04:00
parent f5a53704bb
commit f18d53caff
2 changed files with 26 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/nuts/nut06.rs
View File

@@ -9,8 +9,7 @@ use super::nut00::BlindedSignature;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SplitPayload {
pub keep_blinded_messages: BlindedMessages,
pub send_blinded_messages: BlindedMessages,
pub blinded_messages: BlindedMessages,
pub split_payload: SplitRequest,
}

98
src/wallet.rs
View File

@@ -1,6 +1,9 @@
//! Cashu Wallet
use std::str::FromStr;
use log::warn;
use crate::amount::Amount;
use crate::dhke::unblind_message;
use crate::nuts::nut00::{mint, BlindedMessages, BlindedSignature, Proof, Proofs, Token};
use crate::nuts::nut01::Keys;
@@ -10,8 +13,6 @@ use crate::types::{Melted, ProofsStatus, SendProofs};
pub use crate::Invoice;
use crate::{client::Client, dhke::construct_proofs, error::Error};
use crate::amount::Amount;
#[derive(Clone, Debug)]
pub struct Wallet {
pub client: Client,
@@ -97,73 +98,45 @@ impl Wallet {
};
// Sum amount of all proofs
let amount = token
.proofs
.iter()
.fold(Amount::ZERO, |acc, p| acc + p.amount);
let amount: Amount = token.proofs.iter().map(|p| p.amount).sum();
let split_payload = self.create_split(Amount::ZERO, amount, token.proofs)?;
let split_payload = self.create_split(token.proofs)?;
let split_response = self.client.split(split_payload.split_payload).await?;
if let Some(promises) = &split_response.promises {
// Proof to keep
let p = construct_proofs(
split_response.promises.unwrap(),
split_payload.keep_blinded_messages.rs,
split_payload.keep_blinded_messages.secrets,
promises.to_owned(),
split_payload.blinded_messages.rs,
split_payload.blinded_messages.secrets,
&keys,
)?;
proofs.push(p);
} else {
// Proof to keep
let keep_proofs = construct_proofs(
split_response.fst.unwrap(),
split_payload.keep_blinded_messages.rs,
split_payload.keep_blinded_messages.secrets,
&keys,
)?;
// Proofs to send
let send_proofs = construct_proofs(
split_response.snd.unwrap(),
split_payload.send_blinded_messages.rs,
split_payload.send_blinded_messages.secrets,
&keys,
)?;
proofs.push(send_proofs);
proofs.push(keep_proofs);
warn!("Response missing promises");
return Err(Error::CustomError(
"Split response missing promises".to_string(),
));
}
}
Ok(proofs.iter().flatten().cloned().collect())
}
/// Create Split Payload
fn create_split(
&self,
keep_amount: Amount,
send_amount: Amount,
proofs: Proofs,
) -> Result<SplitPayload, Error> {
let keep_blinded_messages = BlindedMessages::random(keep_amount)?;
let send_blinded_messages = BlindedMessages::random(send_amount)?;
fn create_split(&self, proofs: Proofs) -> Result<SplitPayload, Error> {
let value = proofs.iter().map(|p| p.amount).sum();
let outputs = {
let mut outputs = keep_blinded_messages.blinded_messages.clone();
outputs.extend(send_blinded_messages.blinded_messages.clone());
outputs
};
let blinded_messages = BlindedMessages::random(value)?;
let split_payload = SplitRequest {
amount: Some(send_amount),
amount: None,
proofs,
outputs,
outputs: blinded_messages.blinded_messages.clone(),
};
Ok(SplitPayload {
keep_blinded_messages,
send_blinded_messages,
blinded_messages,
split_payload,
})
}
@@ -235,22 +208,19 @@ impl Wallet {
let amount_to_keep = amount_available - amount;
let amount_to_send = amount;
// TODO: Will need to change https://github.com/cashubtc/cashu/pull/263/files
let split_payload =
self.create_split(amount_to_keep, amount_to_send, send_proofs.send_proofs)?;
let split_payload = self.create_split(send_proofs.send_proofs)?;
let split_response = self.client.split(split_payload.split_payload).await?;
// If only prmises assemble proofs needed for amount
// If only promises assemble proofs needed for amount
let keep_proofs;
let send_proofs;
if let Some(promises) = split_response.promises {
let proofs = construct_proofs(
promises,
split_payload.keep_blinded_messages.rs,
split_payload.keep_blinded_messages.secrets,
split_payload.blinded_messages.rs,
split_payload.blinded_messages.secrets,
&self.mint_keys,
)?;
@@ -258,22 +228,6 @@ impl Wallet {
keep_proofs = proofs[0..split.len()].to_vec();
send_proofs = proofs[split.len()..].to_vec();
} else if let (Some(fst), Some(snd)) = (split_response.fst, split_response.snd) {
// Proof to keep
keep_proofs = construct_proofs(
fst,
split_payload.keep_blinded_messages.rs,
split_payload.keep_blinded_messages.secrets,
&self.mint_keys,
)?;
// Proofs to send
send_proofs = construct_proofs(
snd,
split_payload.send_blinded_messages.rs,
split_payload.send_blinded_messages.secrets,
&self.mint_keys,
)?;
} else {
return Err(Error::CustomError("Invalid split response".to_string()));
}
@@ -365,17 +319,15 @@ mod tests {
mint.verify_proof(proof).unwrap();
}
let split = wallet
.create_split(Amount::from_sat(24), Amount::from_sat(40), proofs.clone())
.unwrap();
let split = wallet.create_split(proofs.clone()).unwrap();
let split_request = split.split_payload;
let split_response = mint.process_split_request(split_request).unwrap();
let p = split_response.snd;
let p = split_response.promises;
let snd_proofs = wallet
.process_split_response(split.send_blinded_messages, p.unwrap())
.process_split_response(split.blinded_messages, p.unwrap())
.unwrap();
let mut error = false;