Merge branch 'master' into taproot-test

Author: 0xEgao

.github/workflows/lint.yaml

@@ -16,6 +16,9 @@ jobs:
 
       - name: Set profile
         run: rustup set profile minimal
+      
+      - name: Install protobuf compiler
+        run: sudo apt-get update && sudo apt-get install -y protobuf-compiler
 
       - name: Install nightly toolchain
         run: rustup toolchain install nightly

.github/workflows/test.yaml

@@ -14,6 +14,9 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
+      - name: Install protobuf compiler
+        run: sudo apt-get update && sudo apt-get install -y protobuf-compiler
+
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:

Cargo.toml

@@ -35,10 +35,13 @@ sha2 = "0.10.9"
 rust-coinselect = "0.1.6"
 crossterm = "0.29.0"
 zmq = "0.10.0"
+tungstenite = { version = "0.28.0", features = ["native-tls"]}
+nostr = "0.44.2"
 
 [dev-dependencies]
 flate2 = {version = "1.0.35"}
 tar = {version = "0.4.43"}
+nostr-rs-relay = "0.8.12"
 
 #Empty default feature set, (helpful to generalise in github actions)
 [features]

README.md

@@ -77,7 +77,7 @@ The crate compiles into following binaries.
 Following dependencies are needed to compile the crate.
 
 ```shell
-sudo apt install build-essential automake libtool
+sudo apt install build-essential automake libtool protobuf-compiler
 ```
 To run all the coinswap apps the two more systems are needed.
 

docker/Dockerfile

@@ -6,14 +6,19 @@ FROM rust:1.90-alpine3.20 AS builder
 
 RUN apk add --no-cache \
     build-base \
+    protobuf \
     cmake \
     git \
     curl \
     pkgconfig \
     openssl-dev \
     sqlite-dev \
     sqlite-static \
-    zeromq-dev
+    zeromq-dev \
+    ca-certificates \
+    openssl-libs-static \
+    libgcc \
+    musl-dev
 
 WORKDIR /usr/src/coinswap
 COPY . .
@@ -26,11 +31,20 @@ FROM alpine:3.20
 
 RUN --mount=type=cache,target=/var/cache/apk \
     apk add --no-cache \
+    build-base \
+    protobuf \
+    cmake \
+    git \
+    curl \
+    pkgconfig \
+    openssl-dev \
+    sqlite-dev \
+    sqlite-static \
+    zeromq-dev \
     ca-certificates \
-    openssl \
+    openssl-libs-static \
     libgcc \
-    sqlite \
-    zeromq
+    musl-dev
 
 RUN adduser -D -u 1001 coinswap
 

src/bin/taker.rs

@@ -2,7 +2,7 @@ use bitcoin::{Address, Amount};
 use bitcoind::bitcoincore_rpc::Auth;
 use clap::Parser;
 use coinswap::{
-    taker::{error::TakerError, SwapParams, Taker, TaprootTaker},
+    taker::{error::TakerError, offers::MakerState, SwapParams, Taker, TaprootTaker},
     utill::{parse_proxy_auth, setup_taker_logger, MIN_FEE_RATE, UTXO},
     wallet::{Destination, RPCConfig, Wallet},
 };
@@ -180,7 +180,7 @@ fn main() -> Result<(), TakerError> {
     let rpc_config = RPCConfig {
         url: args.rpc,
         auth: Auth::UserPass(args.auth.0, args.auth.1),
-        wallet_name: "random".to_string(), // we can put anything here as it will get updated in the init.
+        wallet_name: "random_1".to_string(), // we can put anything here as it will get updated in the init.
     };
 
     match &args.command {
@@ -339,24 +339,49 @@ fn main() -> Result<(), TakerError> {
                     taker.get_wallet_mut().sync_and_save()?;
                 }
                 Commands::FetchOffers => {
-                    let all_offers = {
-                        let offerbook = taker.fetch_offers()?;
-                        offerbook
-                            .all_makers()
-                            .iter()
-                            .cloned()
-                            .cloned()
-                            .collect::<Vec<_>>()
-                    };
-                    if all_offers.is_empty() {
-                        println!("NO LIVE OFFERS FOUND!! You should run a maker!!");
+                    use std::time::{Duration, Instant};
+
+                    println!("Waiting for offerbook synchronization to complete…");
+                    let sync_start = Instant::now();
+
+                    while taker.is_offerbook_syncing() {
+                        println!("Offerbook sync in progress...");
+                        std::thread::sleep(Duration::from_secs(2));
+                    }
+
+                    println!("Offerbook synchronized in {:.2?}", sync_start.elapsed());
+
+                    let offerbook = taker.fetch_offers()?;
+                    let makers = offerbook.all_makers();
+
+                    if makers.is_empty() {
+                        println!("No makers found in offerbook");
                         return Ok(());
-                    } else {
-                        all_offers.iter().try_for_each(|offer| {
-                            println!("{}", taker.display_offer(offer)?);
-                            Ok::<_, TakerError>(())
-                        })?;
                     }
+
+                    let mut good = 0;
+                    let mut bad = 0;
+                    let mut unresponsive = 0;
+
+                    println!("\nDiscovered {} makers\n", makers.len());
+
+                    for maker in &makers {
+                        match maker.state {
+                            MakerState::Good => good += 1,
+                            MakerState::Bad => bad += 1,
+                            MakerState::Unresponsive { .. } => unresponsive += 1,
+                        }
+
+                        println!("{}", taker.display_offer(maker)?);
+                    }
+
+                    println!(
+                        "\nOfferbook summary → good: {}, bad: {}, unresponsive: {} (total: {})",
+                        good,
+                        bad,
+                        unresponsive,
+                        makers.len()
+                    );
                 }
                 Commands::Coinswap { makers, amount } => {
                     // Note: taproot coinswap is handled at the top level to avoid

src/maker/api.rs

@@ -297,6 +297,8 @@ impl Maker {
             config.network_port = port;
         }
 
+        // ## TODO: Encapsulate these initialization inside the watcher and
+        //     pollute the client declaration.
         let backend = ZmqBackend::new(&zmq_addr);
         let rpc_backend = BitcoinRpc::new(rpc_config.clone())?;
         let blockchain_info = rpc_backend.get_blockchain_info()?;
@@ -306,11 +308,12 @@ impl Maker {
         let registry = FileRegistry::load(file_registry);
         let (tx_requests, rx_requests) = mpsc::channel();
         let (tx_events, rx_responses) = mpsc::channel();
+        let rpc_config_watcher = rpc_config.clone();
 
         let mut watcher = Watcher::<Maker>::new(backend, registry, rx_requests, tx_events);
         _ = thread::Builder::new()
             .name("Watcher thread".to_string())
-            .spawn(move || watcher.run(rpc_backend));
+            .spawn(move || watcher.run(rpc_config_watcher));
 
         let watch_service = WatchService::new(tx_requests, rx_responses);
 

src/maker/api2.rs

@@ -280,6 +280,8 @@ impl Maker {
             config.network_port = port;
         }
 
+        // ## TODO: Encapsulate these initialization inside the watcher and
+        //     pollute the client declaration.
         let backend = ZmqBackend::new(&zmq_addr);
         let rpc_backend = BitcoinRpc::new(rpc_config.clone())?;
         let blockchain_info = rpc_backend.get_blockchain_info()?;
@@ -289,11 +291,12 @@ impl Maker {
         let registry = FileRegistry::load(file_registry);
         let (tx_requests, rx_requests) = mpsc::channel();
         let (tx_events, rx_responses) = mpsc::channel();
+        let rpc_config_watcher = rpc_config.clone();
 
         let mut watcher = Watcher::<Maker>::new(backend, registry, rx_requests, tx_events);
         _ = thread::Builder::new()
             .name("Watcher thread".to_string())
-            .spawn(move || watcher.run(rpc_backend));
+            .spawn(move || watcher.run(rpc_config_watcher));
 
         let watch_service = WatchService::new(tx_requests, rx_responses);
 

src/maker/server.rs

@@ -4,9 +4,19 @@
 //! The server maintains the thread pool for P2P Connection, Watchtower, Bitcoin Backend, and RPC Client Request.
 //! The server listens at two ports: 6102 for P2P, and 6103 for RPC Client requests.
 
-use crate::protocol::messages::FidelityProof;
+use crate::{
+    protocol::messages::FidelityProof,
+    utill::{COINSWAP_KIND, NOSTR_RELAYS},
+};
 use bitcoin::{absolute::LockTime, Amount};
 use bitcoind::bitcoincore_rpc::RpcApi;
+use nostr::{
+    event::{EventBuilder, Kind},
+    key::{Keys, SecretKey},
+    message::{ClientMessage, RelayMessage},
+    util::JsonUtil,
+};
+use tungstenite::Message;
 
 use std::{
     io::ErrorKind,
@@ -75,10 +85,102 @@ fn network_bootstrap(maker: Arc<Maker>) -> Result<String, MakerError> {
 /// 2. Creates a new fidelity bond if no valid bonds remain after redemption.
 fn manage_fidelity_bonds(maker: &Maker, maker_addr: &str) -> Result<(), MakerError> {
     maker.wallet.write()?.redeem_expired_fidelity_bonds()?;
-    setup_fidelity_bond(maker, maker_addr)?;
+    let fidelity = setup_fidelity_bond(maker, maker_addr)?;
+    broadcast_bond_on_nostr(fidelity)?;
     Ok(())
 }
 
+// ##TODO: Make this part of nostr module and improve error handing
+// ##TODO: Try retry in case relay doesn't accept the event
+fn broadcast_bond_on_nostr(fidelity: FidelityProof) -> Result<(), MakerError> {
+    let outpoint = fidelity.bond.outpoint;
+    let content = format!("{}:{}", outpoint.txid, outpoint.vout);
+
+    // ##TODO: Don't use ephemeral keys
+    let secret_key = SecretKey::generate();
+    let keys = Keys::new(secret_key);
+
+    let event = EventBuilder::new(Kind::Custom(COINSWAP_KIND), content)
+        .build(keys.public_key)
+        .sign_with_keys(&keys)
+        .expect("Event should be signed");
+
+    let msg = ClientMessage::Event(std::borrow::Cow::Owned(event));
+
+    log::debug!("nostr wire msg: {}", msg.as_json());
+
+    let mut success = false;
+
+    for relay in NOSTR_RELAYS {
+        match broadcast_to_relay(relay, &msg) {
+            Ok(()) => {
+                success = true;
+            }
+            Err(e) => {
+                log::warn!("failed to broadcast to {}: {:?}", relay, e);
+            }
+        }
+    }
+
+    if !success {
+        log::warn!("nostr event was not accepted by any relay");
+    }
+
+    Ok(())
+}
+
+fn broadcast_to_relay(relay: &str, msg: &ClientMessage) -> Result<(), MakerError> {
+    let (mut socket, _) = tungstenite::connect(relay).map_err(|e| {
+        log::warn!("failed to connect to nostr relay {}: {}", relay, e);
+        MakerError::General("failed to connect to nostr relay")
+    })?;
+
+    socket
+        .write(Message::Text(msg.as_json().into()))
+        .map_err(|e| {
+            log::warn!("nostr relay write failed: {}", e);
+            MakerError::General("failed to write to nostr relay")
+        })?;
+    socket.flush().ok();
+
+    match socket.read() {
+        Ok(Message::Text(text)) => {
+            if let Ok(relay_msg) = RelayMessage::from_json(&text) {
+                match relay_msg {
+                    RelayMessage::Ok {
+                        event_id,
+                        status: true,
+                        ..
+                    } => {
+                        log::info!("nostr relay {} accepted event {}", relay, event_id);
+                        return Ok(());
+                    }
+                    RelayMessage::Ok {
+                        event_id,
+                        status: false,
+                        message,
+                    } => {
+                        log::warn!(
+                            "nostr relay {} rejected event {}: {}",
+                            relay,
+                            event_id,
+                            message
+                        );
+                    }
+                    _ => {}
+                }
+            }
+        }
+        Ok(_) => {}
+        Err(e) => {
+            log::warn!("nostr relay {} read error: {}", relay, e);
+        }
+    }
+    log::warn!("nostr relay {} did not confirm event", relay);
+
+    Err(MakerError::General("nostr relay did not confirm event"))
+}
+
 /// Ensures the wallet has a valid fidelity bond. If no active bond exists, it creates a new one.
 ///
 /// ### NOTE ON VALID FIDELITY BOND:
@@ -152,7 +254,7 @@ fn setup_fidelity_bond(maker: &Maker, maker_address: &str) -> Result<FidelityPro
             let fidelity_result = maker.get_wallet().write()?.create_fidelity(
                 amount,
                 locktime,
-                Some(maker_address.as_bytes()),
+                Some(maker_address),
                 MIN_FEE_RATE,
             );