Struct PlainMessage 

pub struct PlainMessage<T = Value> {

    pub id: String,
    pub typ: String,
    pub type_: String,
    pub body: T,
    pub from: String,
    pub to: Vec<String>,
    pub thid: Option<String>,
    pub pthid: Option<String>,
    pub extra_headers: HashMap<String, Value>,
    pub created_time: Option<u64>,
    pub expires_time: Option<u64>,
    pub from_prior: Option<String>,
    pub attachments: Option<Vec<Attachment>>,
}

Wrapper for plain message. Provides helpers for message building and packing/unpacking. Adapted from https://github.com/sicpa-dlab/didcomm-rust/blob/main/src/message/message.rs

Fields

id: String

Message id. Must be unique to the sender.

typ: String

Optional, if present it must be “application/didcomm-plain+json”

type_: String

Message type attribute value MUST be a valid Message Type URI, that when resolved gives human readable information about the message. The attribute’s value also informs the content of the message, or example the presence of other attributes and how they should be processed.

body: T

Message body - strongly typed when T is specified.

from: String

Sender identifier. The from attribute MUST be a string that is a valid DID or DID URL (without the fragment component) which identifies the sender of the message.

to: Vec<String>

Identifier(s) for recipients. MUST be an array of strings where each element is a valid DID or DID URL (without the fragment component) that identifies a member of the message’s intended audience.

thid: Option<String>

Uniquely identifies the thread that the message belongs to. If not included the id property of the message MUST be treated as the value of the thid.

pthid: Option<String>

If the message is a child of a thread the pthid will uniquely identify which thread is the parent.

extra_headers: HashMap<String, Value>

Custom message headers.

created_time: Option<u64>

The attribute is used for the sender to express when they created the message, expressed in UTC Epoch Seconds (seconds since 1970-01-01T00:00:00Z UTC). This attribute is informative to the recipient, and may be relied on by protocols.

expires_time: Option<u64>

The expires_time attribute is used for the sender to express when they consider the message to be expired, expressed in UTC Epoch Seconds (seconds since 1970-01-01T00:00:00Z UTC). This attribute signals when the message is considered no longer valid by the sender. When omitted, the message is considered to have no expiration by the sender.

from_prior: Option<String>

from_prior is a compactly serialized signed JWT containing FromPrior value

attachments: Option<Vec<Attachment>>

Implementations

impl<T> PlainMessage<T>

where T: Serialize + DeserializeOwned,

pub fn new(id: String, type_: String, body: T, from: String) -> Self

Create a new PlainMessage with the given body

pub fn with_recipients(self, to: Vec<String>) -> Self

Builder method to set recipients

pub fn with_recipient(self, recipient: &str) -> Self

Builder method to add a single recipient

pub fn with_thread_id(self, thid: Option<String>) -> Self

Builder method to set thread ID

pub fn with_parent_thread_id(self, pthid: Option<String>) -> Self

Builder method to set parent thread ID

pub fn with_expires_at(self, expires_time: u64) -> Self

Builder method to set expiration time

pub fn with_attachments(self, attachments: Vec<Attachment>) -> Self

Builder method to add attachments

pub fn with_header(self, key: String, value: Value) -> Self

Builder method to add a custom header

impl<T> PlainMessage<T>

where T: TapMessageBody + Serialize + DeserializeOwned,

pub fn new_typed(body: T, from: &str) -> Self

Create a new typed message

pub fn to_plain_message(self) -> Result<PlainMessage<Value>>

Convert to untyped PlainMessage for serialization/transport

pub fn extract_participants(&self) -> Vec<String>

Extract recipients based on the message body participants

impl<T> PlainMessage<T>

where T: TapMessageBody + MessageContext + Serialize + DeserializeOwned,

pub fn extract_participants_with_context(&self) -> Vec<String>

Extract participants using MessageContext

pub fn new_typed_with_context(body: T, from: &str) -> Self

Create a typed message with automatic recipient detection

pub fn routing_hints(&self) -> RoutingHints

Get routing hints from the message body

pub fn transaction_context(&self) -> Option<TransactionContext>

Get transaction context from the message body

impl PlainMessage<Value>

pub fn from_untyped(plain_msg: PlainMessage<Value>) -> Self

Create a typed message from an untyped PlainMessage

pub fn parse_body<T: TapMessageBody>(self) -> Result<PlainMessage<T>>

Try to parse the body into a specific TAP message type

pub fn parse_tap_message(&self) -> Result<TapMessage>

Parse into the TapMessage enum for runtime dispatch

Trait Implementations

impl<T: Clone> Clone for PlainMessage<T>

fn clone(&self) -> PlainMessage<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Connectable for PlainMessage

fn with_connection(&mut self, connection_id: &str) -> &mut Self

Connect this message to a prior Connect message by setting the parent thread ID (pthid).

fn has_connection(&self) -> bool

Check if this message is connected to a prior Connect message.

fn connection_id(&self) -> Option<&str>

Get the connection ID if present.

impl<T: Debug> Debug for PlainMessage<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for PlainMessage<T>

where T: Serialize + DeserializeOwned,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq> PartialEq for PlainMessage<T>

fn eq(&self, other: &PlainMessage<T>) -> 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 PlainMessageExt<Value> for PlainMessage<Value>

fn into_typed(self) -> PlainMessage<Value>

Convert to a typed message

fn parse_as<U: TapMessageBody>(self) -> Result<PlainMessage<U>>

Try to parse as a specific message type

impl<T> Serialize for PlainMessage<T>

where T: Serialize + DeserializeOwned,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TapMessage for PlainMessage

fn validate(&self) -> Result<()>

Validates a TAP message.

fn is_tap_message(&self) -> bool

Checks if this message is a TAP message.

fn get_tap_type(&self) -> Option<String>

Gets the TAP message type from this message.

fn body_as<T: TapMessageBody>(&self) -> Result<T>

Extract a specific message body type from this message.

fn get_all_participants(&self) -> Vec<String>

Get all participant DIDs from this message.

fn thread_id(&self) -> Option<&str>

Get the thread ID for this message

fn parent_thread_id(&self) -> Option<&str>

Get the parent thread ID for this message

fn message_id(&self) -> &str

Get the message ID for this message

fn create_reply<T: TapMessageBody>( &self, body: &T, creator_did: &str, ) -> Result<PlainMessage>

Create a reply to this message.

impl<T: TapMessageBody> TryFrom<PlainMessage<T>> for TapMessage

where TapMessage: From<T>,

Helper to convert between typed messages and TapMessage enum

type Error = Error

The type returned in the event of a conversion error.

fn try_from(typed: PlainMessage<T>) -> Result<Self>

Performs the conversion.

impl<T: Eq> Eq for PlainMessage<T>

impl<T> StructuralPartialEq for PlainMessage<T>