add node id type, add bill id (#550)

Author: zupzup

.github/workflows/rust.yml

@@ -4,6 +4,10 @@ on:
   push:
     branches: [ "*" ]
 
+permissions:
+  contents: read
+  security-events: write
+
 env:
   CARGO_TERM_COLOR: always
 
@@ -26,7 +30,7 @@ jobs:
           df -h
 
       - name: Switch rust version
-        run: rustup default nightly
+        run: rustup default stable
 
       - name: Update rust
         run: rustup update

.github/workflows/test.yml

@@ -4,6 +4,10 @@ on:
   push:
     branches: [ "*" ]
 
+permissions:
+  contents: read
+  security-events: write
+
 jobs:
   test:
     runs-on: ubuntu-latest

CHANGELOG.md

@@ -4,6 +4,10 @@
 * Nostr npub as primary key in Nostr contacts (breaking DB change)
 * Add default mint to nostr contacts as default, so it doesn't have to be added to contacts anymore
 
+# 0.3.15-hotfix1
+
+* Fix Bill Caching issue between multiple identities
+
 # 0.3.15
 
 * Upload and download files to and from Nostr using Blossom

crates/bcr-ebill-api/Cargo.toml

@@ -31,10 +31,10 @@ bcr-ebill-transport = { path = "../bcr-ebill-transport" }
 tokio.workspace = true
 tokio_with_wasm.workspace = true
 secp256k1.workspace = true
-bcr-wdc-webapi = { git = "https://github.com/BitcreditProtocol/wildcat", rev = "210ee9fccfb93e00247c46dbfcd4cc55287" }
-bcr-wdc-quote-client = { git = "https://github.com/BitcreditProtocol/wildcat", rev = "210ee9fccfb93e00247c46dbfcd4cc55287" }
-bcr-wdc-key-client = { git = "https://github.com/BitcreditProtocol/wildcat", rev = "210ee9fccfb93e00247c46dbfcd4cc55287" }
-bcr-wdc-swap-client = { git = "https://github.com/BitcreditProtocol/wildcat", rev = "210ee9fccfb93e00247c46dbfcd4cc55287" }
+bcr-wdc-webapi = { git = "https://github.com/BitcreditProtocol/wildcat", tag = "v0.2.0" }
+bcr-wdc-quote-client = { git = "https://github.com/BitcreditProtocol/wildcat", tag = "v0.2.0" }
+bcr-wdc-key-client = { git = "https://github.com/BitcreditProtocol/wildcat", tag = "v0.2.0" }
+bcr-wdc-swap-client = { git = "https://github.com/BitcreditProtocol/wildcat", tag = "v0.2.0" }
 cashu = { version = "0.9", default-features = false }
 rand = { version = "0.8" }
 hex = { version = "0.4" }

crates/bcr-ebill-core/src/bill/mod.rs

@@ -1,7 +1,12 @@
+use std::str::FromStr;
+
 use crate::{
+    ID_PREFIX, NETWORK_MAINNET, NETWORK_REGTEST, NETWORK_TESTNET, NETWORK_TESTNET4,
+    ValidationError,
     blockchain::bill::{BillBlockchain, block::NodeId},
     contact::{BillParticipant, LightBillParticipant},
-    util::BcrKeys,
+    network_char,
+    util::{self, BcrKeys},
 };
 
 use super::{
@@ -16,6 +21,118 @@ use serde::{Deserialize, Serialize};
 
 pub mod validation;
 
+/// A bitcr Bill ID of the format <prefix><network><hash>
+/// Example: bitcrtBBT5a1eNZ8zEUkU2rppXBDrZJjARoxPkZtBgFo2RLz3y
+/// The prefix is bitcr
+/// The pub key is a base58 encoded, sha256 hashed Secp256k1 public key (the bill pub key)
+/// The network character can be parsed like this:
+/// * m => Mainnet
+/// * t => Testnet
+/// * T => Testnet4
+/// * r => Regtest
+#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)]
+pub struct BillId {
+    hash: String,
+    network: bitcoin::Network,
+}
+
+impl BillId {
+    pub fn new(hash: String, network: bitcoin::Network) -> Self {
+        Self { hash, network }
+    }
+
+    pub fn network(&self) -> bitcoin::Network {
+        self.network
+    }
+
+    pub fn id(&self) -> &str {
+        &self.hash
+    }
+}
+
+impl std::fmt::Display for BillId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}{}{}",
+            ID_PREFIX,
+            network_char(&self.network),
+            self.hash
+        )
+    }
+}
+
+impl FromStr for BillId {
+    type Err = ValidationError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if !s.starts_with(ID_PREFIX) {
+            return Err(ValidationError::InvalidBillId);
+        }
+
+        let network = match s.chars().nth(ID_PREFIX.len()) {
+            None => {
+                return Err(ValidationError::InvalidBillId);
+            }
+            Some(network_str) => match network_str {
+                NETWORK_MAINNET => bitcoin::Network::Bitcoin,
+                NETWORK_TESTNET => bitcoin::Network::Testnet,
+                NETWORK_TESTNET4 => bitcoin::Network::Testnet4,
+                NETWORK_REGTEST => bitcoin::Network::Regtest,
+                _ => {
+                    return Err(ValidationError::InvalidBillId);
+                }
+            },
+        };
+
+        let hash_str = &s[ID_PREFIX.len() + 1..];
+        let decoded = util::base58_decode(hash_str).map_err(|_| ValidationError::InvalidBillId)?;
+        // sha256 is always 32 bytes
+        if decoded.len() != 32 {
+            return Err(ValidationError::InvalidBillId);
+        }
+
+        Ok(Self {
+            hash: hash_str.to_owned(),
+            network,
+        })
+    }
+}
+
+impl serde::Serialize for BillId {
+    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        s.collect_str(self)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for BillId {
+    fn deserialize<D>(d: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(d)?;
+        BillId::from_str(&s).map_err(serde::de::Error::custom)
+    }
+}
+
+impl borsh::BorshSerialize for BillId {
+    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        let bill_id_str = self.to_string();
+        borsh::BorshSerialize::serialize(&bill_id_str, writer)
+    }
+}
+
+impl borsh::BorshDeserialize for BillId {
+    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+        let bill_id_str: String = borsh::BorshDeserialize::deserialize_reader(reader)?;
+        BillId::from_str(&bill_id_str)
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum BillAction {
     RequestAcceptance,

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

@@ -3,7 +3,7 @@ use borsh_derive::{BorshDeserialize, BorshSerialize};
 use company::Company;
 use contact::Contact;
 use serde::{Deserialize, Serialize};
-use std::{fmt, pin::Pin};
+use std::{fmt, pin::Pin, str::FromStr};
 use thiserror::Error;
 use util::is_blank;
 
@@ -20,6 +20,137 @@ pub mod notification;
 mod tests;
 pub mod util;
 
+const ID_PREFIX: &str = "bitcr";
+const NETWORK_MAINNET: char = 'm';
+const NETWORK_TESTNET: char = 't';
+const NETWORK_TESTNET4: char = 'T';
+const NETWORK_REGTEST: char = 'r';
+
+fn network_char(network: &bitcoin::Network) -> char {
+    match network {
+        bitcoin::Network::Bitcoin => NETWORK_MAINNET,
+        bitcoin::Network::Testnet => NETWORK_TESTNET,
+        bitcoin::Network::Testnet4 => NETWORK_TESTNET4,
+        bitcoin::Network::Signet => unreachable!(),
+        bitcoin::Network::Regtest => NETWORK_REGTEST,
+        _ => unreachable!(),
+    }
+}
+
+/// A bitcr Node ID of the format <prefix><network><pub_key>
+/// Example: bitcrt039180c169e5f6d7c579cf1cefa37bffd47a2b389c8125601f4068c87bea795943
+/// The prefix is bitcr
+/// The pub key is a secp256k1 public key
+/// The network character can be parsed like this:
+/// * m => Mainnet
+/// * t => Testnet
+/// * T => Testnet4
+/// * r => Regtest
+#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord)]
+pub struct NodeId {
+    pub_key: bitcoin::secp256k1::PublicKey,
+    network: bitcoin::Network,
+}
+
+impl NodeId {
+    pub fn new(pub_key: bitcoin::secp256k1::PublicKey, network: bitcoin::Network) -> Self {
+        Self { pub_key, network }
+    }
+
+    pub fn network(&self) -> bitcoin::Network {
+        self.network
+    }
+
+    pub fn pub_key(&self) -> bitcoin::secp256k1::PublicKey {
+        self.pub_key
+    }
+
+    pub fn npub(&self) -> nostr::PublicKey {
+        nostr::PublicKey::from(self.pub_key.x_only_public_key().0)
+    }
+
+    pub fn equals_npub(&self, npub: &nostr::PublicKey) -> bool {
+        self.npub() == *npub
+    }
+}
+
+impl std::fmt::Display for NodeId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{}{}{}",
+            ID_PREFIX,
+            network_char(&self.network),
+            self.pub_key
+        )
+    }
+}
+
+impl FromStr for NodeId {
+    type Err = ValidationError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if !s.starts_with(ID_PREFIX) {
+            return Err(ValidationError::InvalidNodeId);
+        }
+
+        let network = match s.chars().nth(ID_PREFIX.len()) {
+            None => {
+                return Err(ValidationError::InvalidNodeId);
+            }
+            Some(network_str) => match network_str {
+                NETWORK_MAINNET => bitcoin::Network::Bitcoin,
+                NETWORK_TESTNET => bitcoin::Network::Testnet,
+                NETWORK_TESTNET4 => bitcoin::Network::Testnet4,
+                NETWORK_REGTEST => bitcoin::Network::Regtest,
+                _ => {
+                    return Err(ValidationError::InvalidNodeId);
+                }
+            },
+        };
+
+        let pub_key_str = &s[ID_PREFIX.len() + 1..];
+        let pub_key = bitcoin::secp256k1::PublicKey::from_str(pub_key_str)
+            .map_err(|_| ValidationError::InvalidNodeId)?;
+
+        Ok(Self { pub_key, network })
+    }
+}
+
+impl serde::Serialize for NodeId {
+    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        s.collect_str(self)
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for NodeId {
+    fn deserialize<D>(d: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(d)?;
+        NodeId::from_str(&s).map_err(serde::de::Error::custom)
+    }
+}
+
+impl borsh::BorshSerialize for NodeId {
+    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        let node_id_str = self.to_string();
+        borsh::BorshSerialize::serialize(&node_id_str, writer)
+    }
+}
+
+impl borsh::BorshDeserialize for NodeId {
+    fn deserialize_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+        let node_id_str: String = borsh::BorshDeserialize::deserialize_reader(reader)?;
+        NodeId::from_str(&node_id_str)
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
+    }
+}
+
 /// Return type of an async function. Can be used to avoid async_trait
 pub type BoxedFuture<'a, T> = Pin<Box<dyn std::future::Future<Output = T> + Send + 'a>>;
 
@@ -258,6 +389,10 @@ pub enum ValidationError {
     #[error("invalid bill type")]
     InvalidBillType,
 
+    /// errors stemming from providing an invalid bill id
+    #[error("invalid bill id")]
+    InvalidBillId,
+
     /// errors stemming from when the drawee is the payee
     #[error("Drawee can't be Payee at the same time")]
     DraweeCantBePayee,
@@ -463,6 +598,10 @@ pub enum ValidationError {
     #[error("Invalid contact type")]
     InvalidContactType,
 
+    /// error returned if the node id is not valid
+    #[error("Invalid node id")]
+    InvalidNodeId,
+
     /// error returned if the identity type is not valid
     #[error("Invalid identity type")]
     InvalidIdentityType,