Add mining code for mp2

src/block.rs

-#[cfg(test)]
-#[macro_use]
+//#[cfg(test)]
+//#[macro_use]
 
 use rand::Rng;
 use serde::{Serialize, Deserialize};
 use crate::crypto::hash::{H256, Hashable};
-use crate::transaction::Transaction;
-use crate::transaction::tests::generate_random_transaction;
+use crate::transaction::{self, Transaction};
 
 #[derive(Serialize, Deserialize, Debug,Clone)]
 pub struct Header {
@@ -39,25 +38,18 @@ impl Hashable for Header {
     }
 }
 
-
-#[cfg(any(test, test_utilities))]
-pub mod test {
-    use super::*;
-    use crate::crypto::hash::H256;
-
-    pub fn generate_random_block(parent: &H256) -> Block {
-        let mut rng = rand::thread_rng();
-        let r1:u32 = rng.gen();
-        let r2:u128 = rng.gen();
-        let mut buffer: [u8; 32] = [0; 32];
-        let b:H256 = buffer.into();
-        let h:Header = Header{parenthash:*parent,nonce:r1,difficulty:b,timestamp:r2,merkle_root:b};
-        let t = generate_random_transaction();
-        //transaction::pr();
-        let mut vect:Vec<Transaction> = vec![];
-        vect.push(t);
-        let c:Content = Content{data:vect};
-        let b:Block = Block{header:h,content:c};
-        b
-    }
+pub fn generate_random_block(parent: &H256) -> Block {
+    let mut rng = rand::thread_rng();
+    let r1:u32 = rng.gen();
+    let r2:u128 = rng.gen();
+    //let mut buffer: [u8; 32] = [0; 32];
+    let b:H256 = hex!("00087718210e0b3b608814e04e61fde06d0df794319a12162f287412df3ec920").into();
+    let h:Header = Header{parenthash:*parent,nonce:r1,difficulty:b,timestamp:r2,merkle_root:b};
+    let t = transaction::generate_random_transaction();
+    //transaction::pr();
+    let mut vect:Vec<Transaction> = vec![];
+    vect.push(t);
+    let c:Content = Content{data:vect};
+    let b:Block = Block{header:h,content:c};
+    b
 }

src/blockchain.rs

-use crate::block::*;
+use crate::block::{self, *};
 use crate::crypto::hash::{H256,Hashable};
-use crate::crypto::hash::tests::generate_random_hash;
+use crate::crypto::hash;
 use std::collections::HashMap;
-use crate::block::test::generate_random_block;
 
 pub struct Blockchain {
-    chain:HashMap<H256,Block>,
-    tiphash:H256,
+    pub chain:HashMap<H256,Block>,
+    pub tiphash:H256,
     heights:HashMap<H256,u8>,
     buffer:HashMap<H256,Block>,
 }
@@ -16,7 +15,7 @@ impl Blockchain {
     pub fn new() -> Self {
         let mut buffer: [u8; 32] = [0; 32];
         let b:H256 = buffer.into();
-        let mut genesis:Block = generate_random_block(&b);
+        let mut genesis:Block = block::generate_random_block(&b);
         let mut genhash:H256 = genesis.hash();
         let mut chainmap:HashMap<H256,Block> = HashMap::new();
         let mut heightsmap:HashMap<H256,u8> = HashMap::new();
@@ -45,7 +44,7 @@ impl Blockchain {
                     self.tiphash = h;
                 }
 
-                let mut bhash_copy:H256 = generate_random_hash();
+                let mut bhash_copy:H256 = hash::generate_random_hash();
                 //if stale blocks parent has arrived, insert it into main chain
                 for (bhash,blck) in self.buffer.iter(){
                     if blck.header.parenthash == h {
@@ -93,14 +92,14 @@ impl Blockchain {
 #[cfg(any(test, test_utilities))]
 mod tests {
     use super::*;
-    use crate::block::test::generate_random_block;
+    use crate::block;
     use crate::crypto::hash::Hashable;
 
     #[test]
     fn insert_one() {
         let mut blockchain = Blockchain::new();
         let genesis_hash = blockchain.tip();
-        let block = generate_random_block(&genesis_hash);
+        let block = block::generate_random_block(&genesis_hash);
         blockchain.insert(&block);
         assert_eq!(blockchain.tip(), block.hash());
 

src/crypto/hash.rs

 use serde::{Serialize, Deserialize};
 use std::convert::TryInto;
+use rand::Rng;
 
 /// An object that can be meaningfully hashed.
 pub trait Hashable {
@@ -107,17 +108,10 @@ impl PartialOrd for H256 {
     }
 }
 
-#[cfg(any(test, test_utilities))]
-pub mod tests {
-    use super::H256;
-    use rand::Rng;
-
-    pub fn generate_random_hash() -> H256 {
-        let mut rng = rand::thread_rng();
-        let random_bytes: Vec<u8> = (0..32).map(|_| rng.gen()).collect();
-        let mut raw_bytes = [0; 32];
-        raw_bytes.copy_from_slice(&random_bytes);
-        (&raw_bytes).into()
-    }
-
+pub fn generate_random_hash() -> H256 {
+    let mut rng = rand::thread_rng();
+    let random_bytes: Vec<u8> = (0..32).map(|_| rng.gen()).collect();
+    let mut raw_bytes = [0; 32];
+    raw_bytes.copy_from_slice(&random_bytes);
+    (&raw_bytes).into()
 }

src/main.rs

-#[cfg(test)]
+//#[cfg(test)]
 #[macro_use]
 extern crate hex_literal;
 
@@ -19,6 +19,7 @@ use std::net;
 use std::process;
 use std::thread;
 use std::time;
+use std::sync::{Arc, Mutex};
 
 fn main() {
     // parse command line arguments
@@ -81,8 +82,10 @@ fn main() {
     worker_ctx.start();
 
     // start the miner
+    let blockchain = Arc::new(Mutex::new(blockchain::Blockchain::new()));
     let (miner_ctx, miner) = miner::new(
         &server,
+        &blockchain,
     );
     miner_ctx.start();
 

src/miner.rs

 use crate::network::server::Handle as ServerHandle;
+use crate::blockchain::Blockchain;
+use crate::block::*;
+use crate::transaction::{self, Transaction};
+use crate::crypto::hash::{H256, Hashable};
 
 use log::info;
-
+use rand::Rng;
 use crossbeam::channel::{unbounded, Receiver, Sender, TryRecvError};
-use std::time;
 
+use std::time::{self, SystemTime, UNIX_EPOCH};
 use std::thread;
+use std::sync::{Arc, Mutex};
 
 enum ControlSignal {
     Start(u64), // the number controls the lambda of interval between block generation
@@ -23,6 +28,7 @@ pub struct Context {
     control_chan: Receiver<ControlSignal>,
     operating_state: OperatingState,
     server: ServerHandle,
+    blockchain: Arc<Mutex<Blockchain>>
 }
 
 #[derive(Clone)]
@@ -33,6 +39,7 @@ pub struct Handle {
 
 pub fn new(
     server: &ServerHandle,
+    blockchain: &Arc<Mutex<Blockchain>>
 ) -> (Context, Handle) {
     let (signal_chan_sender, signal_chan_receiver) = unbounded();
 
@@ -40,6 +47,7 @@ pub fn new(
         control_chan: signal_chan_receiver,
         operating_state: OperatingState::Paused,
         server: server.clone(),
+        blockchain: Arc::clone(blockchain)
     };
 
     let handle = Handle {
@@ -111,7 +119,49 @@ impl Context {
                 return;
             }
 
-            // TODO: actual mining
+            // actual mining
+            
+            // create Block
+            //TODO: Put this in a function
+            
+            //Creating Header fields
+            let mut locked_blockchain = self.blockchain.lock().unwrap();
+            let phash = locked_blockchain.tiphash;
+
+            let mut rng = rand::thread_rng();
+            let nonce = rng.gen();
+            
+            let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis();
+            let difficulty = locked_blockchain.chain.get(&locked_blockchain.tiphash)
+                             .unwrap()
+                             .header
+                             .difficulty ;
+            
+            //Creating Content
+            //It will also be used for Merkel Root for the Header
+            let t = transaction::generate_random_transaction();
+            let mut vect: Vec<Transaction> = vec![];
+            vect.push(t);
+            let content: Content = Content{data:vect};
+
+            let merkle_root = H256::from([0; 32]); 
+
+            //Putting all together
+            let header = Header{
+                parenthash: phash,
+                nonce: nonce,
+                difficulty: difficulty,
+                timestamp: timestamp,
+                merkle_root: merkle_root
+            };
+            let new_block = Block{header: header, content: content};
+            
+            //Check whether block solved the puzzle
+            //If passed, add it to blockchain
+            if new_block.hash() <= difficulty {
+              print!("block is generated\n");
+              locked_blockchain.insert(&new_block);
+            }
 
             if let OperatingState::Run(i) = self.operating_state {
                 if i != 0 {
@@ -119,6 +169,8 @@ impl Context {
                     thread::sleep(interval);
                 }
             }
+
+            std::mem::drop(locked_blockchain);
         }
     }
 }

src/to-do

+remove references to generate_random_block and generate_random_transaction

src/transaction.rs

@@ -41,11 +41,22 @@ pub fn verify(t: &Transaction, public_key: &<Ed25519KeyPair as KeyPair>::PublicK
     peer_public_key.verify(&encoded[..],signature.as_ref()).is_ok()
 }
 
+pub fn generate_random_transaction() -> Transaction {
+    /*Default::default();*/
+    let mut rng = rand::thread_rng();
+    let mut random_bytes: Vec<u8> = (0..32).map(|_| rng.gen()).collect();
+    let input_bytes = random_bytes;
+    random_bytes = (0..32).map(|_| rng.gen()).collect();
+    let output_bytes = random_bytes;
+    Transaction{input : input_bytes,output : output_bytes}
+}
+
 #[cfg(any(test, test_utilities))]
 pub mod tests {
     use super::*;
     use crate::crypto::key_pair;
 
+/*
     pub fn generate_random_transaction() -> Transaction {
         /*Default::default();*/
         let mut rng = rand::thread_rng();
@@ -54,7 +65,7 @@ pub mod tests {
         random_bytes = (0..32).map(|_| rng.gen()).collect();
         let output_bytes = random_bytes;
         Transaction{input : input_bytes,output : output_bytes}
-    }
+    }*/
 
     #[test]
     fn sign_verify() {