Struct TempoPoolUpdates 

pub struct TempoPoolUpdates {

    pub revoked_keys: RevokedKeys,
    pub key_authorization_target_changes: RevokedKeys,
    pub spending_limit_changes: SpendingLimitUpdates,
    pub validator_token_changes: AddressMap<Address>,
    pub user_token_changes: AddressSet,
    pub blacklist_additions: Vec<(u64, Address)>,
    pub whitelist_removals: Vec<(u64, Address)>,
    pub pause_events: Vec<(Address, bool)>,
    pub transfer_policy_updates: AddressSet,
    pub quote_token_updates: AddressSet,
    pub fee_balance_changes: AddressMap<AddressSet>,
    pub spending_limit_spends: SpendingLimitUpdates,
    pub key_authorization_witness_burns: AddressMap<B256Set>,
}

Aggregated block-level invalidation events for the transaction pool.

Collects all invalidation events from a block into a single structure, allowing efficient batch processing of pool updates.

Fields

revoked_keys: RevokedKeys

Revoked keychain keys. Indexed by account for efficient lookup.

key_authorization_target_changes: RevokedKeys

Inline key authorization target-key status changes.

A pending inline authorization for (account, key) is stale once another transaction authorizes, admin-authorizes, or revokes that same key.

spending_limit_changes: SpendingLimitUpdates

Spending limit changes. When a spending limit changes, transactions from that key paying with that token may become unexecutable if the new limit is below their value. Indexed by account for efficient lookup.

validator_token_changes: AddressMap<Address>

Validator token preference changes: validator to new_token (last-write-wins). Uses AddressMap to deduplicate by validator, preventing resource amplification when a validator emits multiple ValidatorTokenSet events in the same block.

user_token_changes: AddressSet

User token preference changes. When a user changes their fee token preference via setUserToken(), pending transactions from that user that don’t have an explicit fee_token set may now resolve to a different token at execution time, causing fee payment failures. Uses a set since a user can emit multiple events in the same block; we only need to process each user once. No cleanup needed as this is ephemeral per-block data.

blacklist_additions: Vec<(u64, Address)>

TIP403 blacklist additions: (policy_id, account).

whitelist_removals: Vec<(u64, Address)>

TIP403 whitelist removals: (policy_id, account).

pause_events: Vec<(Address, bool)>

Fee token pause state changes: (token, is_paused).

transfer_policy_updates: AddressSet

Tokens whose transfer policy was changed via changeTransferPolicyId(). Pending transactions using these tokens as fee tokens need to be re-validated because the new policy may forbid the fee payer or fee manager.

quote_token_updates: AddressSet

Tokens whose quoteToken was updated via completeQuoteTokenUpdate(). Pending transactions paying in these tokens need to be re-validated because the new quote token may invalidate the old route.

fee_balance_changes: AddressMap<AddressSet>

Fee token balance changes keyed by token.

We only track the debited from account from TIP20 Transfer logs because credits to the to account cannot make an already-admitted transaction newly invalid.

spending_limit_spends: SpendingLimitUpdates

Spending-limit spends emitted by the account keychain during execution.

We record the exact (account, key_id, token) triples emitted by AccessKeySpend events. During eviction, the pool re-reads the remaining limit from state for these triples and compares against pending tx fee costs. This keeps maintenance aligned with the runtime’s actual spending-limit decrements instead of inferring them from the mined transaction body.

key_authorization_witness_burns: AddressMap<B256Set>

TIP-1053 key-authorization witness burns.

Pending AA transactions carrying the same (account, witness) key authorization are no longer executable once the account explicitly burns that witness.

Implementations

impl TempoPoolUpdates

pub fn new() -> Self

Creates a new empty TempoPoolUpdates.

pub fn is_empty(&self) -> bool

Returns true if there are no updates to process.

pub fn from_chain(chain: &Chain<TempoPrimitives>) -> Self

Extracts pool updates from a committed chain segment.

Parses receipts for relevant events (key revocations, validator token changes, blacklist additions, pause events).

pub fn has_invalidation_events(&self) -> bool

Returns true if there are any invalidation events that require scanning the pool.

pub fn has_keychain_subject_updates(&self) -> bool

Returns true if updates may invalidate keychain-signature transactions.

Trait Implementations

impl Debug for TempoPoolUpdates

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

Formats the value using the given formatter.

impl Default for TempoPoolUpdates

fn default() -> TempoPoolUpdates

Returns the “default value” for a type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 472 bytes