Struct EthBlockHeaderChip 

pub struct EthBlockHeaderChip<'chip, F: Field> {
    pub rlp: RlpChip<'chip, F>,
    pub max_extra_data_bytes: usize,
}

Fields

rlp: RlpChip<'chip, F>

max_extra_data_bytes: usize

Implementations

impl<'chip, F: Field> EthBlockHeaderChip<'chip, F>

pub fn new(rlp: RlpChip<'chip, F>, max_extra_data_bytes: usize) -> Self

pub fn new_from_network(rlp: RlpChip<'chip, F>, chain: Chain) -> Self

pub fn gate(&self) -> &GateChip<F>

pub fn range(&self) -> &RangeChip<F>

pub fn rlc(&self) -> &RlcChip<F>

pub fn rlp(&self) -> &RlpChip<'_, F>

pub fn decompose_block_header_phase0( &self, ctx: &mut Context<F>, keccak: &KeccakChip<F>, block_header: &[AssignedValue<F>], ) -> EthBlockHeaderWitness<F>

Takes the variable length RLP encoded block header, padded with 0s to the maximum possible block header RLP length, and outputs the decomposition into block header fields.

This function will range check that block_header consists of bytes (8 bits).

In addition, the keccak block hash of the block is calculated.

This is the preparation step that computes the witnesses. This MUST be done in FirstPhase. The accompanying decompose_block_header_phase1 must be called in SecondPhase to constrain the RLCs associated to the RLP decoding.

pub fn decompose_block_header_phase1( &self, ctx: RlcContextPair<'_, F>, witness: EthBlockHeaderWitness<F>, ) -> EthBlockHeaderTrace<F>

Takes the variable length RLP encoded block header, padded with 0s to the maximum possible block header RLP length, and outputs the decomposition into block header fields.

In addition, the keccak block hash of the block is calculated.

This is the finalization step that constrains RLC concatenations. This should be called after decompose_block_header_phase0. This MUST be done in SecondPhase.

pub fn decompose_block_headers_phase0( &self, builder: &mut RlcCircuitBuilder<F>, keccak: &KeccakChip<F>, block_headers: Vec<Vec<AssignedValue<F>>>, ) -> Vec<EthBlockHeaderWitness<F>>

Makes multiple calls to decompose_block_header_phase0 in parallel threads. Should be called in FirstPhase.

pub fn decompose_block_headers_phase1( &self, builder: &mut RlcCircuitBuilder<F>, witnesses: Vec<EthBlockHeaderWitness<F>>, ) -> Vec<EthBlockHeaderTrace<F>>

Makes multiple calls to decompose_block_header_phase1 in parallel threads. Should be called in SecondPhase.

pub fn decompose_block_header_chain_phase0( &self, builder: &mut RlcCircuitBuilder<F>, keccak: &KeccakChip<F>, block_headers: Vec<Vec<AssignedValue<F>>>, ) -> Vec<EthBlockHeaderWitness<F>>

Takes a list of (purported) RLP encoded block headers and decomposes each header into it’s fields. headers[0] is the earliest block.

This is the preparation step that computes the witnesses. This MUST be done in FirstPhase. The accompanying decompose_block_header_chain_phase1 must be called in SecondPhase to constrain the RLCs associated to the RLP decoding.

pub fn decompose_block_header_chain_phase1( &self, builder: &mut RlcCircuitBuilder<F>, witnesses: Vec<EthBlockHeaderWitness<F>>, num_blocks_minus_one: Option<(AssignedValue<F>, Vec<AssignedValue<F>>)>, ) -> Vec<EthBlockHeaderTrace<F>>

Takes a list of 2^max_depth (purported) RLP encoded block headers. Decomposes each header into it’s fields. headers[0] is the earliest block

• If num_blocks_minus_one = (num_blocks_minus_one, indicator) is not None, then the circuit checks that the first num_blocks := num_blocks_minus_one + 1 block headers form a chain: meaning that the parent hash of block i + 1 equals the hash of block i.
• indicator is a vector with index i equal to i == num_blocks - 1 ? 1 : 0.
• Otherwise if num_blocks is None, the circuit checks that all headers form a hash chain.

Assumes that 0 <= num_blocks_minus_one < 2^max_depth.

This is the finalization step that constrains RLC concatenations. In this step the hash chain is actually constrained. This should be called after decompose_block_header_chain_phase0. This MUST be done in SecondPhase.