Chain invite handler (#538)

* Extract block processor, add public block handler

* Crude handler implementation

* Less verbose logging

* Event chain builder

* Nostr chain validation

* Single block handler

* Review fixes

* Review fixes

Author: tompro

crates/bcr-ebill-api/src/service/notification_service/default_service.rs

@@ -642,6 +642,7 @@ mod tests {
                 previous_event: Option<nostr::event::Event>,
                 root_event: Option<nostr::event::Event>) -> bcr_ebill_transport::Result<nostr::event::Event>;
             async fn resolve_contact(&self, node_id: &str) -> Result<Option<bcr_ebill_transport::transport::NostrContactData>>;
+            async fn resolve_public_chain(&self, id: &str, chain_type: BlockchainType) -> Result<Vec<nostr::event::Event>>;
         }
     }
 
@@ -1895,6 +1896,7 @@ mod tests {
         let bill_blockchain_store = Arc::new(MockBillChainStoreApiMock::new());
         let nostr_contact_store = Arc::new(MockNostrContactStore::new());
         let chain_key_store = Arc::new(MockChainKeyService::new());
+        let chain_event_store = Arc::new(MockNostrChainEventStore::new());
         let _ = create_nostr_consumer(
             clients,
             contact_service,
@@ -1905,6 +1907,7 @@ mod tests {
             bill_store,
             nostr_contact_store,
             chain_key_store,
+            chain_event_store,
         )
         .await;
     }

crates/bcr-ebill-api/src/service/notification_service/mod.rs

@@ -12,7 +12,8 @@ use bcr_ebill_persistence::nostr::{
 };
 use bcr_ebill_transport::chain_keys::ChainKeyServiceApi;
 use bcr_ebill_transport::handler::{
-    BillChainEventHandler, LoggingEventHandler, NotificationHandlerApi,
+    BillChainEventHandler, BillChainEventProcessor, BillInviteEventHandler, LoggingEventHandler,
+    NotificationHandlerApi,
 };
 use bcr_ebill_transport::{Error, EventType, Result};
 use bcr_ebill_transport::{NotificationServiceApi, PushApi};
@@ -123,12 +124,21 @@ pub async fn create_nostr_consumer(
     bill_store: Arc<dyn BillStoreApi>,
     nostr_contact_store: Arc<dyn NostrContactStoreApi>,
     chain_key_service: Arc<dyn ChainKeyServiceApi>,
+    chain_event_store: Arc<dyn NostrChainEventStoreApi>,
 ) -> Result<NostrConsumer> {
     // we need one nostr client for nostr interactions
-    let transport = match clients.first() {
+    let transport = match clients.iter().find(|c| c.is_primary()) {
         Some(client) => client.clone(),
         None => panic!("Cant create Nostr consumer as there is no nostr client available"),
     };
+
+    let processor = Arc::new(BillChainEventProcessor::new(
+        bill_blockchain_store,
+        bill_store,
+        transport.clone(),
+        nostr_contact_store,
+    ));
+
     // register the logging event handler for all events for now. Later we will probably
     // setup the handlers outside and pass them to the consumer via this functions arguments.
     let handlers: Vec<Box<dyn NotificationHandlerApi>> = vec![
@@ -138,10 +148,12 @@ pub async fn create_nostr_consumer(
         Box::new(BillChainEventHandler::new(
             notification_store,
             push_service,
-            bill_blockchain_store,
-            bill_store,
-            transport,
-            nostr_contact_store,
+            processor.clone(),
+        )),
+        Box::new(BillInviteEventHandler::new(
+            transport.clone(),
+            processor.clone(),
+            chain_event_store.clone(),
         )),
     ];
     debug!("initializing nostr consumer for {} clients", clients.len());

crates/bcr-ebill-api/src/service/notification_service/nostr.rs

@@ -9,7 +9,7 @@ use bcr_ebill_transport::{
     event::EventEnvelope,
     handler::NotificationHandlerApi,
     transport::{
-        NostrContactData, create_nip04_event, create_public_chain_event,
+        NostrContactData, chain_filter, create_nip04_event, create_public_chain_event,
         decrypt_public_chain_event, unwrap_direct_message, unwrap_public_chain_event,
     },
 };
@@ -357,12 +357,10 @@ impl NotificationJsonTransportApi for NostrClient {
             previous_event,
             root_event,
         )?;
-        info!("Sending public {} chain event: {:?}", blockchain, event);
         let send_event = self.client.sign_event_builder(event).await.map_err(|e| {
             error!("Failed to sign Nostr event: {e}");
             Error::Crypto("Failed to sign Nostr event".to_string())
         })?;
-        trace!("sending event {send_event:?}");
         self.client.send_event(&send_event).await.map_err(|e| {
             error!("Failed to send Nostr event: {e}");
             Error::Network("Failed to send Nostr event".to_string())
@@ -396,6 +394,16 @@ impl NotificationJsonTransportApi for NostrClient {
             Ok(None)
         }
     }
+
+    async fn resolve_public_chain(
+        &self,
+        id: &str,
+        chain_type: BlockchainType,
+    ) -> Result<Vec<nostr::event::Event>> {
+        Ok(self
+            .fetch_events(chain_filter(id, chain_type), Some(SortOrder::Asc), None)
+            .await?)
+    }
 }
 
 #[derive(Clone)]
@@ -508,7 +516,7 @@ impl NostrConsumer {
                                 {
                                     let success = match event.kind {
                                         Kind::EncryptedDirectMessage | Kind::GiftWrap => {
-                                            info!("Received encrypted direct message: {event:?}");
+                                            trace!("Received encrypted direct message: {event:?}");
                                             match handle_direct_message(
                                                 event.clone(),
                                                 &signer,
@@ -525,7 +533,7 @@ impl NostrConsumer {
                                             }
                                         }
                                         Kind::TextNote => {
-                                            info!("Received text note: {event:?}");
+                                            trace!("Received text note: {event:?}");
                                             match handle_public_event(
                                                 event.clone(),
                                                 &client_id,
@@ -629,7 +637,7 @@ async fn handle_public_event(
             .await
         {
             let decrypted = decrypt_public_chain_event(&encrypted_data.payload, &chain_keys)?;
-            info!("Handling public chain event: {:?}", decrypted);
+            trace!("Handling public chain event: {decrypted:?}");
             handle_event(decrypted, node_id, handlers).await?
         }
     }

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

@@ -70,7 +70,7 @@ pub enum Error {
     InvalidBlockchainType(String),
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum BlockchainType {
     #[serde(rename = "bill")]
     Bill,

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

@@ -3,3 +3,6 @@ pub const ACCEPT_DEADLINE_SECONDS: u64 = 86400 * 2; // 2 days
 pub const RECOURSE_DEADLINE_SECONDS: u64 = 86400 * 2; // 2 days
 
 pub const VALID_CURRENCIES: [&str; 1] = ["sat"];
+
+// the chain prefix we use when tagging our events on Nostr
+pub const BCR_NOSTR_CHAIN_PREFIX: &str = "bitcredit";

crates/bcr-ebill-transport/src/event/bill_events.rs

@@ -155,7 +155,7 @@ impl BillChainEvent {
         let invite = ChainInvite::bill(self.bill.id.to_owned(), self.bill_keys.clone());
         self.new_participants()
             .keys()
-            .map(|node_id| (node_id.to_owned(), Event::new_chain(invite.clone())))
+            .map(|node_id| (node_id.to_owned(), Event::new_invite(invite.clone())))
             .collect()
     }
 }

crates/bcr-ebill-transport/src/event/mod.rs

@@ -12,11 +12,17 @@ pub enum EventType {
     Bill,
     /// Public Bill chain events
     BillChain,
+    /// Private Bill invites with keys
+    BillChainInvite,
 }
 
 impl EventType {
     pub fn all() -> Vec<EventType> {
-        vec![EventType::Bill, EventType::BillChain]
+        vec![
+            EventType::Bill,
+            EventType::BillChain,
+            EventType::BillChainInvite,
+        ]
     }
 }
 
@@ -47,6 +53,10 @@ impl<T: Serialize> Event<T> {
     pub fn new_chain(data: T) -> Self {
         Self::new(EventType::BillChain, data)
     }
+
+    pub fn new_invite(data: T) -> Self {
+        Self::new(EventType::BillChainInvite, data)
+    }
 }
 
 /// The event version that is used for all events if no specific version