Struct ProposedBlock

pub struct ProposedBlock { /* private fields */ }

A proposed block with many, but not all constraints of a ProvenBlock enforced.

See ProposedBlock::new_at for details on the checks.

Implementations

impl ProposedBlock

pub fn new_at( block_inputs: BlockInputs, batches: Vec<ProvenBatch>, timestamp: u32, ) -> Result<Self, ProposedBlockError>

Creates a new proposed block from the provided BlockInputs, transaction batches and timestamp.

This checks most of the constraints of a block and computes most of the data structure updates except for the more expensive tree updates (nullifier, account and chain commitment).

Errors

Returns an error if any of the following conditions are met.

Batches

• The number of batches exceeds MAX_BATCHES_PER_BLOCK.
• There are duplicate batches, i.e. they have the same BatchId.
• The expiration block number of any batch is less than the block number of the currently proposed block.

Chain

• The length of the ChainMmr in the block inputs is not equal to the previous block header in the block inputs.
• The ChainMmr’s chain commitment is not equal to the BlockHeader::chain_commitment of the previous block header.

Notes

Note that, in the following, the set of authenticated notes includes unauthenticated notes that have been authenticated.

• The union of all input notes across all batches contain duplicates.
• The union of all output notes across all batches contain duplicates.
• There is an unauthenticated input note and an output note with the same note ID but their note commitments are different (i.e. their metadata is different).
• There is a note inclusion proof for an unauthenticated note whose referenced block is not in the ChainMmr.
• The note inclusion proof for an unauthenticated is invalid.
• There are any unauthenticated notes for which no note inclusion proof is provided.
• A NullifierWitness is missing for an authenticated note.
• If the NullifierWitness for an authenticated note proves that the note was already consumed.

Accounts

• An AccountWitness is missing for an account updated by a batch.
• Any two batches update the same account from the same state. For example, if batch 1 updates some account from state A to B and batch 2 updates it from A to F, then those batches conflict as they both start from the same initial state but produce a fork in the account’s state.
• Account updates from different batches cannot be brought in a contiguous order. For example, if a batch 1 updates an account from state A to C, and a batch 2 updates it from D to F, then the state transition from C to D is missing. Note that this does not mean, that batches must be provided in an order where account updates chain together in the order of the batches, which would generally be an impossible requirement to fulfill.
• Account updates cannot be merged, i.e. if AccountUpdateDetails::merge fails on the updates from two batches.

Time

• The given timestamp does not increase monotonically compared to the previous block header’ timestamp.

pub fn new( block_inputs: BlockInputs, batches: Vec<ProvenBatch>, ) -> Result<Self, ProposedBlockError>

Creates a new proposed block from the provided BlockInputs and transaction batches.

Equivalent to ProposedBlock::new_at except that the timestamp of the proposed block is set to the current system time or the previous block header’s timestamp + 1, whichever is greater. This guarantees that the timestamp increases monotonically.

See the ProposedBlock::new_at for details on errors and other constraints.

pub fn affected_accounts( &self, ) -> impl Iterator<Item = (TransactionId, AccountId)> + '_

Returns an iterator over all transactions which affected accounts in the block with corresponding account IDs.

pub fn block_num(&self) -> BlockNumber

Returns the block number of this proposed block.

pub fn batches(&self) -> &[ProvenBatch]

Returns a reference to the slice of batches in this block.

pub fn created_nullifiers(&self) -> &BTreeMap<Nullifier, NullifierWitness>

Returns the map of nullifiers to their proofs from the proposed block.

pub fn prev_block_header(&self) -> &BlockHeader

Returns a reference to the previous block header that this block builds on top of.

pub fn chain_mmr(&self) -> &ChainMmr

Returns the ChainMmr that this block contains.

pub fn updated_accounts(&self) -> &[(AccountId, AccountUpdateWitness)]

Returns a reference to the slice of accounts updated in this block.

pub fn timestamp(&self) -> u32

Returns the timestamp of this block.

pub fn output_note_batches(&self) -> &[OutputNoteBatch]

Returns a slice of the OutputNoteBatch of each batch in this block.

pub fn into_parts( self, ) -> (Vec<ProvenBatch>, Vec<(AccountId, AccountUpdateWitness)>, Vec<OutputNoteBatch>, BTreeMap<Nullifier, NullifierWitness>, ChainMmr, BlockHeader)

Consumes self and returns the non-Copy parts of the block.

Trait Implementations

impl Clone for ProposedBlock

fn clone(&self) -> ProposedBlock

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProposedBlock

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

Formats the value using the given formatter.

impl Deserializable for ProposedBlock

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

impl Serializable for ProposedBlock

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.