Enum BroadcastMessage 

#[non_exhaustive]
pub enum BroadcastMessage<'a> {
    StateDelta {
        context_id: ContextId,
        author_id: PublicKey,
        delta_id: [u8; 32],
        parent_ids: Vec<[u8; 32]>,
        hlc: HybridTimestamp,
        root_hash: Hash,
        artifact: Cow<'a, [u8]>,
        nonce: Nonce,
        events: Option<Cow<'a, [u8]>>,
    },
    HashHeartbeat {
        context_id: ContextId,
        root_hash: Hash,
        dag_heads: Vec<[u8; 32]>,
    },
    SpecializedNodeDiscovery {
        nonce: [u8; 32],
        node_type: SpecializedNodeType,
    },
    SpecializedNodeJoinConfirmation {
        nonce: [u8; 32],
    },
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

StateDelta

Fields

context_id: ContextId

author_id: PublicKey

delta_id: [u8; 32]

DAG: Unique delta ID (content hash)

parent_ids: Vec<[u8; 32]>

DAG: Parent delta IDs (for causal ordering)

hlc: HybridTimestamp

Hybrid Logical Clock timestamp for causal ordering

root_hash: Hash

artifact: Cow<'a, [u8]>

nonce: Nonce

events: Option<Cow<'a, [u8]>>

Execution events that were emitted during the state change. This field is encrypted along with the artifact.

HashHeartbeat

Hash heartbeat for divergence detection

Periodically broadcast by nodes to allow peers to detect silent divergence. If a peer has a different hash for the same DAG heads, it indicates a problem.

Fields

context_id: ContextId

root_hash: Hash

Current root hash

dag_heads: Vec<[u8; 32]>

Current DAG head(s)

SpecializedNodeDiscovery

Specialized node discovery request

Broadcast by a node to discover and invite specialized nodes (e.g., read-only TEE nodes). Specialized nodes receiving this will respond via request-response protocol to the message source (available from gossipsub message).

Note: context_id is NOT included - it’s tracked internally by the requesting node using the nonce as the lookup key.

Fields

nonce: [u8; 32]

Random nonce to bind verification to this request

node_type: SpecializedNodeType

Type of specialized node being invited

SpecializedNodeJoinConfirmation

Confirmation that a specialized node has joined a context

Broadcast by specialized nodes on the context topic after successfully joining. The inviting node receives this and removes the pending invite entry.

Fields

nonce: [u8; 32]

The nonce from the original discovery request

Trait Implementations

impl<'a> BorshDeserialize for BroadcastMessage<'a>

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl<'a> BorshSerialize for BroadcastMessage<'a>

fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>

impl<'a> Debug for BroadcastMessage<'a>

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

Formats the value using the given formatter.

impl<'a> EnumExt for BroadcastMessage<'a>

fn deserialize_variant<__R: Read>( reader: &mut __R, variant_tag: u8, ) -> Result<Self, Error>

Deserialises given variant of an enum from the reader.