Struct BloomState 

pub struct BloomState { /* private fields */ }

State for managing Bloom filter announcements.

Tracks local filter state and what needs to be sent to peers.

Implementations

impl BloomState

pub fn new(own_node_addr: NodeAddr) -> Self

Create new Bloom state for a node.

pub fn leaf_only(own_node_addr: NodeAddr) -> Self

Create state for a leaf-only node.

pub fn own_node_addr(&self) -> &NodeAddr

Get the node’s own ID.

pub fn is_leaf_only(&self) -> bool

Check if this is a leaf-only node.

pub fn sequence(&self) -> u64

Get the current sequence number.

pub fn next_sequence(&mut self) -> u64

Increment and return the next sequence number.

pub fn update_debounce_ms(&self) -> u64

Get the update debounce interval in milliseconds.

pub fn set_update_debounce_ms(&mut self, ms: u64)

Set the update debounce interval.

pub fn add_leaf_dependent(&mut self, node_addr: NodeAddr)

Add a leaf dependent that we’ll include in our filter.

pub fn remove_leaf_dependent(&mut self, node_addr: &NodeAddr) -> bool

Remove a leaf dependent.

pub fn leaf_dependents(&self) -> &HashSet<NodeAddr>

Get the set of leaf dependents.

pub fn leaf_dependent_count(&self) -> usize

Number of leaf dependents.

pub fn mark_update_needed(&mut self, peer_id: NodeAddr)

Mark that a peer needs an update.

pub fn mark_all_updates_needed( &mut self, peer_ids: impl IntoIterator<Item = NodeAddr>, )

Mark all peers as needing updates.

pub fn needs_update(&self, peer_id: &NodeAddr) -> bool

Check if a peer needs an update.

pub fn should_send_update( &self, peer_id: &NodeAddr, current_time_ms: u64, ) -> bool

Check if we should send an update to a peer (respecting debounce).

pub fn record_update_sent(&mut self, peer_id: NodeAddr, current_time_ms: u64)

Record that we sent an update to a peer.

pub fn clear_pending_updates(&mut self)

Clear all pending updates.

pub fn record_sent_filter(&mut self, peer_id: NodeAddr, filter: BloomFilter)

Record the outgoing filter that was sent to a peer.

pub fn remove_peer_state(&mut self, peer_id: &NodeAddr)

Remove stored filter state for a peer that was removed.

pub fn mark_changed_peers( &mut self, exclude_from: &NodeAddr, peer_addrs: &[NodeAddr], peer_filters: &HashMap<NodeAddr, BloomFilter>, )

Mark only peers whose outgoing filter has actually changed.

Computes the outgoing filter for each peer and compares it against what was last sent. Only marks peers where the filter differs. This prevents cascading update loops in steady state.

pub fn compute_outgoing_filter( &self, exclude_peer: &NodeAddr, peer_filters: &HashMap<NodeAddr, BloomFilter>, ) -> BloomFilter

Compute the outgoing filter for a specific peer.

The filter includes:

• This node’s own ID
• All leaf dependents
• Entries from other peers’ inbound filters (excluding the destination peer)

The peer_filters map contains inbound filters from each peer. The filter for exclude_peer is excluded to prevent routing loops.

pub fn base_filter(&self) -> BloomFilter

Create a base filter containing just this node and its dependents.

Trait Implementations

impl Clone for BloomState

fn clone(&self) -> BloomState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BloomState

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

Formats the value using the given formatter.