Struct DidMethod 

pub struct DidMethod { /* private fields */ }

A DID method, named with an optional namespace: did:demo or did:demo:dev.

Parties that declare or negotiate support for DID methods (SIOPv2’s subject_syntax_types_supported, a wallet’s configuration, a resolver’s registry) exchange method identifiers rather than DIDs. A DidMethod is such an identifier: the method name of DID Core §3.1 (method-name = 1*method-char, lowercase ASCII letters and digits only), optionally followed by one idchar segment that names a namespace within the method, as dev in did:demo:dev or zXYZ in did:ebsi:zXYZ. SIOPv2 lists methods without a namespace; wallets and issuers that distinguish networks of one method exchange the namespaced form; both parse.

A DidMethod is validated when it is constructed and keeps the input unchanged. It displays, serializes and deserializes as did:<name> or did:<name>:<namespace>, where deserialization validates. Equality is field-wise; the ordering is by name, then namespace, with the bare method before its namespaced forms.

DidMethod::matches tells whether a Did belongs to the method: its method name is equal and, when a namespace is set, the first colon-separated segment of its method-specific id is that namespace. Did::method keeps returning the name as a &str; DidMethod::from(&did) is the method of a DID, without a namespace.

Errors

A method name that is empty or has a character outside a-z and 0-9 is DidError::InvalidMethodName, as it is for a Did. A namespace that is empty, has a second segment (did:demo:dev:x) or a character that is not an idchar is DidError::InvalidNamespace; an incomplete percent-encoding in it is DidError::InvalidPercentEncoding. Parsing a string also reports DidError::MissingScheme and DidError::TooLong as Did::parse does. Positions are byte offsets into the input that was given: the string for the parsing forms, the name for DidMethod::new, the namespace for DidMethod::with_namespace.

Examples

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

let demo: DidMethod = "did:demo".parse()?;
let namespaced = DidMethod::new("demo")?.with_namespace("dev")?;
assert_eq!(demo.name(), "demo");
assert_eq!(demo.namespace(), None);
assert_eq!(namespaced.namespace(), Some("dev"));
assert_eq!(namespaced.to_string(), "did:demo:dev");

let did = Did::parse("did:demo:dev:0xabc")?;
assert!(demo.matches(&did));
assert!(namespaced.matches(&did));
assert!(!DidMethod::parse("did:demo:alt")?.matches(&did));
assert_eq!(DidMethod::from(&did), demo);

// The method name is lowercase; the namespace is one non-empty segment.
assert_eq!(
    DidMethod::parse("did:Example"),
    Err(DidError::InvalidMethodName { position: 4 })
);
assert_eq!(
    DidMethod::parse("did:demo:"),
    Err(DidError::InvalidNamespace { position: 9 })
);
assert_eq!(
    DidMethod::parse("did:demo:dev:x"),
    Err(DidError::InvalidNamespace { position: 12 })
);

Implementations

impl DidMethod

pub fn new(name: impl Into<String>) -> Result<Self, DidError>

A method named name, without a namespace.

Errors

Returns DidError::InvalidMethodName when name is empty or has a character outside a-z and 0-9, with the byte offset into name.

Examples

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

assert_eq!(DidMethod::new("web")?.to_string(), "did:web");
assert_eq!(
    DidMethod::new("ex_ample"),
    Err(DidError::InvalidMethodName { position: 2 })
);

pub fn with_namespace( self, namespace: impl Into<String>, ) -> Result<Self, DidError>

This method with its namespace set to namespace.

Errors

Returns DidError::InvalidNamespace when namespace is empty or has a character that is not an idchar (a : among them), or DidError::InvalidPercentEncoding when a % is not followed by two hexadecimal digits, with the byte offset into namespace.

Examples

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

let ebsi = DidMethod::new("ebsi")?;
assert_eq!(ebsi.clone().with_namespace("zXYZ")?.to_string(), "did:ebsi:zXYZ");
assert_eq!(
    ebsi.with_namespace("a:b"),
    Err(DidError::InvalidNamespace { position: 1 })
);

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

Parses did:<name> or did:<name>:<namespace>, rejecting input longer than DEFAULT_MAX_LEN bytes.

Errors

Returns a DidError describing the first violation, as listed for DidMethod.

Examples

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

let method = DidMethod::parse("did:ebsi:zXYZ")?;
assert_eq!(method.name(), "ebsi");
assert_eq!(method.namespace(), Some("zXYZ"));

assert_eq!(DidMethod::parse("ebsi"), Err(DidError::MissingScheme));

pub fn name(&self) -> &str

The method name: demo in did:demo:dev.

pub fn namespace(&self) -> Option<&str>

The namespace within the method: dev in did:demo:dev, None in did:demo.

pub fn matches(&self, did: &Did) -> bool

Whether did belongs to this method: its method name is name and, when a namespace is set, the first colon-separated segment of its method-specific id is that namespace.

Examples

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

let did = Did::parse("did:demo:dev:0xabc")?;
assert!(DidMethod::parse("did:demo")?.matches(&did));
assert!(DidMethod::parse("did:demo:dev")?.matches(&did));
assert!(!DidMethod::parse("did:demo:alt")?.matches(&did));
assert!(!DidMethod::parse("did:web")?.matches(&did));

Trait Implementations

impl Clone for DidMethod

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DidMethod

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DidMethod

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for DidMethod

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

Formats the value using the given formatter.

impl Eq for DidMethod

impl From<&Did> for DidMethod

The method of a DID, without a namespace: did:demo for did:demo:dev:0xabc.

fn from(did: &Did) -> Self

Converts to this type from the input type.

impl FromStr for DidMethod

type Err = DidError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for DidMethod

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

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 Ord for DidMethod

fn cmp(&self, other: &Self) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for DidMethod

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for DidMethod

fn partial_cmp(&self, other: &Self) -> 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 DidMethod

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DidMethod

impl TryFrom<&str> for DidMethod

type Error = DidError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for DidMethod

type Error = DidError

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<Self, Self::Error>

Performs the conversion.