Struct Did

Source

pub struct Did(/* private fields */);

Expand description

A decentralized identifier such as did:web:example.com.

A Did is validated against the DID syntax of W3C DID Core §3.1 when it is constructed and stores the input unchanged: no percent-decoding, no case folding, no normalization. Two DIDs are equal exactly when their strings are equal.

§Examples

use identity_kit::did::Did;

let did = Did::parse("did:web:example.com%3A8443:user:alice")?;
assert_eq!(did.method(), "web");
assert_eq!(did.method_specific_id(), "example.com%3A8443:user:alice");
assert_eq!(did.as_str(), "did:web:example.com%3A8443:user:alice");

// The scheme and the method name are lowercase; a DID has no path, query or fragment.
assert!(Did::parse("DID:web:example.com").is_err());
assert!(Did::parse("did:Web:example.com").is_err());
assert!(Did::parse("did:web:example.com#key-1").is_err());

A Did serializes as its string and deserialization validates:

use identity_kit::did::Did;
use serde::Deserialize;
use serde::de::IntoDeserializer;
use serde::de::value::{Error, StrDeserializer};

let input: StrDeserializer<'_, Error> = "did:example:123".into_deserializer();
let did = Did::deserialize(input)?;
assert_eq!(did.as_str(), "did:example:123");

let input: StrDeserializer<'_, Error> = "did:example:".into_deserializer();
assert!(Did::deserialize(input).is_err());

Implementations§

Source §

impl Did

Source

pub fn parse(s: &str) -> Result<Self, DidError>

Parses a DID, rejecting input longer than DEFAULT_MAX_LEN bytes.

§Errors

Returns a DidError describing the first violation of the DID syntax.

§Examples

use identity_kit::did::{Did, DidError};

let did = Did::parse("did:example:123456789abcdefghi")?;
assert_eq!(did.method(), "example");
assert_eq!(did.method_specific_id(), "123456789abcdefghi");

assert_eq!(Did::parse("example:123"), Err(DidError::MissingScheme));
assert_eq!(Did::parse("did:example:a:"), Err(DidError::EmptyMethodSpecificId));
assert_eq!(
    Did::parse("did:example:ab%2"),
    Err(DidError::InvalidPercentEncoding { position: 14 })
);

Source

pub fn parse_with_max_len(s: &str, max_len: usize) -> Result<Self, DidError>

Parses a DID, rejecting input longer than max_len bytes with DidError::TooLong.

§Errors

Returns a DidError describing the first violation of the DID syntax.

Source

pub fn method(&self) -> &str

The method name, for example web in did:web:example.com.

Source

pub fn method_specific_id(&self) -> &str

The method-specific id, for example example.com in did:web:example.com.

Source

pub fn as_str(&self) -> &str

The DID as it was parsed.

Source

pub fn to_url(&self) -> DidUrl

This DID as a DidUrl without path, query or fragment.

Source

pub fn join(&self, relative: &str) -> Result<DidUrl, DidError>

Appends a relative reference ("#key-1", "/path", "?versionId=1" or a combination such as "/path?versionId=1#key-1") to this DID.

The relative reference is taken as already percent-encoded. An empty reference yields the same as Did::to_url.

§Errors

Returns DidError::InvalidPath when relative does not start with /, ? or #, the respective DidError when a component is not valid per RFC 3986, and DidError::TooLong when the DID URL would exceed DEFAULT_MAX_LEN bytes.

§Examples

use identity_kit::did::{Did, DidError};

let did = Did::parse("did:example:123")?;

let key = did.join("#key-1")?;
assert_eq!(key.fragment(), Some("key-1"));
assert_eq!(key.to_string(), "did:example:123#key-1");

let versioned = did.join("/path?versionId=1")?;
assert_eq!(versioned.path(), Some("/path"));
assert_eq!(versioned.query(), Some("versionId=1"));
assert_eq!(versioned.fragment(), None);

assert_eq!(did.join("key-1"), Err(DidError::InvalidPath));