Struct DigMessage 

pub struct DigMessage {
    pub msg_type: u8,
    pub id: Option<u16>,
    pub data: Bytes,
}

Wire message with raw u8 opcode — handles both Chia (0–107) and DIG (200–219) opcodes.

Same binary layout as chia_protocol::Message:

[u8 msg_type] [bool has_id] [u16 id (if has_id)] [u32 data_len] [u8... data]

Use DigMessage::to_bytes / DigMessage::from_bytes for wire serialization. Use DigMessage::try_into_chia_message to convert to stock Message when the opcode is a known Chia type.

Fields

msg_type: u8

Raw wire opcode — no enum restriction.

id: Option<u16>

Correlation ID for request/response pairing (same as Message.id).

data: Bytes

Serialized payload body.

Implementations

impl DigMessage

pub const MAX_MESSAGE_SIZE: usize

Protocol-level ceiling on a single message’s declared payload length (bytes).

from_bytes rejects any data_len prefix above this value with None before slicing/allocating the payload, so a peer cannot force a multi-gigabyte Vec allocation via a lying (or genuine but oversized) length prefix. Mirrors chia-protocol’s own message-size ceiling (16 MiB) — comfortably above any legitimate DIG opcode payload (attestations, checkpoints, block-transaction batches) while bounding worst-case per-message memory.

Callers MUST still enforce a per-frame size cap at the transport/framing layer BEFORE buffering an incoming frame into a contiguous &[u8] — this constant only bounds what from_bytes will accept once a slice already exists; it cannot stop a transport from reading an unbounded number of bytes off the wire first.

pub fn new(msg_type: u8, id: Option<u16>, data: Bytes) -> Self

Construct a new DIG message.

pub fn to_bytes(&self) -> Vec<u8>

Serialize to wire bytes (same format as Message::to_bytes).

Layout: [u8 msg_type] [u8 has_id (0/1)] [u16 id if present] [u32 data_len] [data...]

pub fn from_bytes(bytes: &[u8]) -> Option<Self>

Deserialize from wire bytes. Accepts any msg_type value — no enum validation.

Returns None if the buffer is too short, the length prefix doesn’t match, or the declared data_len exceeds Self::MAX_MESSAGE_SIZE.

This is a leaf parser over an already-materialized &[u8]: the MAX_MESSAGE_SIZE check bounds the allocation this function performs, but it cannot bound how many bytes a transport read off the wire to build bytes in the first place. Callers MUST enforce a per-frame size cap at the transport/framing layer before buffering an incoming frame, so that a peer cannot force unbounded buffering ahead of ever reaching this function.

pub fn from_bytes_owned(buf: Vec<u8>) -> Option<Self>

Deserialize from an OWNED byte buffer, moving the payload instead of copying it.

Identical acceptance/rejection rules to Self::from_bytes (same length checks, same Self::MAX_MESSAGE_SIZE cap, same None on any malformed input) — the only difference is that when buf already owns its bytes (e.g. a transport that read the frame directly into a Vec<u8>), the payload is moved into the result via Vec::drain instead of being copied out of a borrowed &[u8] with to_vec. Prefer this over from_bytes whenever the caller already has an owned Vec<u8> and does not need it afterward.

pub fn from_chia_message(msg: &Message) -> Self

Convert from a stock chia_protocol::Message (lossless — opcode stored as u8).

Clones msg.data. Prefer Self::from_chia_message_owned when an owned Message is available and does not need to be kept afterward.

pub fn from_chia_message_owned(msg: Message) -> Self

Convert from an OWNED stock chia_protocol::Message, moving data instead of cloning it (lossless — opcode stored as u8).

pub fn try_into_chia_message(&self) -> Option<Message>

Try to convert to a stock chia_protocol::Message, cloning self.data.

Fails if msg_type is not a valid ProtocolMessageTypes discriminant (i.e., DIG extension opcodes 200+ will fail here — use DigMessage directly for those). Prefer Self::into_chia_message when self does not need to be kept afterward.

pub fn into_chia_message(self) -> Option<Message>

Try to convert into a stock chia_protocol::Message BY VALUE, moving self.data instead of cloning it.

Same failure condition as Self::try_into_chia_message: None when msg_type is not a valid ProtocolMessageTypes discriminant. On failure self is dropped (its opcode was not a known Chia type, so there is nothing useful to hand back).

pub fn is_dig_extension(&self) -> bool

Whether this message carries a DIG extension opcode (>= 200).

pub fn is_chia_standard(&self) -> bool

Whether this message carries a standard Chia opcode (< 200).

Trait Implementations

impl Clone for DigMessage

fn clone(&self) -> DigMessage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DigMessage

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

Formats the value using the given formatter.

impl Eq for DigMessage

impl PartialEq for DigMessage

fn eq(&self, other: &DigMessage) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DigMessage