Struct P2pNetworkPubsubState

pub struct P2pNetworkPubsubState {
    pub clients: BTreeMap<PeerId, P2pNetworkPubsubClientState>,
    pub seq: u64,
    pub to_sign: VecDeque<Message>,
    pub seen: VecDeque<Vec<u8>>,
    pub mcache: P2pNetworkPubsubMessageCache,
    pub incoming_transactions: Vec<(Transaction, u32)>,
    pub incoming_snarks: Vec<(Snark, u32)>,
    pub topics: BTreeMap<String, BTreeMap<PeerId, P2pNetworkPubsubClientTopicState>>,
    pub iwant: VecDeque<P2pNetworkPubsubIwantRequestCount>,
}

State of the P2P Network PubSub system.

This struct maintains information about connected peers, message sequencing, message caching, and topic subscriptions. It handles incoming and outgoing messages, manages the mesh network topology, and ensures efficient message broadcasting across the network.

Fields

clients: BTreeMap<PeerId, P2pNetworkPubsubClientState>

State of each connected peer.

seq: u64

Current message sequence number.

Increments with each new message to ensure proper ordering and uniqueness.

to_sign: VecDeque<Message>

Messages awaiting cryptographic signing.

seen: VecDeque<Vec<u8>>

Recently seen message identifiers to prevent duplication.

Keeps a limited history of message signatures to avoid processing the same message multiple times.

mcache: P2pNetworkPubsubMessageCache

Cache of published messages for efficient retrieval and broadcasting.

For quick access and reducing redundant data transmission across peers.

incoming_transactions: Vec<(Transaction, u32)>

Incoming transactions from peers along with their nonces.

incoming_snarks: Vec<(Snark, u32)>

Incoming snarks from peers along with their nonces.

topics: BTreeMap<String, BTreeMap<PeerId, P2pNetworkPubsubClientTopicState>>

Topics and their subscribed peers.

iwant: VecDeque<P2pNetworkPubsubIwantRequestCount>

iwant requests, tracking the number of times peers have expressed interest in specific messages.

Implementations

impl P2pNetworkPubsubState

pub fn prune_peer_state(&mut self, peer_id: &PeerId)

pub fn filter_iwant_message_ids( &mut self, message_id: &[u8], timestamp: Timestamp, ) -> bool

pub fn clear_incoming(&mut self)

impl P2pNetworkPubsubState

pub fn reducer<Action, State>( state_context: Substate<'_, Action, State, Self>, action: ActionWithMeta<P2pNetworkPubsubAction>, ) -> Result<(), String>

where State: P2pStateTrait, Action: P2pActionTrait<State>,

fn prepare_to_sign<Action, State>( state_context: Substate<'_, Action, State, Self>, buffer: Vec<u8>, ) -> Result<(), String>

where State: P2pStateTrait, Action: P2pActionTrait<State>,

fn reduce_incoming_validated_message( &mut self, message_id: P2pNetworkPubsubMessageCacheId, peer_id: PeerId, message: &Message, )

Queues a validated message for propagation to other peers in the pubsub network. For peers that are “on mesh” for the message’s topic, queues the full message. For other peers, queues an IHAVE control message to notify about message availability. The original sender is excluded from propagation.

fn reduce_incoming_message( &mut self, message: &Message, seen_limit: usize, ) -> Result<Option<GossipNetMessageV2>, String>

Processes an incoming message by checking for duplicates and deserializing its contents.

This function performs two main operations:

1. Deduplication: Tracks recently seen messages using their signatures to avoid processing duplicates
2. Deserialization: Converts valid message data into a GossipNetMessageV2 structure

Arguments

• message - The incoming message to process
• seen_limit - Maximum number of message signatures to keep in the deduplication cache

Returns

• Ok(Some(GossipNetMessageV2)) - Successfully processed and deserialized message
• Ok(None) - Message was a duplicate (already seen)
• Err(String) - Error during processing (invalid message format or deserialization failure)

fn combined_with_pending_buffer<'a>( buffer: &'a mut Vec<u8>, data: &'a [u8], ) -> &'a [u8]

fn reduce_incoming_data( &mut self, peer_id: &PeerId, data: Data, timestamp: Timestamp, ) -> Result<(), String>

Processes incoming data from a peer, handling subscriptions, control messages, and message broadcasting within the P2P pubsub system.

fn update_subscriptions( &mut self, peer_id: &PeerId, subscriptions: Vec<SubOpts>, )

fn apply_control_commands(&mut self, peer_id: &PeerId, control: &ControlMessage)

Applies control commands (graft and prune) to manage the peer’s mesh states within topics.

fn respond_to_iwant_requests( &mut self, peer_id: &PeerId, iwant_requests: &[ControlIWant], )

fn process_ihave_messages( &mut self, peer_id: &PeerId, ihave_messages: Vec<ControlIHave>, timestamp: Timestamp, )

fn broadcast<Action, State>( dispatcher: &mut Dispatcher<Action, State>, state: &State, ) -> Result<(), String>

where State: P2pStateTrait, Action: P2pActionTrait<State>,

Trait Implementations

impl Clone for P2pNetworkPubsubState

fn clone(&self) -> P2pNetworkPubsubState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for P2pNetworkPubsubState

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

Formats the value using the given formatter.

impl Default for P2pNetworkPubsubState

fn default() -> P2pNetworkPubsubState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for P2pNetworkPubsubState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MallocSizeOf for P2pNetworkPubsubState

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl Serialize for P2pNetworkPubsubState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SubstateAccess<P2pNetworkPubsubState> for P2pState

fn substate(&self) -> SubstateResult<&P2pNetworkPubsubState>

Attempts to obtain an immutable reference to the substate.

fn substate_mut(&mut self) -> SubstateResult<&mut P2pNetworkPubsubState>

Attempts to obtain a mutable reference to the substate.