server.srs

    loop {
        let (socket, addr) = listener.accept().await.unwrap();
        println!("New connection from: {addr}");

        let mut framed_stream = Framed::new(socket, ServerCodec);
        let new_txs = new_txs.clone();
        let state = state.clone();
        let new_task = tokio::spawn(async move {

            while let Some(Ok(frame)) = framed_stream.next().await {
                match frame {
                    TxFrame(txs) => {
                        println!("New txs received");
                        //todo: verify that txs are valid
                        let mut new_txs = { new_txs.lock().unwrap().clone() };
                        new_txs.extend(txs);
                    },
                    Mined(block) => {
                        let mut state = state.lock().unwrap();
                        if state.add_block_if_valid(block).is_ok() {
                                println!("New block accepted");
                                let mut new_txs = new_txs.lock().unwrap();
                                new_txs.clear();
                                //new_txs.retain(|item| !block_clone.txs.iter().any(|x| x == item));
                        } else {
                            println!("New block rejected");
                        }
                    },
                    GetNewTxpool => {
                        //println!("Tx pool requested");
                        let new_txs = { new_txs.lock().unwrap().clone() };
                        framed_stream.send(ServerFrame::NewTxPool(new_txs)).await;
                    },
                    GetVersion => {
                        framed_stream.send(ServerFrame::Version(env!("CARGO_PKG_VERSION").to_string())).await;
                    },
                    GetLastHash => {
                        println!("Last hash requested");
                        let last_hash = {
                            //change this later
                            let blocks = state.lock().unwrap().blocks.clone();
                            blocks.last().unwrap().get_hash()
                        };

                        framed_stream.send(ServerFrame::LastBlockHash(last_hash)).await;
                    },
                    GetBlockchain => {
                        println!("Blockchain requested");
                        let block_chain = { state.lock().unwrap().blocks.clone() };
                        framed_stream.send(ServerFrame::BlockChain(block_chain)).await;
                    }

                }
            }

        });

        //match

    }