Struct Block 

pub struct Block {
    pub offset: u64,
    pub size: u64,
    pub hash_prev: U256,
    pub validator: U256,
    pub nonce: U256,
    pub hash: U256,
}

Basic structure for block.

Fields

offset: u64

size: u64

hash_prev: U256

validator: U256

nonce: U256

hash: U256

Implementations

impl Block

pub fn new( offset: u64, size: u64, hash_prev: U256, validator: U256, nonce: U256, hash: U256, ) -> Self

New block.

pub fn validate( &self, transactions: &[Transaction], block_info_prev: &BlockInfo, complexity: usize, state: &State, senders: &[U256], ) -> UqoinResult<()>

Full validation of the block that includes transactions, info of the previous block, complexity, state between this block and the previous one.

pub fn build( block_info_prev: &BlockInfo, validator: U256, transactions: &[Transaction], nonce: U256, complexity: usize, state: &State, senders: &[U256], ) -> UqoinResult<Self>

Build a new block for the transactions. It validates the final hash.

pub fn validate_coins( transactions: &[Transaction], state: &State, senders: &[U256], ) -> UqoinResult<()>

👎Deprecated since 0.1.0:

use groups and check_unique instead

Validate coins. The checks:

1. All coins are unique.
2. All transactions are valid (see Transaction::validate_coins()).

pub fn validate_transactions( transactions: &[Transaction], validator: &U256, state: &State, senders: &[U256], ) -> UqoinResult<()>

Validate transactions. The checks:

1. All coins are valid (see validate_coins).
2. All transactions can be groupped into groups and extensions.
3. Sender of each extension is the validator.
4. Values of groups and extensions correspond each other. Each group or extension has valid structure after the groupping because they cannot be created invalid due to inner validation.

pub fn validate_hash_complexity( hash: &U256, size: usize, complexity: usize, ) -> UqoinResult<()>

Validate hash for the certain complexity.

pub fn calc_msg( block_hash_prev: &U256, validator: &U256, transactions: &[Transaction], ) -> U256

calculate block message as hash of the important content.

pub fn calc_hash(msg: &U256, nonce: &U256) -> U256

Calculate block hash from message and nonce.

pub fn is_hash_valid(hash_bytes: &[u8], limit_hash_bytes: &[u8]) -> bool

Chech if the hash corresponds to the necessary size.

pub fn mine<R: Rng>( rng: &mut R, block_hash_prev: &U256, validator: &U256, transactions: &[Transaction], complexity: usize, iterations: Option<usize>, ) -> Option<[u8; 32]>

Find correct nonce bytes to mine the block.

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Block

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Block

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

where __S: Serializer,

Serialize this value into the given Serde serializer.