Block & Chain skeleton

Block.rs

pub struct Block {
    index: u64,
    timestamp: DateTime<Utc>,
    transactions: Vec<Transaction>,
    proof: u64,
    previous_hash: String,
}

Chian.rs

pub struct Chain {
    chain: Vec<Block>,
    current_transactions: Vec<Transaction>,
    nodes: HashSet<String>,
}

impl Chain {
    pub fn new() -> Self {
        let mut chain = Chain {
            chain: vec![],
            current_transactions: vec![],
            nodes: HashSet::new(),
        };
        chain.new_block(Some("1".to_string()), 100);
        return chain;
    }

    pub fn new_block(&mut self, previous_hash: Option<String>, proof: u64) {
        let previous_hash: String = match previous_hash {
            Some(previous_hash) => previous_hash.to_string(),
            None => match self.chain.last_mut() {
                Some(last_block) => Chain::hash(last_block),
                None => "".to_string(),
            },
        };

        let block = Block::new(
            &self,
            self.current_transactions.to_vec(),
            proof,
            previous_hash.to_string(),
        );
        self.chain.push(block);
        self.current_transactions.clear();
    }
}

Transaction.rs

pub struct Transaction {
    sender: String,
    recipient: String,
    amount: u64,
}