Struct Did 

pub struct Did {
    pub ipns: String,
    pub fragment: Option<String>,
}

A parsed did:ma: identifier.

Without a fragment this is a bare DID: did:ma:<ipns>. With a fragment it becomes a DID URL: did:ma:<ipns>#<fragment>.

Constructors enforce strict fragment validation (strict in what we send). Parsing via try_from is lenient (generous in what we receive).

Examples

use ma_did::Did;

// Bare DID (identity)
let id = Did::new_identity("k51qzi5uqu5abc").unwrap();
assert!(id.is_bare());
assert_eq!(id.base_id(), "did:ma:k51qzi5uqu5abc");

// DID URL with auto-generated fragment
let url = Did::new_url("k51qzi5uqu5abc", None::<String>).unwrap();
assert!(url.is_url());

// Parse incoming DID URL (lenient)
let parsed = Did::try_from("did:ma:k51qzi5uqu5abc#lobby").unwrap();
assert_eq!(parsed.fragment.as_deref(), Some("lobby"));

Fields

ipns: String

fragment: Option<String>

Local atom/inbox name (for example an avatar inbox in a world). In practice this often matches a Kubo key name, but this coupling is loose.

Implementations

impl Did

pub fn new_identity(ipns: impl Into<String>) -> Result<Did, MaError>

Create a bare DID (did:ma:<ipns>) with no fragment.

pub fn new_url( ipns: impl Into<String>, fragment: Option<impl Into<String>>, ) -> Result<Did, MaError>

Create a DID URL (did:ma:<ipns>#<fragment>). If fragment is None, a nanoid is generated automatically. Provided fragments are validated as nanoids ([A-Za-z0-9_-]+).

pub fn base_id(&self) -> String

pub fn with_fragment(&self, fragment: impl Into<String>) -> Result<Did, MaError>

pub fn id(&self) -> String

pub fn parse(input: &str) -> Result<(String, Option<String>), MaError>

pub fn validate(input: &str) -> Result<(), MaError>

pub fn validate_url(input: &str) -> Result<(), MaError>

Validate that input is a DID URL (has a fragment).

pub fn validate_identity(input: &str) -> Result<(), MaError>

Validate that input is a bare DID identity (no fragment).

pub fn is_url(&self) -> bool

True when this DID has a fragment (is a DID URL).

pub fn is_bare(&self) -> bool

True when this DID has no fragment (bare DID).

Trait Implementations

impl Clone for Did

fn clone(&self) -> Did

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Did

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Did

fn deserialize<__D>( __deserializer: __D, ) -> Result<Did, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Did

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Did

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

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 TryFrom<&str> for Did

fn try_from(value: &str) -> Result<Did, MaError>

Parse any valid DID URL. A bare DID (no fragment) is a valid DID URL per W3C DID Core §3.2 — the fragment is optional.

type Error = MaError

The type returned in the event of a conversion error.

impl Eq for Did

impl StructuralPartialEq for Did