Struct luk_chain::Block

pub struct Block<T> {
    pub events: Vec<Event<T>>,
    pub prev_hash: Option<String>,
    pub hash: Option<String>,
    pub nonce: u128,
    pub created_at: Duration,
}

Encapsulation of groups of events mined and stored on BlockChain

Fields

events: Vec<Event<T>>

Events contained within Block

prev_hash: Option<String>

Hash of preceding Block in BlockChain

hash: Option<String>

Hash of Block

nonce: u128

Random value for each instance

created_at: Duration

Time Block was created at since Epoch

Implementations

impl<T: BlockChainBase> Block<T>

pub fn new(prev_hash: Option<String>) -> Self

Creates a new Block

pub fn add_events(&mut self, events: Vec<Event<T>>)

Adds multiple events to Block

pub fn set_nonce(&mut self, nonce: u128)

Sets the nonce of the Block

pub fn calculate_hash(&self) -> String

Calculates the hash of a given Block

pub fn update_hash(&mut self)

Updates the hash of a given Block

pub fn verify_hash(&self) -> bool

Verifies the hash of the Block

pub fn add_event(&mut self, event: Event<T>)

Adds a event to a Block

pub fn get_event_count(&self) -> usize

Gets the number of events in a given Block

pub fn execute(&self, users: &HashMap<u128, RsaPublicKey>) -> bool

Goes through each Event in Block, checks validity and information each contains

Trait Implementations

impl<T: Clone> Clone for Block<T>

fn clone(&self) -> Block<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Block<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Block<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq<Block<T>> for Block<T>

fn eq(&self, other: &Block<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Block<T>) -> bool

This method tests for !=.

impl<T> Serialize for Block<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for Block<T>