Struct BlockChanges 

pub struct BlockChanges {
    pub extractor: String,
    pub chain: Chain,
    pub block: Block,
    pub finalized_block_height: u64,
    pub revert: bool,
    pub new_tokens: HashMap<Bytes, Token>,
    pub txs_with_update: Vec<TxWithChanges>,
    pub block_contract_changes: Vec<TxWithContractChanges>,
    pub trace_results: Vec<TracedEntryPoint>,
    pub partial_block_index: Option<u32>,
}

Fields

extractor: String

chain: Chain

block: Block

finalized_block_height: u64

revert: bool

new_tokens: HashMap<Bytes, Token>

txs_with_update: Vec<TxWithChanges>

Vec of updates at this block, aggregated by tx and sorted by tx index in ascending order

block_contract_changes: Vec<TxWithContractChanges>

trace_results: Vec<TracedEntryPoint>

Required here so that it is part of the reorg buffer and thus inserted into storage once finalized. Populated by the DynamicContractIndexer

partial_block_index: Option<u32>

The index of the partial block. None if it’s a full block.

Implementations

impl BlockChanges

pub fn new( extractor: String, chain: Chain, block: Block, finalized_block_height: u64, revert: bool, txs_with_update: Vec<TxWithChanges>, block_contract_changes: Vec<TxWithContractChanges>, ) -> BlockChanges

pub fn into_aggregated( self, db_committed_block_height: Option<u64>, ) -> Result<BlockAggregatedChanges, MergeError>

Aggregates component and account updates.

This function aggregates all protocol updates into a BlockAggregatedChanges object. This new object should have all individual changes merged into only one final/compacted change per component and account. This means there is only one state delta and component balance per component, and one account delta and account balance per account. DCI trace results are also aggregated into a result per entry point.

Note - all non-protocol specific data in the BlockChanges object are lost during aggregation. This means block_storage_changes is dropped.

Errors

This returns a MergeError if there was a problem during merge.

pub fn protocol_components(&self) -> Vec<ProtocolComponent>

pub fn is_partial_block(&self) -> bool

Returns true if the block is a partial block.

pub fn set_partial_block_index(&mut self, index: Option<u32>)

Sets the partial block index.

pub fn normalize_block_hash(&mut self)

Sets every transaction’s block_hash in txs_with_update and block_contract_changes to this block’s hash. Used after merging partials so all txs refer to the same block (e.g. the final block hash).

pub fn merge_partial( self, other: BlockChanges, ) -> Result<BlockChanges, MergeError>

Merges another partial block into this one, preserving later changes.

The partial block with the higher index represents later changes and takes precedence. Merges new_tokens, txs_with_update (sorted by index), block_contract_changes, and trace_results. When both blocks have the same token address, the token from the block with the higher partial index is kept.

Works regardless of merge order: partial_0.merge_partial(partial_1) and partial_1.merge_partial(partial_0) produce equivalent results.

Errors

• Non-partial block: Either block is not marked as partial
• Extractor mismatch: Blocks from different extractors
• Chain mismatch: Blocks from different chains
• Block mismatch: Different block numbers (hash may differ for temp vs final partial)
• Revert mismatch: Different revert status

Trait Implementations

impl BlockScoped for BlockChanges

fn block(&self) -> Block

impl Clone for BlockChanges

fn clone(&self) -> BlockChanges

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockChanges

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

Formats the value using the given formatter.

impl DeepSizeOf for BlockChanges

fn deep_size_of_children(&self, context: &mut Context) -> usize

Returns an estimation of the heap-managed storage of this object. This does not include the size of the object itself.

fn deep_size_of(&self) -> usize

Returns an estimation of a total size of memory owned by the object, including heap-managed storage.

impl Default for BlockChanges

fn default() -> BlockChanges

Returns the “default value” for a type.

impl PartialEq for BlockChanges

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for BlockChanges