lt_blockchain 0.1.0

Blockchain written with educational purpose by Learn Together Community.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// #![allow(dead_code)]
#![allow(non_snake_case)]

use std::collections::HashMap;

use serde_with::serde_as;

use super::wt;
use super::transaction::*;
use super::digest::*;
use super::block::*;

#[ serde_as ]
#[ derive( Clone, Serialize, Deserialize, Debug ) ]
pub struct Chain
{
  pub blocks : Vec< Block >,
  #[ serde_as( as = "HashMap<serde_with::json::JsonString, _>" ) ]
  pub transactions_pool : HashMap< Digest, Transaction >,
  pub difficulty : u32,
  pub miner_addr : String,
  pub reward : f64
}

//

impl Chain
{

  //

  pub fn new() -> Chain
  {

    Chain
    {
      blocks : Vec::new(),
      transactions_pool : HashMap::new(),
      difficulty : 2,
      miner_addr : "Miner1".to_string(),
      reward : 100.0
    }

    /*
    issue : https://github.com/Learn-Together-Pro/Blockchain/issues/19
    complexity : mid
    stage : early
    */

  }

  //

  pub fn hash_last( &self ) -> Digest
  {
    let last_block = &self
                                                  .blocks
                                                  .last();
    let last_block_hash: Digest = match last_block {
      Some(last_block) => last_block.to_owned().body.hash.clone(),
      None => {
        let zero : Vec< u8 > = [ 0 ; 32 ].into();
        Digest::from( zero.clone() )
      }
    };
    last_block_hash
  }

  //

  pub fn block_mine( &self ) -> Option< Block >
  {

    let time = wt::time::s::now();
    let block_header = BlockHeader
    {
      time,
      nonce : 0,
      pre_hash : self.hash_last(),
      merkle_hash : Digest::new(),
      difficulty : self.difficulty,
      body : (),
    };
    let mut block = block_header.form();

    let sender = Digest::from( Vec::from( "root".as_bytes() ) );
    let mut receiver_map = HashMap::new();
    receiver_map.insert( Digest::from( Vec::from( self.miner_addr.as_bytes() ) ), self.reward );

    let reward_trans_body = TransactionHeader
    {
      sender,
      receiver : receiver_map,
      amount : self.reward,
      time,
      body : ()
    };
    let reward_trans = reward_trans_body.form();
    block.body.transactions.push( reward_trans );
    block.body.transactions.extend( self.transactions_pool.values().cloned() );

    block.merkle_hash = merkle_calc( &block.body.transactions );
    block.body.hash = block.header().proof_of_work();

    println!( "ntransactions : {}", block.body.transactions.len() );
    println!( "hash : {:?}", block.body.hash );

    Some( block )
  }

  //

  pub fn block_add( &mut self, block : Block )
  {
    println!( "Adding block : {:#?}", &block );

    for t in &block.body.transactions
    {
      let hash = &t.body.hash;
      self.transactions_pool.remove( hash );
    }

    self.blocks.push( block );
  }

}