feat(spv): broadcast transaction (#180)

Author: pauldelucia

dash-spv-ffi/src/broadcast.rs

@@ -26,7 +26,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_broadcast_transaction(
         }
     };
 
-    let _tx = match dashcore::consensus::deserialize::<dashcore::Transaction>(&tx_bytes) {
+    let tx = match dashcore::consensus::deserialize::<dashcore::Transaction>(&tx_bytes) {
         Ok(t) => t,
         Err(e) => {
             set_last_error(&format!("Invalid transaction: {}", e));
@@ -38,15 +38,26 @@ pub unsafe extern "C" fn dash_spv_ffi_client_broadcast_transaction(
     let inner = client.inner.clone();
 
     let result: Result<(), dash_spv::SpvError> = client.runtime.block_on(async {
-        let guard = inner.lock().unwrap();
-        if let Some(ref _spv_client) = *guard {
-            // TODO: broadcast_transaction not yet implemented in dash-spv
-            Err(dash_spv::SpvError::Config("Not implemented".to_string()))
-        } else {
-            Err(dash_spv::SpvError::Storage(dash_spv::StorageError::NotFound(
-                "Client not initialized".to_string(),
-            )))
-        }
+        // Take the client out to avoid holding the lock across await
+        let spv_client = {
+            let mut guard = inner.lock().unwrap();
+            match guard.take() {
+                Some(client) => client,
+                None => {
+                    return Err(dash_spv::SpvError::Storage(dash_spv::StorageError::NotFound(
+                        "Client not initialized".to_string(),
+                    )))
+                }
+            }
+        };
+
+        // Broadcast the transaction over P2P
+        let res = spv_client.broadcast_transaction(&tx).await;
+
+        // Put the client back
+        let mut guard = inner.lock().unwrap();
+        *guard = Some(spv_client);
+        res
     });
 
     match result {

dash-spv-ffi/src/client.rs

@@ -1476,7 +1476,7 @@ pub unsafe extern "C" fn dash_spv_ffi_client_record_send(
         }
     };
 
-    let _txid = match Txid::from_str(txid_str) {
+    let txid = match Txid::from_str(txid_str) {
         Ok(t) => t,
         Err(e) => {
             set_last_error(&format!("Invalid txid: {}", e));
@@ -1499,9 +1499,10 @@ pub unsafe extern "C" fn dash_spv_ffi_client_record_send(
                 }
             }
         };
+        let res = spv_client.record_send(txid).await;
         let mut guard = inner.lock().unwrap();
         *guard = Some(spv_client);
-        Ok(())
+        res
     });
 
     match result {

dash-spv/src/client/mempool.rs

@@ -138,6 +138,13 @@ impl<
         mempool_state.transactions.len()
     }
 
+    /// Record that we attempted to send a transaction (for UX/heuristics).
+    pub async fn record_send(&self, txid: dashcore::Txid) -> Result<()> {
+        let mut mempool_state = self.mempool_state.write().await;
+        mempool_state.record_send(txid);
+        Ok(())
+    }
+
     /// Update mempool filter with wallet's monitored addresses.
     #[allow(dead_code)]
     pub(super) async fn update_mempool_filter(&mut self) {

dash-spv/src/client/mod.rs

@@ -10,6 +10,7 @@
 //! - `progress.rs` - Sync progress calculation and reporting
 //! - `mempool.rs` - Mempool tracking and coordination
 //! - `queries.rs` - Peer, masternode, and balance queries
+//! - `transactions.rs` - Transaction operations (e.g., broadcast)
 //! - `chainlock.rs` - ChainLock and InstantLock processing
 //! - `sync_coordinator.rs` - Sync orchestration and network monitoring (the largest module)
 //!
@@ -48,6 +49,7 @@ mod mempool;
 mod progress;
 mod queries;
 mod sync_coordinator;
+mod transactions;
 
 // Re-export public types from extracted modules
 pub use block_processor::{BlockProcessingTask, BlockProcessor};

dash-spv/src/client/transactions.rs

@@ -0,0 +1,52 @@
+//! Transaction-related client APIs (e.g., broadcasting)
+
+use crate::error::{Result, SpvError};
+use crate::network::NetworkManager;
+use crate::storage::StorageManager;
+use dashcore::network::message::NetworkMessage;
+use key_wallet_manager::wallet_interface::WalletInterface;
+
+use super::DashSpvClient;
+
+impl<
+        W: WalletInterface + Send + Sync + 'static,
+        N: NetworkManager + Send + Sync + 'static,
+        S: StorageManager + Send + Sync + 'static,
+    > DashSpvClient<W, N, S>
+{
+    /// Broadcast a transaction to all connected peers.
+    pub async fn broadcast_transaction(&self, tx: &dashcore::Transaction) -> Result<()> {
+        let network = self
+            .network
+            .as_any()
+            .downcast_ref::<crate::network::multi_peer::MultiPeerNetworkManager>()
+            .ok_or_else(|| {
+                SpvError::Config("Network manager does not support broadcasting".to_string())
+            })?;
+
+        if network.peer_count() == 0 {
+            return Err(SpvError::Network(crate::error::NetworkError::NotConnected));
+        }
+
+        let message = NetworkMessage::Tx(tx.clone());
+        let results = network.broadcast(message).await;
+
+        let mut success = false;
+        let mut errors = Vec::new();
+        for res in results {
+            match res {
+                Ok(_) => success = true,
+                Err(err) => errors.push(err.to_string()),
+            }
+        }
+
+        if success {
+            Ok(())
+        } else {
+            Err(SpvError::Network(crate::error::NetworkError::ProtocolError(format!(
+                "Broadcast failed: {}",
+                errors.join(", ")
+            ))))
+        }
+    }
+}