Struct WireMessage 

pub struct WireMessage {
    pub version: u8,
    pub source_chain: u64,
    pub state_version: StateVersion,
    pub updated_at: u64,
    pub key: StateKey,
    pub data: Bytes,
}

Binary wire format for cross-chain state messages.

Layout (all multi-byte integers big-endian):

[0x58 0x45 0x4E 0x48]  magic ("XENH", 4 bytes)
u8                     wire format version (2 or 3)
u64                    source_chain
u64                    version.timestamp_ms
u64                    version.sequence
u64                    version.source_chain
u64                    updated_at
u16                    key_len
[u8; key_len]          key bytes (UTF-8)
u32                    data_len
[u8; data_len]         payload bytes
--- version 3 only ---
u8                     has_metadata (0 or 1)
[u8; 20]               address  (only when has_metadata == 1)
[u8; 32]               slot     (only when has_metadata == 1)

Version 2 messages decode with metadata = None. Version 3 messages carry optional on-chain metadata (contract address + storage slot) that enables crate::ReadStrategy::Quorum reads without a separate set_metadata call.

Example

use bytes::Bytes;
use xenith_core::{ChainId, KeyMetadata, StateKey, StateValue, StateVersion, wire};

let key = StateKey::new("uniswap", "pool", "0xabc");
let value = StateValue {
    data: Bytes::from_static(b"price=3400"),
    version: StateVersion { timestamp_ms: 1_700_000_000_000, sequence: 0, source_chain: 1 },
    updated_at: 1_700_000_000,
    source_chain: ChainId::from(1),
};
let encoded = wire::encode(&key, &value, None);
let (decoded_key, decoded_value, meta) = wire::decode(&encoded).unwrap();
assert_eq!(decoded_key, key);
assert_eq!(decoded_value.version.timestamp_ms, 1_700_000_000_000);
assert!(meta.is_none());

Fields

version: u8

source_chain: u64

state_version: StateVersion

updated_at: u64

key: StateKey

data: Bytes

Trait Implementations

impl Clone for WireMessage

fn clone(&self) -> WireMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WireMessage

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

Formats the value using the given formatter.

impl PartialEq for WireMessage

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