Use node id, pubkey, secretkey and bill id (#557)

Author: zupzup

CHANGELOG.md

@@ -1,7 +1,17 @@
 # 0.3.17
 
-* Use NodeId and BillId types internally instead of strings
-* Removed `NodeId` trait and replaced it with method
+* Use NodeId, PublicKey, SecretKey and BillId types internally instead of strings (fully breaking)
+    * This breaks all existing databases, since the node ids and bill ids now have the format `prefix|network|pubkey`- example: `bitcrt03f9f94d1fdc2090d46f3524807e3f58618c36988e69577d70d5d4d1e9e9645a4f`
+    * The `prefix` is `bitcr`
+    * The `network` character is as follows:
+        * m => Mainnet
+        * t => Testnet
+        * T => Testnet4
+        * r => Regtest
+    * The `pubkey` is a stringified secp256k1 public key
+    * Existing apps need to a.) delete their IndexedDB and b.) their localhost (because the mint ID might be in there)
+* Removed `NodeId` trait and replaced it with a concrete method on the corresponding types (breaking API change)
+* Rename `BillId` TS type to `BillIdResponse` (breaking TS type)
 
 # 0.3.16
 

Cargo.toml

@@ -43,7 +43,7 @@ futures = { version = "0.3", default-features = false }
 anyhow = { version = "1", default-features = false }
 thiserror = { version = "2", default-features = false }
 uuid = { version = "1", default-features = false, features = ["v4", "js"] }
-bitcoin = { version = "0.32", default-features = false }
+bitcoin = { version = "0.32", default-features = false, features = ["serde"] }
 bip39 = { version = "2.1", features = ["rand"] }
 ecies = { version = "0.2", default-features = false, features = ["pure"] }
 nostr = { version = "0.42" }

crates/bcr-ebill-api/src/data/mod.rs

@@ -3,11 +3,15 @@ pub use bcr_ebill_core::company;
 pub use bcr_ebill_core::contact;
 pub use bcr_ebill_core::identity;
 pub use bcr_ebill_core::mint;
+pub use bcr_ebill_core::nostr_contact;
 pub use bcr_ebill_core::notification;
 
 pub use bcr_ebill_core::File;
 pub use bcr_ebill_core::GeneralSearchFilterItemType;
 pub use bcr_ebill_core::GeneralSearchResult;
+pub use bcr_ebill_core::NodeId;
 pub use bcr_ebill_core::OptionalPostalAddress;
 pub use bcr_ebill_core::PostalAddress;
+pub use bcr_ebill_core::PublicKey;
+pub use bcr_ebill_core::SecretKey;
 pub use bcr_ebill_core::UploadFileResult;

crates/bcr-ebill-api/src/external/bitcoin.rs

@@ -1,10 +1,9 @@
 use crate::get_config;
 use async_trait::async_trait;
-use bcr_ebill_core::{ServiceTraitBounds, util};
+use bcr_ebill_core::{PublicKey, ServiceTraitBounds, util};
 use bitcoin::{Network, secp256k1::Scalar};
 use log::debug;
 use serde::Deserialize;
-use std::str::FromStr;
 use thiserror::Error;
 
 /// Generic result type
@@ -50,7 +49,11 @@ pub trait BitcoinClientApi: ServiceTraitBounds {
 
     async fn check_if_paid(&self, address: &str, sum: u64) -> Result<(bool, u64)>;
 
-    fn get_address_to_pay(&self, bill_public_key: &str, holder_public_key: &str) -> Result<String>;
+    fn get_address_to_pay(
+        &self,
+        bill_public_key: &PublicKey,
+        holder_public_key: &PublicKey,
+    ) -> Result<String>;
 
     fn generate_link_to_pay(&self, address: &str, sum: u64, message: &str) -> String;
 
@@ -188,11 +191,13 @@ impl BitcoinClientApi for BitcoinClient {
         }
     }
 
-    fn get_address_to_pay(&self, bill_public_key: &str, holder_public_key: &str) -> Result<String> {
-        let public_key_bill = bitcoin::CompressedPublicKey::from_str(bill_public_key)
-            .map_err(|e| Error::PublicKey(e.to_string()))?;
-        let public_key_bill_holder = bitcoin::CompressedPublicKey::from_str(holder_public_key)
-            .map_err(|e| Error::PublicKey(e.to_string()))?;
+    fn get_address_to_pay(
+        &self,
+        bill_public_key: &PublicKey,
+        holder_public_key: &PublicKey,
+    ) -> Result<String> {
+        let public_key_bill = bitcoin::CompressedPublicKey(*bill_public_key);
+        let public_key_bill_holder = bitcoin::CompressedPublicKey(*holder_public_key);
 
         let public_key_bill = public_key_bill
             .0

crates/bcr-ebill-api/src/external/mint.rs

@@ -3,7 +3,7 @@ use std::str::FromStr;
 use crate::{constants::CURRENCY_CRSAT, util};
 use async_trait::async_trait;
 use bcr_ebill_core::{
-    PostalAddress, ServiceTraitBounds,
+    PostalAddress, SecretKey, ServiceTraitBounds,
     bill::BitcreditBill,
     contact::{BillAnonParticipant, BillIdentParticipant, BillParticipant, ContactType},
     util::{BcrKeys, date::DateTimeUtc},
@@ -87,7 +87,7 @@ pub trait MintClientApi: ServiceTraitBounds {
         mint_url: &str,
         keyset: cdk02::KeySet,
         quote_id: &str,
-        private_key: &str,
+        private_key: &SecretKey,
         blinded_messages: Vec<cashu::BlindedMessage>,
         secrets: Vec<cashu::secret::Secret>,
         rs: Vec<cashu::SecretKey>,
@@ -196,14 +196,15 @@ impl MintClientApi for MintClient {
         mint_url: &str,
         keyset: cdk02::KeySet,
         quote_id: &str,
-        private_key: &str,
+        private_key: &SecretKey,
         blinded_messages: Vec<cashu::BlindedMessage>,
         secrets: Vec<cashu::secret::Secret>,
         rs: Vec<cashu::SecretKey>,
     ) -> Result<String> {
         let token_mint_url =
             cashu::MintUrl::from_str(mint_url).map_err(|_| Error::InvalidMintUrl)?;
-        let secret_key = cdk01::SecretKey::from_hex(private_key).map_err(|_| Error::PrivateKey)?;
+        let secret_key = cdk01::SecretKey::from_hex(private_key.display_secret().to_string())
+            .map_err(|_| Error::PrivateKey)?;
         let qid = uuid::Uuid::from_str(quote_id).map_err(|_| Error::InvalidMintRequestId)?;
 
         // mint
@@ -262,7 +263,7 @@ impl MintClientApi for MintClient {
         files: &[Url],
     ) -> Result<String> {
         let bill_info = BillInfo {
-            id: bill.id.clone(),
+            id: bill.id.clone().to_string(),
             drawee: map_bill_ident_participant(bill.drawee.to_owned()),
             drawer: map_bill_ident_participant(bill.drawer.to_owned()),
             payee: map_bill_participant(bill.payee.to_owned()),
@@ -453,7 +454,7 @@ fn map_bill_anon_participant(
     ident: BillAnonParticipant,
 ) -> bcr_wdc_webapi::bill::BillAnonParticipant {
     bcr_wdc_webapi::bill::BillAnonParticipant {
-        node_id: ident.node_id,
+        node_id: ident.node_id.to_string(),
         email: ident.email,
         nostr_relays: ident.nostr_relays,
     }
@@ -464,7 +465,7 @@ fn map_bill_ident_participant(
 ) -> bcr_wdc_webapi::bill::BillIdentParticipant {
     bcr_wdc_webapi::bill::BillIdentParticipant {
         t: map_contact_type(ident.t),
-        node_id: ident.node_id,
+        node_id: ident.node_id.to_string(),
         name: ident.name,
         postal_address: map_postal_address(ident.postal_address),
         email: ident.email,

crates/bcr-ebill-api/src/lib.rs

@@ -1,4 +1,5 @@
 use anyhow::{Result, anyhow};
+use bcr_ebill_core::NodeId;
 use bitcoin::Network;
 use std::sync::OnceLock;
 
@@ -20,7 +21,7 @@ pub use persistence::db::SurrealDbConfig;
 pub use persistence::get_db_context;
 pub use persistence::notification::NotificationFilter;
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct Config {
     pub bitcoin_network: String,
     pub esplora_base_url: String,
@@ -54,17 +55,16 @@ pub struct NostrConfig {
 }
 
 /// Mint configuration
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct MintConfig {
     /// URL of the default mint
     pub default_mint_url: String,
     /// Node Id of the default mint
-    pub default_mint_node_id: String,
+    pub default_mint_node_id: NodeId,
 }
 
 impl MintConfig {
-    pub fn new(default_mint_url: String, default_mint_node_id: String) -> Result<Self> {
-        util::crypto::validate_pub_key(&default_mint_node_id)?;
+    pub fn new(default_mint_url: String, default_mint_node_id: NodeId) -> Result<Self> {
         reqwest::Url::parse(&default_mint_url)
             .map_err(|e| anyhow!("Invalid Default Mint URL: {e}"))?;
         Ok(Self {

crates/bcr-ebill-api/src/service/backup_service.rs

@@ -66,18 +66,14 @@ impl BackupService {
 impl BackupServiceApi for BackupService {
     async fn backup(&self) -> Result<Vec<u8>> {
         self.validate_surreal_db_connection()?;
-        let public_key = self.identity_store.get_key_pair().await?.get_public_key();
+        let public_key = self.identity_store.get_key_pair().await?.pub_key();
         let bytes = self.store.backup().await?;
         let encrypted_bytes = util::crypto::encrypt_ecies(&bytes, &public_key)?;
         Ok(encrypted_bytes)
     }
 
     async fn restore(&self, file_path: &Path) -> Result<()> {
-        let private_key = self
-            .identity_store
-            .get_key_pair()
-            .await?
-            .get_private_key_string();
+        let private_key = self.identity_store.get_key_pair().await?.get_private_key();
         let mut buffer = vec![];
         let mut file = File::open(file_path).await?;
         file.read_to_end(&mut buffer).await?;
@@ -187,7 +183,7 @@ OPTION IMPORT;
 DEFINE TABLE bill_chain TYPE ANY SCHEMALESS PERMISSIONS NONE;";
 
         let encrypted_bytes =
-            util::crypto::encrypt_ecies(backup_str.as_bytes(), &keys.get_public_key()).unwrap();
+            util::crypto::encrypt_ecies(backup_str.as_bytes(), &keys.pub_key()).unwrap();
 
         let temp_dir = env::temp_dir();
         let file_path = temp_dir.join("test.surql");

crates/bcr-ebill-api/src/service/bill_service/blocks.rs

@@ -1,6 +1,6 @@
 use bcr_ebill_core::{
-    Validate, ValidationError,
-    bill::{BillKeys, BitcreditBill, RecourseReason},
+    NodeId, Validate, ValidationError,
+    bill::{BillId, BillKeys, BitcreditBill, RecourseReason},
     blockchain::{
         self, Blockchain,
         bill::{
@@ -221,9 +221,10 @@ impl BillService {
             }
             // can be anon to offer to sell
             BillAction::OfferToSell(buyer, sum, currency) => {
-                let address_to_pay = self
-                    .bitcoin_client
-                    .get_address_to_pay(&bill_keys.public_key, &signer_public_data.node_id())?;
+                let address_to_pay = self.bitcoin_client.get_address_to_pay(
+                    &bill_keys.public_key,
+                    &signer_public_data.node_id().pub_key(),
+                )?;
                 let block_data = BillOfferToSellBlockData {
                     seller: if holder_is_anon {
                         // if holder is anon, we need to continue as anon
@@ -416,7 +417,7 @@ impl BillService {
 
     pub(super) async fn validate_and_add_block(
         &self,
-        bill_id: &str,
+        bill_id: &BillId,
         blockchain: &mut BillBlockchain,
         new_block: BillBlock,
     ) -> Result<()> {
@@ -432,7 +433,7 @@ impl BillService {
     pub(super) async fn add_identity_and_company_chain_blocks_for_signed_bill_action(
         &self,
         signer_public_data: &BillParticipant,
-        bill_id: &str,
+        bill_id: &BillId,
         block: &BillBlock,
         identity_keys: &BcrKeys,
         signer_keys: &BcrKeys,
@@ -457,8 +458,8 @@ impl BillService {
                             block,
                             identity_keys,
                             &CompanyKeys {
-                                private_key: signer_keys.get_private_key_string(),
-                                public_key: signer_keys.get_public_key(),
+                                private_key: signer_keys.get_private_key(),
+                                public_key: signer_keys.pub_key(),
                             },
                             timestamp,
                         )
@@ -491,7 +492,7 @@ impl BillService {
 
     pub(super) async fn add_block_to_identity_chain_for_signed_bill_action(
         &self,
-        bill_id: &str,
+        bill_id: &BillId,
         block: &BillBlock,
         keys: &BcrKeys,
         timestamp: u64,
@@ -514,8 +515,8 @@ impl BillService {
 
     pub(super) async fn add_block_to_identity_chain_for_signed_company_bill_action(
         &self,
-        company_id: &str,
-        bill_id: &str,
+        company_id: &NodeId,
+        bill_id: &BillId,
         block: &BillBlock,
         keys: &BcrKeys,
         timestamp: u64,
@@ -539,8 +540,8 @@ impl BillService {
 
     pub(super) async fn add_block_to_company_chain_for_signed_bill_action(
         &self,
-        company_id: &str,
-        bill_id: &str,
+        company_id: &NodeId,
+        bill_id: &BillId,
         block: &BillBlock,
         signatory_keys: &BcrKeys,
         company_keys: &CompanyKeys,

crates/bcr-ebill-api/src/service/bill_service/data_fetching.rs

@@ -2,16 +2,16 @@ use crate::util;
 
 use super::service::BillService;
 use super::{Error, Result};
-use bcr_ebill_core::ValidationError;
 use bcr_ebill_core::bill::BillMintStatus;
 use bcr_ebill_core::bill::validation::get_expiration_deadline_base_for_req_to_pay;
 use bcr_ebill_core::constants::RECOURSE_DEADLINE_SECONDS;
 use bcr_ebill_core::contact::{BillParticipant, Contact};
 use bcr_ebill_core::identity::IdentityType;
+use bcr_ebill_core::{NodeId, ValidationError};
 use bcr_ebill_core::{
     bill::{
-        BillAcceptanceStatus, BillCurrentWaitingState, BillData, BillKeys, BillParticipants,
-        BillPaymentStatus, BillRecourseStatus, BillSellStatus, BillStatus,
+        BillAcceptanceStatus, BillCurrentWaitingState, BillData, BillId, BillKeys,
+        BillParticipants, BillPaymentStatus, BillRecourseStatus, BillSellStatus, BillStatus,
         BillWaitingForPaymentState, BillWaitingForRecourseState, BillWaitingForSellState,
         BitcreditBill, BitcreditBillResult,
     },
@@ -43,7 +43,7 @@ impl BillService {
         chain: &BillBlockchain,
         bill_keys: &BillKeys,
         identity: &Identity,
-        contacts: &HashMap<String, Contact>,
+        contacts: &HashMap<NodeId, Contact>,
     ) -> Result<BitcreditBill> {
         let bill_first_version = chain.get_first_version_bill(bill_keys)?;
         let bill_parties = chain.get_bill_parties(bill_keys, &bill_first_version)?;
@@ -137,7 +137,7 @@ impl BillService {
         chain: &BillBlockchain,
         bill_keys: &BillKeys,
         local_identity: &Identity,
-        current_identity_node_id: &str,
+        current_identity_node_id: &NodeId,
         current_timestamp: u64,
     ) -> Result<BitcreditBillResult> {
         // fetch contacts to get current contact data for participants
@@ -193,7 +193,7 @@ impl BillService {
         // calculate, if the caller has received funds at any point in the bill
         let mut redeemed_funds_available =
             chain.is_beneficiary_from_a_block(bill_keys, current_identity_node_id);
-        if holder.node_id() == current_identity_node_id && paid {
+        if holder.node_id() == *current_identity_node_id && paid {
             redeemed_funds_available = true;
         }
 
@@ -362,7 +362,7 @@ impl BillService {
                     // we're waiting, collect data
                     let address_to_pay = self
                         .bitcoin_client
-                        .get_address_to_pay(&bill_keys.public_key, &holder.node_id())?;
+                        .get_address_to_pay(&bill_keys.public_key, &holder.node_id().pub_key())?;
 
                     let link_to_pay = self.bitcoin_client.generate_link_to_pay(
                         &address_to_pay,
@@ -413,7 +413,7 @@ impl BillService {
 
                     let address_to_pay = self.bitcoin_client.get_address_to_pay(
                         &bill_keys.public_key,
-                        &payment_info.recourser.node_id,
+                        &payment_info.recourser.node_id.pub_key(),
                     )?;
 
                     let link_to_pay = self.bitcoin_client.generate_link_to_pay(
@@ -624,7 +624,7 @@ impl BillService {
         &self,
         bill: &mut BitcreditBillResult,
         identity: &Identity,
-        contacts: &HashMap<String, Contact>,
+        contacts: &HashMap<NodeId, Contact>,
     ) {
         bill.participants.payee = self
             .extend_bill_chain_participant_data_from_contacts_or_identity(
@@ -711,9 +711,9 @@ impl BillService {
 
     pub(super) async fn recalculate_and_cache_bill(
         &self,
-        bill_id: &str,
+        bill_id: &BillId,
         local_identity: &Identity,
-        current_identity_node_id: &str,
+        current_identity_node_id: &NodeId,
         current_timestamp: u64,
     ) -> Result<BitcreditBillResult> {
         let chain = self.blockchain_store.get_chain(bill_id).await?;
@@ -739,9 +739,9 @@ impl BillService {
 
     pub(super) async fn get_full_bill(
         &self,
-        bill_id: &str,
+        bill_id: &BillId,
         local_identity: &Identity,
-        current_identity_node_id: &str,
+        current_identity_node_id: &NodeId,
         current_timestamp: u64,
     ) -> Result<BitcreditBillResult> {
         // if there is no such bill, we return an error