refactor(builder)!: keep revealedoutputs

- Instead of revealed amounts, we keep the revealed outputs, which
allows us to find the revealed amount by output key.

src/builder.rs

@@ -14,7 +14,7 @@ use std::{
 };
 
 use crate::transaction::{
-    DbcTransaction, Output, RevealedAmount, RevealedInput, RevealedTransaction,
+    DbcTransaction, Output, RevealedAmount, RevealedInput, RevealedOutput, RevealedTransaction,
 };
 use crate::{
     rand::{CryptoRng, RngCore},
@@ -177,11 +177,11 @@ impl TransactionBuilder {
     /// Build the DbcTransaction by signing the inputs,
     /// and generating the blinded outputs. Return a DbcBuilder.
     pub fn build(self, rng: impl RngCore + CryptoRng) -> Result<DbcBuilder> {
-        let (transaction, revealed_amounts) = self.revealed_tx.sign(rng)?;
+        let (transaction, revealed_outputs) = self.revealed_tx.sign(rng)?;
 
         Ok(DbcBuilder::new(
             transaction,
-            revealed_amounts,
+            revealed_outputs,
             self.output_owner_map,
             self.revealed_tx,
         ))
@@ -193,7 +193,7 @@ impl TransactionBuilder {
 #[derive(Debug, Clone)]
 pub struct DbcBuilder {
     pub transaction: DbcTransaction,
-    pub revealed_amounts: Vec<RevealedAmount>,
+    pub revealed_outputs: Vec<RevealedOutput>,
     pub output_owner_map: OutputOwnerMap,
     pub revealed_tx: RevealedTransaction,
     pub spent_proofs: HashSet<SpentProof>,
@@ -205,13 +205,13 @@ impl DbcBuilder {
     /// Create a new DbcBuilder
     pub fn new(
         transaction: DbcTransaction,
-        revealed_amounts: Vec<RevealedAmount>,
+        revealed_outputs: Vec<RevealedOutput>,
         output_owner_map: OutputOwnerMap,
         revealed_tx: RevealedTransaction,
     ) -> Self {
         Self {
             transaction,
-            revealed_amounts,
+            revealed_outputs,
             output_owner_map,
             revealed_tx,
             spent_proofs: Default::default(),
@@ -305,9 +305,10 @@ impl DbcBuilder {
     ) -> Result<Vec<(Dbc, OwnerOnce, RevealedAmount)>> {
         let pc_gens = PedersenGens::default();
         let output_blinded_and_revealed_amounts: Vec<(BlindedAmount, RevealedAmount)> = self
-            .revealed_amounts
+            .revealed_outputs
             .iter()
-            .map(|r| (r.blinded_amount(&pc_gens), *r))
+            .map(|output| output.revealed_amount)
+            .map(|r| (r.blinded_amount(&pc_gens), r))
             .collect();
 
         let owner_once_list: Vec<&OwnerOnce> = self

src/dbc.rs

@@ -431,7 +431,7 @@ pub(crate) mod tests {
         let input_content = DbcContent::from((
             owner_once.owner_base.clone(),
             owner_once.derivation_index,
-            revealed_amounts[0],
+            revealed_amounts[0].revealed_amount,
         ));
         let public_key = owner_once
             .owner_base
@@ -469,7 +469,7 @@ pub(crate) mod tests {
         let input_content = DbcContent::from((
             owner_once.owner_base.clone(),
             owner_once.derivation_index,
-            revealed_amounts[0],
+            revealed_amounts[0].revealed_amount,
         ));
         let public_key = owner_once
             .owner_base
@@ -568,7 +568,7 @@ pub(crate) mod tests {
         let input_content = DbcContent::from((
             owner_once.owner_base.clone(),
             owner_once.derivation_index,
-            revealed_amounts[0],
+            revealed_amounts[0].revealed_amount,
         ));
 
         let public_key = owner_once
@@ -684,9 +684,10 @@ pub(crate) mod tests {
         let output = dbc_builder.transaction.outputs.get(0).unwrap();
         let pc_gens = PedersenGens::default();
         let output_blinded_and_revealed_amounts: Vec<(BlindedAmount, RevealedAmount)> = dbc_builder
-            .revealed_amounts
+            .revealed_outputs
             .iter()
-            .map(|r| (r.blinded_amount(&pc_gens), *r))
+            .map(|output| output.revealed_amount)
+            .map(|r| (r.blinded_amount(&pc_gens), r))
             .collect();
         let revealed_amount_list: Vec<RevealedAmount> = output_blinded_and_revealed_amounts
             .iter()

src/mint.rs

@@ -377,7 +377,7 @@ mod tests {
             .add_output_by_amount(Token::from_nano(100), output1_owner.clone())
             .build(&mut rng)?;
 
-        let revealed_amount = dbc_builder.revealed_amounts[0];
+        let revealed_amount = dbc_builder.revealed_outputs[0].revealed_amount;
         let secret_key = output1_owner.as_owner().secret_key()?;
 
         let output2_owner =

src/transaction/mod.rs

@@ -9,8 +9,6 @@ mod error;
 mod input;
 mod output;
 
-use output::RevealedOutput;
-
 use crate::rand::{CryptoRng, RngCore};
 use crate::BlindedAmount;
 
@@ -28,7 +26,7 @@ use serde::{Deserialize, Serialize};
 pub use amount::{Amount, RevealedAmount};
 pub(crate) use error::Error;
 pub use input::{BlindedInput, RevealedInput};
-pub use output::{BlindedOutput, Output};
+pub use output::{BlindedOutput, Output, RevealedOutput};
 
 pub(super) const RANGE_PROOF_BITS: usize = 64; // note: Range Proof max-bits is 64. allowed are: 8, 16, 32, 64 (only)
                                                //       This limits our amount field to 64 bits also.
@@ -169,7 +167,7 @@ impl RevealedTransaction {
     pub fn sign(
         &self,
         mut rng: impl RngCore + CryptoRng,
-    ) -> Result<(DbcTransaction, Vec<RevealedAmount>)> {
+    ) -> Result<(DbcTransaction, Vec<RevealedOutput>)> {
         // We need to gather a bunch of things for our message to sign.
         //   All public keys in all inputs
         //   All input blinded amounts
@@ -199,17 +197,12 @@ impl RevealedTransaction {
             .map(|input| input.sign(&msg, &Self::pc_gens()))
             .collect();
 
-        let revealed_output_amounts = adjusted_revealed_outputs
-            .iter()
-            .map(|r| r.revealed_amount)
-            .collect::<Vec<_>>();
-
         Ok((
             DbcTransaction {
                 inputs: blinded_inputs,
                 outputs: blinded_outputs,
             },
-            revealed_output_amounts,
+            adjusted_revealed_outputs,
         ))
     }
 

src/transaction/output.rs

@@ -47,7 +47,7 @@ impl Output {
 /// blinding factor included (in the revealed amount instance).
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug, Clone)]
-pub(super) struct RevealedOutput {
+pub struct RevealedOutput {
     pub public_key: PublicKey,
     pub revealed_amount: RevealedAmount,
 }