Enum near_chain::Block

pub enum Block {
    BlockV1(Box<BlockV1, Global>),
    BlockV2(Box<BlockV2, Global>),
}

Versioned Block data structure. For each next version, document what are the changes between versions.

Variants

BlockV1(Box<BlockV1, Global>)

Tuple Fields of BlockV1

0: Box<BlockV1, Global>

BlockV2(Box<BlockV2, Global>)

Tuple Fields of BlockV2

0: Box<BlockV2, Global>

Implementations

impl Block

pub fn genesis(
    genesis_protocol_version: u32,
    chunks: Vec<ShardChunkHeader, Global>,
    timestamp: DateTime<Utc>,
    height: u64,
    initial_gas_price: u128,
    initial_total_supply: u128,
    next_bp_hash: CryptoHash
) -> Block

Returns genesis block for given genesis date and state root.

pub fn produce(
    protocol_version: u32,
    prev: &BlockHeader,
    height: u64,
    chunks: Vec<ShardChunkHeader, Global>,
    epoch_id: EpochId,
    next_epoch_id: EpochId,
    approvals: Vec<Option<Signature>, Global>,
    gas_price_adjustment_rate: Ratio<isize>,
    min_gas_price: u128,
    max_gas_price: u128,
    minted_amount: Option<u128>,
    challenges_result: Vec<SlashedValidator, Global>,
    challenges: Vec<Challenge, Global>,
    signer: &dyn ValidatorSigner,
    next_bp_hash: CryptoHash,
    block_merkle_root: CryptoHash
) -> Block

Produces new block from header of previous block, current state root and set of transactions.

pub fn verify_gas_price(
    &self,
    prev_gas_price: u128,
    min_gas_price: u128,
    max_gas_price: u128,
    gas_price_adjustment_rate: Ratio<isize>
) -> bool

pub fn compute_new_gas_price(
    prev_gas_price: u128,
    gas_used: u64,
    gas_limit: u64,
    gas_price_adjustment_rate: Ratio<isize>,
    min_gas_price: u128,
    max_gas_price: u128
) -> u128

pub fn compute_state_root<'a, T>(chunks: T) -> CryptoHash where
    T: IntoIterator<Item = &'a ShardChunkHeader>, 

pub fn compute_chunk_receipts_root<'a, T>(chunks: T) -> CryptoHash where
    T: IntoIterator<Item = &'a ShardChunkHeader>, 

pub fn compute_chunk_headers_root<'a, T>(
    chunks: T
) -> (CryptoHash, Vec<Vec<MerklePathItem, Global>, Global>) where
    T: IntoIterator<Item = &'a ShardChunkHeader>, 

pub fn compute_chunk_tx_root<'a, T>(chunks: T) -> CryptoHash where
    T: IntoIterator<Item = &'a ShardChunkHeader>, 

pub fn compute_outcome_root<'a, T>(chunks: T) -> CryptoHash where
    T: IntoIterator<Item = &'a ShardChunkHeader>, 

pub fn compute_challenges_root(
    challenges: &Vec<Challenge, Global>
) -> CryptoHash

pub fn compute_gas_used<'a, T>(chunks: T, height: u64) -> u64 where
    T: IntoIterator<Item = &'a ShardChunkHeader>, 

pub fn compute_gas_limit<'a, T>(chunks: T, height: u64) -> u64 where
    T: IntoIterator<Item = &'a ShardChunkHeader>, 

pub fn validate_chunk_header_proof(
    chunk: &ShardChunkHeader,
    chunk_root: &CryptoHash,
    merkle_path: &Vec<MerklePathItem, Global>
) -> bool

pub fn header(&self) -> &BlockHeader

pub fn chunks(&self) -> ChunksCollection<'_>

pub fn challenges(&self) -> &Vec<Challenge, Global>

pub fn vrf_value(&self) -> &Value

pub fn vrf_proof(&self) -> &Proof

pub fn hash(&self) -> &CryptoHash

pub fn check_validity(&self) -> Result<(), BlockValidityError>

Checks that block content matches block hash, with the possible exception of chunk signatures

impl Block

pub fn mut_header(&mut self) -> &mut BlockHeader

pub fn set_chunks(&mut self, chunks: Vec<ShardChunkHeader, Global>)

pub fn empty_with_epoch(
    prev: &Block,
    height: u64,
    epoch_id: EpochId,
    next_epoch_id: EpochId,
    next_bp_hash: CryptoHash,
    signer: &dyn ValidatorSigner,
    block_merkle_tree: &mut PartialMerkleTree
) -> Block

pub fn empty_with_height(
    prev: &Block,
    height: u64,
    signer: &dyn ValidatorSigner
) -> Block

pub fn empty_with_height_and_block_merkle_tree(
    prev: &Block,
    height: u64,
    signer: &dyn ValidatorSigner,
    block_merkle_tree: &mut PartialMerkleTree
) -> Block

pub fn empty_with_block_merkle_tree(
    prev: &Block,
    signer: &dyn ValidatorSigner,
    block_merkle_tree: &mut PartialMerkleTree
) -> Block

pub fn empty(prev: &Block, signer: &dyn ValidatorSigner) -> Block

pub fn empty_with_approvals(
    prev: &Block,
    height: u64,
    epoch_id: EpochId,
    next_epoch_id: EpochId,
    approvals: Vec<Option<Signature>, Global>,
    signer: &dyn ValidatorSigner,
    next_bp_hash: CryptoHash,
    block_merkle_root: CryptoHash
) -> Block

This is not suppose to be used outside of chain tests, because this doesn’t refer to correct chunks. Done because chain tests don’t have a good way to store chunks right now.

Trait Implementations

impl BorshDeserialize for Block where
    Box<BlockV1, Global>: BorshDeserialize,
    Box<BlockV2, Global>: BorshDeserialize, 

pub fn deserialize(buf: &mut &[u8]) -> Result<Block, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

impl BorshSerialize for Block where
    Box<BlockV1, Global>: BorshSerialize,
    Box<BlockV2, Global>: BorshSerialize, 

pub fn serialize<W>(&self, writer: &mut W) -> Result<(), Error> where
    W: Write, 

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

impl Clone for Block

pub fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl PartialEq<Block> for Block

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

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

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

This method tests for !=.

impl Eq for Block

impl StructuralEq for Block

impl StructuralPartialEq for Block