Struct CannedMessageEvent 

pub struct CannedMessageEvent {
    pub message: CannedMessage,
    pub source_node: NodeId,
    pub target_node: Option<NodeId>,
    pub timestamp: u64,
    pub sequence: u32,
}

A canned message event with metadata.

Contains the message code plus source, optional target, timestamp, and sequence number for deduplication.

Fields

message: CannedMessage

The message type

source_node: NodeId

Source node that sent this message

target_node: Option<NodeId>

Target node (if directed message, e.g., ACK to specific node)

timestamp: u64

Timestamp in milliseconds (epoch or boot time)

sequence: u32

Sequence number for deduplication

Implementations

impl CannedMessageEvent

pub fn new( message: CannedMessage, source_node: NodeId, target_node: Option<NodeId>, timestamp: u64, ) -> Self

Create a new canned message event.

pub fn with_sequence( message: CannedMessage, source_node: NodeId, target_node: Option<NodeId>, timestamp: u64, sequence: u32, ) -> Self

Create with explicit sequence number.

pub fn encode(&self) -> Vec<u8, 22>

Encode to wire format.

Format:

┌──────┬──────────┬──────────┬──────────┬───────────┬──────┐
│ 0xAF │ msg_code │ src_node │ tgt_node │ timestamp │ seq  │
│ 1B   │ 1B       │ 4B       │ 4B (opt) │ 8B        │ 4B   │
└──────┴──────────┴──────────┴──────────┴───────────┴──────┘

If target_node is None, those 4 bytes are 0x00000000.

pub fn decode(data: &[u8]) -> Option<Self>

Decode from wire format.

Returns None if data is malformed.

pub fn is_newer_than(&self, other: &Self) -> bool

Check if this event is newer than another from the same source.

pub fn encode_signed(&self, signature: &[u8; 64]) -> Vec<u8, 86>

Encode to signed wire format with Ed25519 signature.

Format:

┌──────┬──────────┬──────────┬──────────┬───────────┬──────┬───────────┐
│ 0xAF │ msg_code │ src_node │ tgt_node │ timestamp │ seq  │ signature │
│ 1B   │ 1B       │ 4B       │ 4B       │ 8B        │ 4B   │ 64B       │
└──────┴──────────┴──────────┴──────────┴───────────┴──────┴───────────┘

The signature should cover the first 22 bytes (marker through seq). Caller is responsible for computing the signature using their identity.

Arguments

• signature - Ed25519 signature over the unsigned payload (22 bytes)

pub fn decode_signed(data: &[u8]) -> Option<(Self, [u8; 64])>

Decode from signed wire format.

Returns the event and signature if the data is exactly 86 bytes and has a valid marker.

Note: This does NOT verify the signature. Caller must verify using the sender’s public key from the identity registry.

Returns

Some((event, signature)) if valid signed format, None otherwise.

pub fn signable_payload(&self) -> Vec<u8, 22>

Get the payload bytes that should be signed.

Returns the 22-byte unsigned wire format suitable for signing. Use this with your identity’s sign() method:

let payload = event.signable_payload();
let signature = identity.sign(&payload);
let wire = event.encode_signed(&signature);

pub fn is_signed_format(data: &[u8]) -> bool

Check if wire data is in signed format (86 bytes) vs unsigned (22 bytes).

Useful for protocol negotiation and backward compatibility.

pub fn is_unsigned_format(data: &[u8]) -> bool

Check if wire data is in unsigned format (22 bytes).

pub fn decode_auto(data: &[u8]) -> Option<(Self, Option<[u8; 64]>)>

Decode from either signed or unsigned format.

Returns (event, Some(signature)) for signed format, or (event, None) for unsigned format.

Returns

Some((event, optional_signature)) if valid format, None if malformed.

Trait Implementations

impl Clone for CannedMessageEvent

fn clone(&self) -> CannedMessageEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CannedMessageEvent

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

Formats the value using the given formatter.

impl PartialEq for CannedMessageEvent

fn eq(&self, other: &CannedMessageEvent) -> 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 Copy for CannedMessageEvent

impl Eq for CannedMessageEvent

impl StructuralPartialEq for CannedMessageEvent