fix: order split correctly

src/mint.rs

@@ -93,48 +93,12 @@ impl Mint {
         })
     }
 
-    fn create_split_response(
-        &self,
-        amount: Amount,
-        outputs: &[BlindedMessage],
-    ) -> Result<SplitResponse, Error> {
-        let mut outputs = outputs.to_vec();
-        outputs.reverse();
-        let mut target_total = Amount::ZERO;
-        let mut change_total = Amount::ZERO;
-        let mut target = Vec::with_capacity(outputs.len());
-        let mut change = Vec::with_capacity(outputs.len());
-
-        // Create sets of target and change amounts that we're looking for
-        // in the outputs (blind messages). As we loop, take from those sets,
-        // target amount first.
-        for output in outputs {
-            let signed = self.blind_sign(&output)?;
-
-            // Accumulate outputs into the target (send) list
-            if target_total + signed.amount <= amount {
-                target_total += signed.amount;
-                target.push(signed);
-            } else {
-                change_total += signed.amount;
-                change.push(signed);
-            }
-        }
-
-        println!("change: {:?}", serde_json::to_string(&change));
-        println!("send: {:?}", serde_json::to_string(&target));
-
-        Ok(SplitResponse {
-            fst: change,
-            snd: target,
-        })
-    }
-
     pub fn process_split_request(
         &mut self,
         split_request: SplitRequest,
     ) -> Result<SplitResponse, Error> {
         let proofs_total = split_request.proofs_amount();
+
         if proofs_total < split_request.amount {
             return Err(Error::Amount);
         }
@@ -153,21 +117,25 @@ impl Mint {
             secrets.push(self.verify_proof(proof)?);
         }
 
-        let mut split_response =
-            self.create_split_response(split_request.amount, &split_request.outputs)?;
+        let outs_fst = (proofs_total - split_request.amount).split();
 
-        if split_response.target_amount() != split_request.amount {
-            let mut outputs = split_request.outputs;
-            outputs.reverse();
-            split_response = self.create_split_response(split_request.amount, &outputs)?;
-        }
+        // Blinded change messages
+        let b_fst = split_request.outputs[0..outs_fst.len()].to_vec();
+        let b_snd = split_request.outputs[outs_fst.len()..].to_vec();
+
+        let fst: Vec<BlindedSignature> =
+            b_fst.iter().map(|b| self.blind_sign(b).unwrap()).collect();
+        let snd: Vec<BlindedSignature> =
+            b_snd.iter().map(|b| self.blind_sign(b).unwrap()).collect();
+
+        let split_response = SplitResponse { snd, fst };
 
         if split_response.target_amount() != split_request.amount {
             return Err(Error::OutputOrdering);
         }
 
-        for secret in secrets {
-            self.spent_secrets.insert(secret);
+        for proof in split_request.proofs {
+            self.spent_secrets.insert(proof.secret);
         }
 
         Ok(split_response)
@@ -208,7 +176,7 @@ impl Mint {
     ) -> Result<CheckSpendableResponse, Error> {
         let mut spendable = vec![];
         for proof in &check_spendable.proofs {
-            spendable.push(self.spent_secrets.contains(&proof.secret))
+            spendable.push(!self.spent_secrets.contains(&proof.secret))
         }
 
         Ok(CheckSpendableResponse { spendable })

src/wallet.rs

@@ -139,6 +139,12 @@ impl Wallet {
         proofs: Proofs,
     ) -> Result<SplitPayload, Error> {
         let keep_blinded_messages = BlindedMessages::random(keep_amount)?;
+        let out_amounts: Vec<Amount> = keep_blinded_messages
+            .blinded_messages
+            .iter()
+            .map(|o| o.amount)
+            .collect();
+        println!("keep outs: {:?}", out_amounts);
         let send_blinded_messages = BlindedMessages::random(send_amount)?;
 
         let outputs = {
@@ -146,6 +152,9 @@ impl Wallet {
             outputs.extend(send_blinded_messages.blinded_messages.clone());
             outputs
         };
+
+        let out_amounts: Vec<Amount> = outputs.iter().map(|o| o.amount).collect();
+        println!("outs: {:?}", out_amounts);
         let split_payload = SplitRequest {
             amount: send_amount,
             proofs,
@@ -337,22 +346,13 @@ mod tests {
 
         let wallet = Wallet::new(client, keys.keys);
 
-        let blinded_messages = BlindedMessages::random(Amount::from_sat(100)).unwrap();
+        let blinded_messages = BlindedMessages::random(Amount::from_sat(64)).unwrap();
 
         let mint_request = nut04::MintRequest {
             outputs: blinded_messages.blinded_messages.clone(),
         };
 
         let res = mint.process_mint_request(mint_request).unwrap();
-        /*
-                let proofs = construct_proofs(
-                    res.promises,
-                    blinded_messages.rs,
-                    blinded_messages.secrets,
-                    &mint.active_keyset_pubkeys().keys,
-                )
-                .unwrap();
-        */
 
         let proofs = wallet
             .process_split_response(blinded_messages, res.promises)
@@ -362,26 +362,18 @@ mod tests {
         }
 
         let split = wallet
-            .create_split(Amount::from_sat(33), Amount::from_sat(67), proofs.clone())
+            .create_split(Amount::from_sat(24), Amount::from_sat(40), proofs.clone())
             .unwrap();
 
         let split_request = split.split_payload;
+
         let split_response = mint.process_split_request(split_request).unwrap();
-        let mut p = split_response.snd;
-        p.reverse();
+        let p = split_response.snd;
 
         let snd_proofs = wallet
             .process_split_response(split.send_blinded_messages, p)
             .unwrap();
-        /*
-        let snd_proofs = construct_proofs(
-            split_response.snd,
-            split.send_blinded_messages.rs,
-            split.send_blinded_messages.secrets,
-            &mint.active_keyset_pubkeys().keys,
-        )
-        .unwrap();
-        */
+
         let mut error = false;
         for proof in &snd_proofs {
             if let Err(err) = mint.verify_proof(proof) {