Merge pull request #84 from ariard/2023-11-verify-mb-proofs

Add `BitcoindResult` and inter-thread chan between `BitcoindHandler` / `CredentialGateway`

src/bitcoind_client.rs

@@ -26,6 +26,11 @@ pub enum BitcoindRequest {
 	GenerateTxInclusionProof { txid: String, respond_to: oneshot::Sender<Option<String>> },
 }
 
+#[derive(Debug)]
+pub enum BitcoindResult {
+	ProofValid { hash: [u8; 32], valid: bool }
+}
+
 pub struct BitcoindClient {
 	host: String,
 	port: String,
@@ -58,6 +63,10 @@ pub struct BitcoindHandler {
 
 	receive_bitcoind_request: TokioMutex<mpsc::UnboundedReceiver<BitcoindRequest>>,
 
+	receive_bitcoind_request_gateway: TokioMutex<mpsc::UnboundedReceiver<BitcoindRequest>>,
+
+	send_bitcoind_result_handler: TokioMutex<mpsc::UnboundedSender<BitcoindResult>>,
+
 	bitcoind_client: BitcoindClient,
 
 	rpc_client: Client,
@@ -66,7 +75,7 @@ pub struct BitcoindHandler {
 }
 
 impl BitcoindHandler {
-	pub fn new(config: Config, receive_bitcoind_requests: mpsc::UnboundedReceiver<BitcoindRequest>) -> BitcoindHandler {
+	pub fn new(config: Config, receive_bitcoind_requests: mpsc::UnboundedReceiver<BitcoindRequest>, send_bitcoind_request_gateway: mpsc::UnboundedReceiver<BitcoindRequest>, send_bitcoind_result_handler: mpsc::UnboundedSender<BitcoindResult>) -> BitcoindHandler {
 
 		let bitcoind_client = BitcoindClient {
 			host: config.bitcoind_params.host.clone(),
@@ -84,6 +93,8 @@ impl BitcoindHandler {
 
 		BitcoindHandler {
 			receive_bitcoind_request: TokioMutex::new(receive_bitcoind_requests),
+			receive_bitcoind_request_gateway: TokioMutex::new(send_bitcoind_request_gateway),
+			send_bitcoind_result_handler: TokioMutex::new(send_bitcoind_result_handler),
 			bitcoind_client,
 			rpc_client,
 			config,

src/credentialgateway.rs

@@ -28,7 +28,7 @@ use staking_credentials::common::msgs::{CredentialAuthenticationResult, Credenti
 use staking_credentials::common::utils::Credentials;
 
 use crate::events::ClientEvents;
-use crate::bitcoind_client::BitcoindClient;
+use crate::bitcoind_client::{BitcoindClient, BitcoindRequest, BitcoindResult};
 
 use tokio::time::{sleep, Duration};
 use tokio::sync::mpsc;
@@ -152,14 +152,17 @@ pub struct CredentialGateway {
 	receive_credential_event_gateway: Mutex<mpsc::UnboundedReceiver<ClientEvents>>,
 	send_credential_events_gateway: Mutex<mpsc::UnboundedSender<ClientEvents>>,
 
+	send_bitcoind_request_gateway: Mutex<mpsc::UnboundedSender<BitcoindRequest>>,
+	receive_bitcoind_result_handler: Mutex<mpsc::UnboundedReceiver<BitcoindResult>>,
+
 	issuance_manager: IssuanceManager,
 	redemption_manager: RedemptionManager,
 
 	hosted_services: HashMap<u64, Service>,
 }
 
 impl CredentialGateway {
-	pub fn new(receive_credential_event_gateway: mpsc::UnboundedReceiver<ClientEvents>, send_credential_events_gateway: mpsc::UnboundedSender<ClientEvents>) -> Self {
+	pub fn new(receive_credential_event_gateway: mpsc::UnboundedReceiver<ClientEvents>, send_credential_events_gateway: mpsc::UnboundedSender<ClientEvents>, send_bitcoind_request_gateway: mpsc::UnboundedSender<BitcoindRequest>, receive_bitcoind_result_gateway: mpsc::UnboundedReceiver<BitcoindResult>) -> Self {
 		let bitcoind_client = BitcoindClient::new(String::new(), "0".to_string(), String::new(), String::new());
 		let secp_ctx = Secp256k1::new();
 		//TODO: should be given a path to bitcoind to use the wallet
@@ -191,6 +194,8 @@ impl CredentialGateway {
 			secp_ctx,
 			receive_credential_event_gateway: Mutex::new(receive_credential_event_gateway),
 			send_credential_events_gateway: Mutex::new(send_credential_events_gateway),
+			send_bitcoind_request_gateway: Mutex::new(send_bitcoind_request_gateway),
+			receive_bitcoind_result_handler: Mutex::new(receive_bitcoind_result_gateway),
 			issuance_manager: issuance_manager,
 			redemption_manager: redemption_manager,
 			hosted_services: hosted_services,

src/server.rs

@@ -28,7 +28,7 @@ use civkit::credentialgateway::CredentialGateway;
 use civkit::kindprocessor::NoteProcessor;
 use civkit::nodesigner::NodeSigner;
 use civkit::peerhandler::{NoiseGateway, PeerInfo};
-use civkit::bitcoind_client::{BitcoindHandler, BitcoindRequest};
+use civkit::bitcoind_client::{BitcoindHandler, BitcoindRequest, BitcoindResult};
 use civkit::NostrClient;
 
 use civkit::oniongateway::OnionBox;
@@ -390,14 +390,18 @@ fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
 	let (manager_send_bitcoind_request, receive_bitcoind_request) = mpsc::unbounded_channel::<(BitcoindRequest)>();
 
+	let (send_bitcoind_request_gateway, receive_bitcoind_request_handler) = mpsc::unbounded_channel::<(BitcoindRequest)>();
+
+	let (send_bitcoind_result_gateway, receive_bitcoind_result_handler) = mpsc::unbounded_channel::<(BitcoindResult)>();
+
 	// The onion message handler...quite empty for now.
 	let onion_box = OnionBox::new();
 
 	// The noise peers handler...almost empty for now.
 	let noise_gateway = NoiseGateway::new(gateway_receive);
 
 	// The staking credentials handler...quite empty for now.
-	let mut credential_gateway = CredentialGateway::new(receive_credential_event_gateway, send_credential_events_gateway);
+	let mut credential_gateway = CredentialGateway::new(receive_credential_event_gateway, send_credential_events_gateway, send_bitcoind_request_gateway, receive_bitcoind_result_handler);
 
 	// The note or service provider...quite empty for now.
 	let mut note_processor = NoteProcessor::new(processor_receive_dbrequests, receive_dbrequests_manager, send_db_result_handler, config.clone());
@@ -412,7 +416,7 @@ fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 	// TODO: add receive_credential_events_handler
 	let mut client_handler = ClientHandler::new(handler_receive, request_receive, handler_send_dbrequests, handler_receive_db_result, send_credential_events_handler, config.clone());
 
-	let mut bitcoind_handler = BitcoindHandler::new(config.clone(), receive_bitcoind_request);
+	let mut bitcoind_handler = BitcoindHandler::new(config.clone(), receive_bitcoind_request, receive_bitcoind_request_handler, send_bitcoind_result_gateway);
 
 	// Main handler of services provision.
 	let service_manager = ServiceManager::new(node_signer, anchor_manager, service_mngr_events_send, service_mngr_peer_send, manager_send_dbrequests, manager_send_bitcoind_request, config.clone());