feat: ✨ send mined block for client

src/blockchain.rs

@@ -51,7 +51,13 @@ impl BlockChain {
         self.chain.push(new_block);
     }
 
-    pub fn add_block(&mut self, block: Block) -> Option<Block> {
+    pub fn add_block(&mut self, mut block: Block) -> Block {
+        block.mine(self.difficulty);
+        self.chain.push(block.clone());
+        block
+    }
+
+    pub fn push_block(&mut self, block: Block) -> Option<Block> {
         if block.hash != String::new() {
             self.chain.push(block.clone());
             Some(block)

src/client_network.rs

@@ -1,6 +1,9 @@
-use futures_util::{stream::SplitStream, StreamExt};
+use futures_util::{
+    stream::{SplitSink, SplitStream},
+    SinkExt, StreamExt,
+};
 use tokio::net::TcpStream;
-use tokio_tungstenite::{connect_async, MaybeTlsStream, WebSocketStream};
+use tokio_tungstenite::{connect_async, tungstenite::Message, MaybeTlsStream, WebSocketStream};
 
 use crate::{block::Block, blockchain::BlockChain, ClientConfig};
 
@@ -14,11 +17,14 @@ pub async fn start_network(client_config: ClientConfig) {
         Ok(ws_stream) => ws_stream,
         Err(_) => return,
     };
-    let (_, ws_receiver) = ws_stream.0.split();
-    sync(ws_receiver).await;
+    let (ws_stream_sender, ws_stream_receiver) = ws_stream.0.split();
+    sync(ws_stream_sender, ws_stream_receiver).await;
 }
 
-async fn sync(ws_stream_receiver: SplitStream<WebSocketStream<MaybeTlsStream<TcpStream>>>) {
+async fn sync(
+    mut ws_stream_sender: SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>,
+    ws_stream_receiver: SplitStream<WebSocketStream<MaybeTlsStream<TcpStream>>>,
+) {
     let (mut ws_stream_receiver, mut blockchain) =
         match receive_blockchain(ws_stream_receiver).await {
             Some((ws_stream_receiver, blockchain)) => (ws_stream_receiver, blockchain),
@@ -30,7 +36,11 @@ async fn sync(ws_stream_receiver: SplitStream<WebSocketStream<MaybeTlsStream<Tcp
             Some((ws_stream_receiver, block)) => (ws_stream_receiver, block),
             None => return,
         };
-        blockchain.add_block(block);
+        let block = blockchain.add_block(block);
+        ws_stream_sender = match send_block(ws_stream_sender, block).await {
+            Some(ws_stream_sender) => ws_stream_sender,
+            None => return,
+        }
     }
 }
 
@@ -83,3 +93,17 @@ async fn receive_block(
         None => return None,
     }
 }
+
+async fn send_block(
+    mut ws_stream_sender: SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>,
+    block: Block,
+) -> Option<SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>> {
+    let block_data = serde_json::json!(block).to_string();
+    match ws_stream_sender.send(block_data.into()).await {
+        Ok(_) => match ws_stream_sender.flush().await {
+            Ok(_) => Some(ws_stream_sender),
+            Err(_) => None,
+        },
+        Err(_) => None,
+    }
+}

src/consensus.rs

@@ -44,8 +44,13 @@ pub async fn accept_agreement(
             //03.46 right now.
             for block in received_blocks.iter() {
                 if max_pair.0 == block.hash {
-                    match blockchain_thread_safe.lock().await.add_block(block.clone()) {
-                        Some(_successfully_added_block) => {
+                    match blockchain_thread_safe
+                        .lock()
+                        .await
+                        .push_block(block.clone())
+                    {
+                        Some(successfully_added_block) => {
+                            println!("{:#?}", successfully_added_block);
                             todo!("Notify Whole Network, Reward First Founder or Else")
                         }
                         None => todo!(),