Struct ProposedBatch 

pub struct ProposedBatch { /* private fields */ }

A proposed batch of transactions with all necessary data to validate it.

See ProposedBatch::new for what a proposed batch expects and guarantees.

This type is fairly large, so consider boxing it.

Implementations

impl ProposedBatch

pub fn new( transactions: Vec<Arc<ProvenTransaction>>, reference_block_header: BlockHeader, partial_blockchain: PartialBlockchain, unauthenticated_note_proofs: BTreeMap<NoteId, NoteInclusionProof>, ) -> Result<Self, ProposedBatchError>

Creates a new ProposedBatch from the provided parts.

Inputs

• The given transactions must be correctly ordered. That is, if two transactions A and B update the same account in this order, meaning A’s initial account state commitment matches the account state before any transactions are executed and B’s initial account state commitment matches the final account state commitment of A, then A must come before B.
• The partial blockchain’s hashed peaks must match the reference block’s chain_commitment and it must contain all block headers:
  • that are referenced by note inclusion proofs in unauthenticated_note_proofs.
  • that are referenced by a transaction in the batch.
• The unauthenticated_note_proofs should contain NoteInclusionProofs for any unauthenticated note consumed by the transaction’s in the batch which can be authenticated. This means it is not required that every unauthenticated note has an entry in this map for two reasons.
  • Unauthenticated note authentication can be delayed to the block kernel.
  • Another transaction in the batch creates an output note matching an unauthenticated input note, in which case inclusion in the chain does not need to be proven.
• The reference block of a batch must satisfy the following requirement: Its block number must be greater or equal to the highest block number referenced by any transaction. This is not verified explicitly, but will implicitly cause an error during the validation that each reference block of a transaction is in the partial blockchain.

Errors

Returns an error if:

• The number of input notes exceeds MAX_INPUT_NOTES_PER_BATCH.
  • Note that unauthenticated notes that are created in the same batch do not count. Any other input notes, unauthenticated or not, do count.
• The number of output notes exceeds MAX_OUTPUT_NOTES_PER_BATCH.
  • Note that output notes that are consumed in the same batch as unauthenticated input notes do not count.
• Any note is consumed more than once.
• Any note is created more than once.
• The number of account updates exceeds MAX_ACCOUNTS_PER_BATCH.
  • Note that any number of transactions against the same account count as one update.
• The partial blockchains chain length does not match the block header’s block number. This means the partial blockchain should not contain the block header itself as it is added to the MMR in the batch kernel.
• The partial blockchains hashed peaks do not match the block header’s chain commitment.
• The reference block of any transaction is not in the partial blockchain.
• The note inclusion proof for an unauthenticated note fails to verify.
• The block referenced by a note inclusion proof for an unauthenticated note is missing from the partial blockchain.
• The transactions in the proposed batch which update the same account are not correctly ordered.
• The provided list of transactions is empty. An empty batch is pointless and would potentially result in the same BatchId for two empty batches which would mean batch IDs are no longer unique.
• There are duplicate transactions.
• If any transaction’s expiration block number is less than or equal to the batch’s reference block.

pub fn transactions(&self) -> &[Arc<ProvenTransaction>]

Returns a slice of the ProvenTransactions in the batch.

pub fn transaction_headers(&self) -> OrderedTransactionHeaders

Returns the ordered set of transactions in the batch.

pub fn account_updates(&self) -> &BTreeMap<AccountId, BatchAccountUpdate>

Returns the map of account IDs mapped to their BatchAccountUpdates.

If an account was updated by multiple transactions, the BatchAccountUpdate is the result of merging the individual updates.

For example, suppose an account’s state before this batch is A and the batch contains two transactions that updated it. Applying the first transaction results in intermediate state B, and applying the second one results in state C. Then the returned update represents the state transition from A to C.

pub fn id(&self) -> BatchId

The ID of this batch. See BatchId for details on how it is computed.

pub fn batch_expiration_block_num(&self) -> BlockNumber

Returns the block number at which the batch will expire.

pub fn input_notes(&self) -> &InputNotes<InputNoteCommitment>

Returns the InputNotes of this batch.

pub fn output_notes(&self) -> &[OutputNote]

Returns the output notes of the batch.

This is the aggregation of all output notes by the transactions in the batch, except the ones that were consumed within the batch itself.

pub fn into_parts( self, ) -> (Vec<Arc<ProvenTransaction>>, BlockHeader, PartialBlockchain, BTreeMap<NoteId, NoteInclusionProof>, BatchId, BTreeMap<AccountId, BatchAccountUpdate>, InputNotes<InputNoteCommitment>, Vec<OutputNote>, BlockNumber)

Consumes the proposed batch and returns its underlying parts.

Trait Implementations

impl Clone for ProposedBatch

fn clone(&self) -> ProposedBatch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProposedBatch

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

Formats the value using the given formatter.

impl Deserializable for ProposedBatch

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 ProposedBatch

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.