Struct DidCommHeader 

pub struct DidCommHeader {
    pub id: String,
    pub message_type: String,
    pub to: BTreeSet<String>,
    pub from: Option<String>,
    pub thid: Option<String>,
    pub pthid: Option<String>,
    pub created_time: Option<u64>,
    pub expires_time: Option<u64>,
    pub fields: BTreeMap<String, String>,
}

See: https://identity.foundation/didcomm-messaging/spec/#message-headers

Fields

id: String

REQUIRED. Message ID. The id attribute value MUST be unique to the sender, across all messages they send. See Threading > Message IDs for constraints on this value.

message_type: String

REQUIRED. A URI that associates the body of a plaintext message with a published and versioned schema. Useful for message handling in application-level protocols. The type attribute value MUST be a valid message type URI, that when resolved gives human readable information about the message category.

to: BTreeSet<String>

OPTIONAL. 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. These values are useful for recipients to know which of their keys can be used for decryption. It is not possible for one recipient to verify that the message was sent to a different recipient.

When Alice sends the same plaintext message to Bob and Carol, it is by inspecting this header that the recipients learn the message was sent to both of them. If the header is omitted, each recipient SHOULD assume they are the only recipient (much like an email sent only to BCC: addresses).

For signed messages, there are specific requirements around properly defining the to header outlined in the DIDComm Signed Message definition above. This prevents certain kind of forwarding attacks, where a message that was not meant for a given recipient is forwarded along with its signature to a recipient which then might blindly trust it because of the signature.

Upon reception of a message with a defined to header, the recipient SHOULD verify that their own identifier appears in the list. Implementations MUST NOT fail to accept a message when this is not the case, but SHOULD give a warning to their user as it could indicate malicious intent from the sender.

The to header cannot be used for routing, since it is encrypted at every intermediate point in a route. Instead, the forward message contains a next attribute in its body that specifies the target for the next routing operation.

from: Option<String>

OPTIONAL when the message is to be encrypted via anoncrypt; REQUIRED when the message is encrypted via authcrypt. 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. When a message is encrypted, the sender key MUST be authorized for encryption by this DID. Authorization of the encryption key for this DID MUST be verified by message recipient with the proper proof purposes. When the sender wishes to be anonymous using authcrypt, it is recommended to use a new DID created for the purpose to avoid correlation with any other behavior or identity. Peer DIDs are lightweight and require no ledger writes, and therefore a good method to use for this purpose.

thid: Option<String>

OPTIONAL. Thread identifier. 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. See Threads for details.

pthid: Option<String>

OPTIONAL. Parent thread identifier. If the message is a child of a thread the pthid will uniquely identify which thread is the parent. See Parent Threads for details.

created_time: Option<u64>

OPTIONAL but recommended. Message Created Time. This 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) as an integer. This allows the recipient to guess about transport latency and clock divergence. The difference between when a message is created and when it is sent is assumed to be negligible; this lets timeout logic start from this value.

expires_time: Option<u64>

OPTIONAL. Message Expires Time. This attribute is used for the sender to express when they will consider the message to be expired, expressed in UTC Epoch Seconds (seconds since 1970-01-01T00:00:00Z) as an integer. By default, the meaning of “expired” is that the sender will abort the protocol if it doesn’t get a response by this time. However, protocols can nuance this in their formal spec. For example, an online auction protocol might specify that timed out bids must be ignored instead of triggering a cancellation of the whole auction. When omitted from any given message, the message is considered to have no expiration by the sender.

fields: BTreeMap<String, String>

OPTIONAL. Custom fields.

Implementations

impl DidCommHeader

pub fn new(date: &CoDateRef, message_type: impl Into<String>) -> Self

Create new DidCommHeader with an

pub fn create<F, T>( date: &CoDateRef, from: &F, to: &T, message_type: impl Into<String>, ) -> Result<(DidCommPrivateContext, DidCommPublicContext, Self)>

where F: PrivateIdentity + Send + Sync + 'static, T: Identity + Send + Sync + 'static,

Create new DidCommHeader for a message with sender from and single recipient to.

pub fn create_from<F>( date: &CoDateRef, from: &F, message_type: impl Into<String>, ) -> Result<(DidCommPrivateContext, Self)>

where F: PrivateIdentity + Send + Sync + 'static,

Create new DidCommHeader for a message with sender from and unknown recipent(s).

pub fn create_message_id() -> String

Create random message id.

pub fn with_fields( self, fields: impl IntoIterator<Item = (String, String)>, ) -> Result<Self, Error>

Trait Implementations

impl Clone for DidCommHeader

fn clone(&self) -> DidCommHeader

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DidCommHeader

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

Formats the value using the given formatter.

impl Default for DidCommHeader

fn default() -> DidCommHeader

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DidCommHeader

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<DidCommHeader> for PeerDidCommHeader

fn from(header: DidCommHeader) -> Self

Converts to this type from the input type.

impl From<PeerDidCommHeader> for DidCommHeader

fn from(value: PeerDidCommHeader) -> Self

Converts to this type from the input type.

impl Ord for DidCommHeader

fn cmp(&self, other: &DidCommHeader) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for DidCommHeader

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

fn partial_cmp(&self, other: &DidCommHeader) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for DidCommHeader

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DidCommHeader

impl StructuralPartialEq for DidCommHeader