Skip to main content

Block and Block Header

The data structures for block and block headers are

pub struct Block {
/// Block Header
pub header: BlockHeader,
/// Headers of chunk in the block
pub chunks: Vec<ShardChunkHeader>,
/// Challenges, but they are not used today
pub challenges: Challenges,

/// Data to confirm the correctness of randomness beacon output
pub vrf_value: [u8; 32],
pub vrf_proof: [u8; 64],
}
pub struct BlockHeader {
pub prev_hash: CryptoHash,

/// Inner part of the block header that gets hashed, split into two parts, one that is sent
/// to light clients, and the rest
pub inner_lite: BlockHeaderInnerLite,
pub inner_rest: BlockHeaderInnerRest,

/// Signature of the block producer.
pub signature: Signature,

/// Cached value of hash for this block.
pub hash: CryptoHash,
}

where BlockHeaderInnerLite and BlockHeaderInnerRest are

pub struct BlockHeaderInnerLite {
/// Height of this block.
pub height: u64,
/// Epoch start hash of this block's epoch.
/// Used for retrieving validator information
pub epoch_id: EpochId,
pub next_epoch_id: EpochId,
/// Root hash of the state at the previous block.
pub prev_state_root: CryptoHash,
/// Root of the outcomes of transactions and receipts.
pub outcome_root: CryptoHash,
/// Timestamp at which the block was built (number of non-leap-nanoseconds since January 1, 1970 0:00:00 UTC).
pub timestamp: u64,
/// Hash of the next epoch block producers set
pub next_bp_hash: CryptoHash,
/// Merkle root of block hashes up to the current block.
pub block_merkle_root: CryptoHash,
}
pub struct BlockHeaderInnerRest {
/// Root hash of the chunk receipts in the given block.
pub chunk_receipts_root: CryptoHash,
/// Root hash of the chunk headers in the given block.
pub chunk_headers_root: CryptoHash,
/// Root hash of the chunk transactions in the given block.
pub chunk_tx_root: CryptoHash,
/// Root hash of the challenges in the given block.
pub challenges_root: CryptoHash,
/// The output of the randomness beacon
pub random_value: CryptoHash,
/// Validator proposals.
pub validator_proposals: Vec<ValidatorStake>,
/// Mask for new chunks included in the block
pub chunk_mask: Vec<bool>,
/// Gas price. Same for all chunks
pub gas_price: u128,
/// Total supply of tokens in the system
pub total_supply: u128,
/// List of challenges result from previous block.
pub challenges_result: ChallengesResult,

/// Last block that has full BFT finality
pub last_final_block: CryptoHash,
/// Last block that has doomslug finality
pub last_ds_final_block: CryptoHash,

/// The ordinal of the Block on the Canonical Chain
pub block_ordinal: u64,

/// All the approvals included in this block
pub approvals: Vec<Option<Signature>>,

/// Latest protocol version that this block producer has.
pub latest_protocol_version: u32,
}

Here CryptoHash is a 32-byte hash and EpochId is a 32-byte identifier.

Block Hash

The hash of a block is computed by

sha256(concat(
sha256(concat(
sha256(borsh(inner_lite)),
sha256(borsh(inner_rest))
)),
prev_hash
))

Chunk and Chunk Header

The data structures for chunk and chunk header are

pub struct ShardChunkHeader {
pub inner: ShardChunkHeaderInner,

pub height_included: BlockHeight,

/// Signature of the chunk producer.
pub signature: Signature,

pub hash: ChunkHash,
}
pub struct ShardChunk {
pub chunk_hash: ChunkHash,
pub header: ShardChunkHeader,
pub transactions: Vec<SignedTransaction>,
pub receipts: Vec<Receipt>,
}

where ShardChunkHeaderInner is

pub struct ShardChunkHeaderInner {
/// Previous block hash.
pub prev_block_hash: CryptoHash,
pub prev_state_root: CryptoHash,
/// Root of the outcomes from execution transactions and results.
pub outcome_root: CryptoHash,
pub encoded_merkle_root: CryptoHash,
pub encoded_length: u64,
pub height_created: u64,
/// Shard index.
pub shard_id: u64,
/// Gas used in this chunk.
pub gas_used: u64,
/// Gas limit voted by validators.
pub gas_limit: u64,
/// Total balance burnt in previous chunk
pub balance_burnt: u128,
/// Outgoing receipts merkle root.
pub outgoing_receipts_root: CryptoHash,
/// Tx merkle root.
pub tx_root: CryptoHash,
/// Validator proposals.
pub validator_proposals: Vec<ValidatorStake>,
}

Chunk Hash

Chunk hash is computed by

sha256(
concat(
sha256(borsh(inner)),
encoded_merkle_root
)
)