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) -> PlainMessage<T>

Create a new PlainMessage with the given body

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

Builder method to set recipients

pub fn with_recipient(self, recipient: &str) -> PlainMessage<T>

Builder method to add a single recipient

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

Builder method to set thread ID

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

Builder method to set parent thread ID

pub fn with_expires_at(self, expires_time: u64) -> PlainMessage<T>

Builder method to set expiration time

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

Builder method to add attachments

pub fn with_header(self, key: String, value: Value) -> PlainMessage<T>

Builder method to add a custom header

impl<T> PlainMessage<T>

where T: TapMessageBody + Serialize + DeserializeOwned,

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

Create a new typed message

pub fn to_plain_message(self) -> Result<PlainMessage, Error>

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) -> PlainMessage<T>

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

pub fn from_untyped(plain_msg: PlainMessage) -> PlainMessage

Create a typed message from an untyped PlainMessage

pub fn parse_body<T>(self) -> Result<PlainMessage<T>, Error>

where T: TapMessageBody,

Try to parse the body into a specific TAP message type

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

Parse into the TapMessage enum for runtime dispatch

Trait Implementations

impl<T> Clone for PlainMessage<T>

where T: Clone,

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 PlainMessage

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 for PlainMessage<T>

where T: Debug,

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

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<PlainMessage<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Packable for PlainMessage

Implement Packable for PlainMessage

fn pack<'life0, 'life1, 'async_trait>( &'life0 self, key_manager: &'life1 (impl 'async_trait + KeyManagerPacking + ?Sized), options: PackOptions, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Pack the object for secure transmission

impl<T> PartialEq for PlainMessage<T>

where T: PartialEq,

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

fn into_typed(self) -> PlainMessage

Convert to a typed message

fn parse_as<U>(self) -> Result<PlainMessage<U>, Error>

where U: TapMessageBody,

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 as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TapMessage for PlainMessage

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

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>(&self) -> Result<T, Error>

where T: TapMessageBody,

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>( &self, body: &T, creator_did: &str, ) -> Result<PlainMessage, Error>

where T: TapMessageBody,

Create a reply to this message.

impl<T> Eq for PlainMessage<T>

where T: Eq,

impl<T> StructuralPartialEq for PlainMessage<T>