Struct blockchainblock::BlockchainBlock

pub struct BlockchainBlock<'a, T> {
    pub curr_hash: BlockHash,
    pub prev_hash: Option<BlockHash>,
    pub data: &'a [T],
    pub timestamp: u64,
    pub nonce: u64,
    pub merkle_root: BlockHash,
    pub version: u8,
}

Structure for storing one Block of the Blockchain with as few dependencies as possible.

Fields

curr_hash: BlockHash

hash of the current block

prev_hash: Option<BlockHash>

hash of the previous block. Is None for the first block

data: &'a [T]

encrypted data in compressed form

timestamp: u64

time of block creation in seconds since 1970-01-01T00:00 UTC

nonce: u64

field used for giving variability

merkle_root: BlockHash

root of a sha256 hash tree where the leaves are transactions

version: u8

version of the protocol used to create the block

Methods

impl<'a, T> BlockchainBlock<'a, T> where
    T: Byteable + Clone, 

Implementation of BlockchainBlock for a generic type T

pub fn new(
    prev_hash: Option<BlockHash>,
    data: &[T],
    timestamp: u64,
    nonce: u64
) -> BlockchainBlock<T>

Constructs a new BlockchainBlock<T>.

Description

• prev_hash - Hash of the previous block.
• data - Data to be stored in the block.
• timestamp - Creation time in Unix time format.
• nonce - Nonce to include variability in the hash calculation.

Examples

Simple example with i32

  extern crate blockchainblock;
  use crate::blockchainblock::*;
   
  let prev  : Option<BlockHash> = None;
  let nonce : u64 = 3;
  let timestamp : u64 = 4;
  let data : [i32; 1] = [5];
  let block : BlockchainBlock<i32> = BlockchainBlock::new(prev, &data, timestamp, nonce);
  println!("\n{:?}\n", &block);
  assert_eq!(block.curr_hash, [23, 105, 91, 179, 190, 192, 178, 189, 198, 134, 87, 143, 214, 135, 93, 17, 50, 143, 192, 3, 254, 144, 115, 123, 42, 223, 197, 199, 181, 113, 224, 123]);

Example with array of Strings

extern crate blockchainblock;
use crate::blockchainblock::*;
     
let book_reviews = [
 String::from(
  "{
   \"Adventures of Huckleberry Finn\": \"My favorite book.\",
   \"Grimms' Fairy Tales\": \"Masterpiece.\",
   \"Pride and Prejudice\": \"Very enjoyable.\",
   \"The Adventures of Sherlock Holmes\": \"Eye lyked it alot.\",
   }"),
 String::from(
  "{
   \"Adventures of Huckleberry Finn\": \"My favorite book.\",
   \"Grimms' Fairy Tales\": \"Masterpiece.\",
   \"Pride and Prejudice\": \"Very enjoyable.\",
   \"The Adventures of Sherlock Holmes\": \"Eye lyked it alot.\",
   }")
];
let prev  : Option<BlockHash> = Some([1; BLOCKHASHLEN]);
let nonce : u64 = 3;
let timestamp = std::time::Duration::from_secs(1524885322).as_secs();
let block : BlockchainBlock<String> = BlockchainBlock::new(prev, &book_reviews, timestamp, nonce);
   
println!("\n{:?}\n", &block);
assert_eq!(block.curr_hash, [220, 149, 236, 219, 173, 29, 131, 71, 35, 245, 97, 228, 58, 247, 45, 86, 197, 104, 26, 236, 232, 98, 144, 4, 220, 210, 177, 17, 235, 113, 214, 18]);

pub fn check_value_inblock(&self, data: &T, position: usize) -> bool

Check data is inside the block. Calculate a merkle root and compare it with the one stored in the block.

Description

• data - Data to be checked.
• position - Position of the data in the original array. 0 <= pos < block.data.len()

Examples

Example checking String is inside the Block

extern crate blockchainblock;
use crate::blockchainblock::*;    
let string_check = String::from(
    "{\"The Adventures of Sherlock Holmes\",\"Grimms' Fairy Tales\"}"
);
let book_reviews = [
    String::from(
        "{\"Adventures of Huckleberry Finn\",\"Grimms' Fairy Tales\"}"
    ),
    String::from(
        "{\"Eloquent JavaScript, Second Edition\",\"Learning JavaScript Design Patterns\"}"
    ),
    string_check.clone(),
    String::from(
        "{\"Speaking JavaScript\",\"Programming JavaScript Applications\"}"
    ),
];
 
let prev  : Option<BlockHash> = None;
let nonce : u64 = 1;
let timestamp = std::time::Duration::from_secs(1524885322).as_secs();
let block : BlockchainBlock<String> = BlockchainBlock::new(prev, &book_reviews, timestamp, nonce);
    
println!("\n{:?}\n", &block);
assert_eq!(block.check_value_inblock(&string_check,2), true);

Trait Implementations

impl<'a, T> Hashable for BlockchainBlock<'a, T> where
    T: Byteable, 

fn calculate_hash(&mut self)

Calculate the hash of an object and store the result in their internal structures

impl<'a, T: Debug> Debug for BlockchainBlock<'a, T>

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.