chore(deps): bump sn_dbc to 11.0.0

sn_api/Cargo.toml

@@ -42,7 +42,7 @@ serde = "1.0.123"
 serde_json = "1.0.62"
 sha3 = "~0.9"
 sn_client = { path = "../sn_client", version = "^0.82.5" }
-sn_dbc = { version = "10.0.0", features = ["serdes"] }
+sn_dbc = { version = "11.0.0", features = ["serdes"] }
 sn_interface = { path = "../sn_interface", version = "^0.20.8" }
 thiserror = "1.0.23"
 time = { version = "~0.3.4", features = ["formatting"] }

sn_api/src/app/test_helpers.rs

@@ -86,8 +86,8 @@ pub async fn get_next_bearer_dbc() -> Result<(Dbc, Token)> {
 
 // Build a set of bearer DBCs with random amounts, by reissuing them from testnet genesis DBC.
 async fn reissue_bearer_dbcs() -> Result<Vec<(Dbc, Token)>> {
-    let total_balance = match GENESIS_DBC.amount_secrets_bearer() {
-        Ok(amount_secrets) => amount_secrets.amount().as_nano(),
+    let total_balance = match GENESIS_DBC.revealed_amount_bearer() {
+        Ok(amount) => amount.value(),
         Err(err) => bail!("Failed to obtain genesis DBC balance: {:?}", err),
     };
 
@@ -120,10 +120,7 @@ async fn reissue_bearer_dbcs() -> Result<Vec<(Dbc, Token)>> {
 
     Ok(output_dbcs
         .into_iter()
-        .map(|(dbc, _, amount_secrets)| {
-            let amount = amount_secrets.amount();
-            (dbc, amount)
-        })
+        .map(|(dbc, _, amount)| (dbc, Token::from_nano(amount.value())))
         .collect())
 }
 

sn_api/src/app/wallet.rs

@@ -17,7 +17,7 @@ use crate::{
 
 use sn_client::Client;
 use sn_dbc::{
-    rng, AmountSecrets, Error as DbcError, Hash, Owner, OwnerOnce, PublicKey, SpentProof,
+    rng, Error as DbcError, Hash, Owner, OwnerOnce, PublicKey, RevealedAmount, SpentProof,
     SpentProofShare, TransactionBuilder,
 };
 use sn_interface::{elder_count, network_knowledge::supermajority};
@@ -129,8 +129,8 @@ impl Safe {
         };
 
         let amount = dbc_to_deposit
-            .amount_secrets_bearer()
-            .map(|amount_secrets| amount_secrets.amount())?;
+            .revealed_amount_bearer()
+            .map(|amount| amount.value())?;
 
         let safeurl = self.parse_and_resolve_url(wallet_url).await?;
         self.insert_dbc_into_wallet(&safeurl, &dbc_to_deposit, spendable_name.clone())
@@ -141,7 +141,7 @@ impl Safe {
             amount, safeurl, spendable_name
         );
 
-        Ok((spendable_name, amount))
+        Ok((spendable_name, Token::from_nano(amount)))
     }
 
     /// Verify if the provided DBC's public_key has been already spent on the network.
@@ -243,10 +243,10 @@ impl Safe {
         for (name, (dbc, _)) in &balances {
             debug!("Checking spendable balance named: {}", name);
 
-            let balance = match dbc.amount_secrets_bearer() {
-                Ok(amount_secrets) => amount_secrets.amount(),
+            let balance = match dbc.revealed_amount_bearer() {
+                Ok(amount) => Token::from_nano(amount.value()),
                 Err(err) => {
-                    warn!("Ignoring amount from DBC found in wallet due to error in revealing secret amount: {:?}", err);
+                    warn!("Ignoring amount from DBC found in wallet due to dbc not being bearer: {:?}", err);
                     continue;
                 }
             };
@@ -414,8 +414,8 @@ impl Safe {
         let mut total_input_amount = Token::zero();
         let mut change_amount = total_output_amount;
         for (name, (dbc, entry_hash)) in spendable_dbcs {
-            let dbc_balance = match dbc.amount_secrets_bearer() {
-                Ok(amount_secrets) => amount_secrets.amount(),
+            let dbc_balance = match dbc.revealed_amount_bearer() {
+                Ok(amount) => Token::from_nano(amount.value()),
                 Err(err) => {
                     warn!("Ignoring input DBC found in wallet (entry: {}) due to error in revealing secret amount: {:?}", name, err);
                     continue;
@@ -508,10 +508,10 @@ impl Safe {
                 outputs_owners.push((fee, owner_once));
             });
 
-            let dbc_balance = match dbc.amount_secrets_bearer() {
-                Ok(amount_secrets) => amount_secrets.amount(),
+            let dbc_balance = match dbc.revealed_amount_bearer() {
+                Ok(amount) => Token::from_nano(amount.value()),
                 Err(err) => {
-                    warn!("Ignoring input DBC found in wallet (entry: {}) due to error in revealing secret amount: {:?}", name, err);
+                    warn!("Ignoring input DBC found in wallet (entry: {name}) due to not being a bearer: {err:?}");
                     continue;
                 }
             };
@@ -616,7 +616,7 @@ impl Safe {
         outputs: Vec<(Token, OwnerOnce)>,
         reason: DbcReason,
         change_amount: Token,
-    ) -> Result<(Vec<(Dbc, OwnerOnce, AmountSecrets)>, Option<Dbc>)> {
+    ) -> Result<(Vec<(Dbc, OwnerOnce, RevealedAmount)>, Option<Dbc>)> {
         let mut tx_builder = TransactionBuilder::default()
             .add_inputs_dbc_bearer(input_dbcs.iter())?
             .add_outputs_by_amount(outputs.into_iter().map(|(token, owner)| (token, owner)));
@@ -1046,18 +1046,18 @@ mod tests {
             .ok_or_else(|| anyhow!("Couldn't read first DBC from fetched wallet"))?;
         assert_eq!(dbc1_read.owner_base(), dbc1.owner_base());
         let balance1 = dbc1_read
-            .amount_secrets_bearer()
+            .revealed_amount_bearer()
             .map_err(|err| anyhow!("Couldn't read balance from first DBC fetched: {:?}", err))?;
-        assert_eq!(balance1.amount(), dbc1_balance);
+        assert_eq!(balance1.value(), dbc1_balance.as_nano());
 
         let (dbc2_read, _) = wallet_balances
             .get("my-second-dbc")
             .ok_or_else(|| anyhow!("Couldn't read second DBC from fetched wallet"))?;
         assert_eq!(dbc2_read.owner_base(), dbc2.owner_base());
         let balance2 = dbc2_read
-            .amount_secrets_bearer()
+            .revealed_amount_bearer()
             .map_err(|err| anyhow!("Couldn't read balance from second DBC fetched: {:?}", err))?;
-        assert_eq!(balance2.amount(), dbc2_balance);
+        assert_eq!(balance2.value(), dbc2_balance.as_nano());
 
         Ok(())
     }
@@ -1137,9 +1137,9 @@ mod tests {
             .await?;
 
         let output_balance = output_dbc
-            .amount_secrets_bearer()
+            .revealed_amount_bearer()
             .map_err(|err| anyhow!("Couldn't read balance from output DBC: {:?}", err))?;
-        assert_eq!(output_balance.amount(), amount_to_reissue);
+        assert_eq!(output_balance.value(), amount_to_reissue.as_nano());
 
         let current_balance = safe.wallet_balance(&wallet_xorurl).await?;
         assert_eq!(current_balance, Token::from_nano(expected_change));
@@ -1153,9 +1153,9 @@ mod tests {
             .next()
             .ok_or_else(|| anyhow!("Couldn't read change DBC from fetched wallet"))?;
         let change = change_dbc_read
-            .amount_secrets_bearer()
+            .revealed_amount_bearer()
             .map_err(|err| anyhow!("Couldn't read balance from change DBC fetched: {:?}", err))?;
-        assert_eq!(change.amount(), Token::from_nano(expected_change));
+        assert_eq!(change.value(), expected_change);
 
         Ok(())
     }
@@ -1173,9 +1173,9 @@ mod tests {
             .await?;
 
         let output_balance = output_dbc
-            .amount_secrets_bearer()
+            .revealed_amount_bearer()
             .map_err(|err| anyhow!("Couldn't read balance from output DBC: {:?}", err))?;
-        assert_eq!(output_balance.amount(), Token::from_nano(1_000_000_000));
+        assert_eq!(output_balance.value(), 1_000_000_000);
 
         tokio::time::sleep(tokio::time::Duration::from_millis(5000)).await;
 
@@ -1193,9 +1193,9 @@ mod tests {
             .next()
             .ok_or_else(|| anyhow!("Couldn't read change DBC from fetched wallet"))?;
         let change = change_dbc_read
-            .amount_secrets_bearer()
+            .revealed_amount_bearer()
             .map_err(|err| anyhow!("Couldn't read balance from change DBC fetched: {:?}", err))?;
-        assert_eq!(change.amount(), change_amount);
+        assert_eq!(change.value(), change_amount.as_nano());
 
         Ok(())
     }
@@ -1540,8 +1540,8 @@ mod tests {
 
         let mut num_fee_outputs = 0;
         for dbc in output_dbcs {
-            if let Ok(balance) = dbc.amount_secrets_bearer() {
-                assert!(output_amounts.contains(&balance.amount().as_nano()));
+            if let Ok(balance) = dbc.revealed_amount_bearer() {
+                assert!(output_amounts.contains(&balance.value()));
             } else {
                 num_fee_outputs += 1;
             }
@@ -1560,9 +1560,9 @@ mod tests {
             .next()
             .ok_or_else(|| anyhow!("Couldn't read change DBC from fetched wallet"))?;
         let change = change_dbc_read
-            .amount_secrets_bearer()
+            .revealed_amount_bearer()
             .map_err(|err| anyhow!("Couldn't read balance from change DBC fetched: {:?}", err))?;
-        assert_eq!(change.amount(), Token::from_nano(expected_change));
+        assert_eq!(change.value(), expected_change);
 
         Ok(())
     }

sn_cli/Cargo.toml

@@ -38,7 +38,7 @@ reqwest = { version = "~0.11", default-features = false, features = ["rustls-tls
 rmp-serde = "1.0.0"
 sn_updater = { path = "../sn_updater", version = "^0.1.0" }
 sn_api = { path = "../sn_api", version = "^0.80.3", default-features = false, features = ["app"] }
-sn_dbc = { version = "10.0.0", features = ["serdes"] }
+sn_dbc = { version = "11.0.0", features = ["serdes"] }
 serde = "1.0.123"
 serde_json = "1.0.62"
 serde_yaml = "~0.8"

sn_cli/src/subcommands/helpers.rs

@@ -175,10 +175,12 @@ pub async fn gen_wallet_table(safe: &Safe, multimap: &Multimap) -> Result<Table>
             }
         };
 
-        let balance = match dbc.amount_secrets_bearer() {
-            Ok(amount_secrets) => amount_secrets.amount().to_string(),
+        let balance = match dbc.revealed_amount_bearer() {
+            Ok(amount) => sn_dbc::Token::from_nano(amount.value()).to_string(),
             Err(err) => {
-                warn!("Ignoring amount from DBC found in wallet due to error in revealing secret amount: {:?}", err);
+                warn!(
+                    "Ignoring amount from DBC found in wallet due to not being a bearer: {err:?}"
+                );
                 "unknown".to_string()
             }
         };

sn_client/Cargo.toml

@@ -71,7 +71,7 @@ serde = { version = "1.0.111", features = ["derive", "rc"] }
 serde_bytes = "~0.11.5"
 serde_json = "1.0.53"
 signature = "1.1.10"
-sn_dbc = { version = "10.0.0", features = ["serdes"] }
+sn_dbc = { version = "11.0.0", features = ["serdes"] }
 sn_interface = { path = "../sn_interface", version = "^0.20.8" }
 sn_testnet = { path = "../sn_testnet", version = "^0.1.3" }
 strum = "0.24"

sn_client/src/api/spentbook_apis.rs

@@ -379,8 +379,7 @@ mod tests {
                 source: ErrorMsg::InvalidOperation(error_string),
                 ..
             }) => {
-                let correct_error_str =
-                    format!("{:?}", sn_dbc::Error::MissingCommitmentForPubkey(pk));
+                let correct_error_str = format!("{:?}", sn_dbc::Error::MissingAmountForPubkey(pk));
                 assert!(
                     error_string.contains(&correct_error_str),
                     "A different SpentbookError error was expected for this case. What we got: {error_string:?}, expected: {correct_error_str:?}"
@@ -427,7 +426,7 @@ mod tests {
                 ..
             }) => {
                 let correct_error_str =
-                    format!("SpentbookError(\"There are no commitments for the given public key {random_public_key:?}\"");
+                    format!("SpentbookError(\"There are no amounts for the given public key {random_public_key:?}\"");
                 assert!(
                     error_string.contains(&correct_error_str),
                     "A different SpentbookError error was expected for this case. What we got: {error_string:?}"
@@ -491,7 +490,7 @@ mod tests {
         outputs: Vec<(sn_dbc::Token, OwnerOnce)>,
         change_amount: sn_dbc::Token,
     ) -> Result<(
-        Vec<(sn_dbc::Dbc, OwnerOnce, sn_dbc::AmountSecrets)>,
+        Vec<(sn_dbc::Dbc, OwnerOnce, sn_dbc::RevealedAmount)>,
         Option<sn_dbc::Dbc>,
     )> {
         let mut tx_builder = TransactionBuilder::default()

sn_interface/Cargo.toml

@@ -42,7 +42,7 @@ serde_bytes = "~0.11.5"
 serde_json = "1.0.53"
 signature = "1.1.10"
 sn_consensus = "3.3.3"
-sn_dbc = { version = "10.0.0", features = ["serdes"] }
+sn_dbc = { version = "11.0.0", features = ["serdes"] }
 sn_sdkg = "3.1.3"
 strum = "0.24"
 strum_macros = "0.24"

sn_interface/src/dbcs/mod.rs

@@ -12,8 +12,7 @@ pub use reasons::DbcReason;
 
 use sn_dbc::{
     rng, Dbc, Error as DbcError, Hash, IndexedSignatureShare, Owner, OwnerOnce, PedersenGens,
-    RevealedCommitment, RevealedInput, SpentProofContent, SpentProofShare, Token,
-    TransactionBuilder,
+    RevealedAmount, RevealedInput, SpentProofContent, SpentProofShare, Token, TransactionBuilder,
 };
 
 use std::{fmt::Debug, result};
@@ -58,10 +57,10 @@ pub fn gen_genesis_dbc(
     let output_owner =
         OwnerOnce::from_owner_base(Owner::from(genesis_dbc_sk.clone()), &mut rng::thread_rng());
 
-    let revealed_commitment = RevealedCommitment::from_value(GENESIS_DBC_AMOUNT, rng::thread_rng());
+    let revealed_amount = RevealedAmount::from_amount(GENESIS_DBC_AMOUNT, rng::thread_rng());
 
     // Use the same key as the input and output of Genesis Tx.
-    let genesis_input = RevealedInput::new(genesis_dbc_sk.clone(), revealed_commitment);
+    let genesis_input = RevealedInput::new(genesis_dbc_sk.clone(), revealed_amount);
 
     let mut dbc_builder = TransactionBuilder::default()
         .add_input(genesis_input)
@@ -84,7 +83,7 @@ pub fn gen_genesis_dbc(
         public_key,
         transaction_hash: Hash::from(tx.hash()),
         reason: Hash::default(),
-        public_commitment: revealed_commitment.commit(&PedersenGens::default()),
+        blinded_amount: revealed_amount.blinded_amount(&PedersenGens::default()),
     };
 
     let sk_share_index = 0;

sn_interface/src/network_knowledge/section_keys.rs

@@ -11,7 +11,7 @@ use crate::network_knowledge::{Error, Result, SectionAuthorityProvider};
 use crate::types::log_markers::LogMarker;
 
 use sn_dbc::{
-    Commitment, DbcTransaction, Hash, IndexedSignatureShare, SpentProofContent, SpentProofShare,
+    BlindedAmount, DbcTransaction, Hash, IndexedSignatureShare, SpentProofContent, SpentProofShare,
 };
 use uluru::LRUCache;
 
@@ -111,13 +111,13 @@ pub fn build_spent_proof_share(
     reason: DbcReason,
     sap: &SectionAuthorityProvider,
     skp: &SectionKeysProvider,
-    public_commitment: Commitment,
+    blinded_amount: BlindedAmount,
 ) -> Result<SpentProofShare> {
     let content = SpentProofContent {
         public_key: *public_key,
         transaction_hash: Hash::from(tx.hash()),
         reason: reason.into(),
-        public_commitment,
+        blinded_amount,
     };
     let (index, sig_share) = skp.sign_with(content.hash().as_ref(), &sap.section_key())?;
     Ok(SpentProofShare {