Struct AccountDid 

pub struct AccountDid {
    did: String,
    host: String,
    port: Option<u16>,
}

A validated did:web belonging to one agent.

Held as the exact DID string plus its decoded authority, so that neither the identifier nor the fetch URL has to be recomputed — and so that the decoded form can never disagree with the encoded one.

Fields

did: String

The DID exactly as it is written, port colon still encoded.

host: String

Decoded hostname, without a port.

port: Option<u16>

Decoded port, if the DID carried one.

Implementations

impl AccountDid

pub fn mint(zone: &Zone, account_id: &str) -> Result<Self, DidError>

Mints the DID for account_id within zone.

Produces did:web:<account_id>.<zone host>, which resolves at https://<account_id>.<zone host>/.well-known/did.json — no port, because the spec allows one only for a bare loopback hostname and an account is a subdomain of its zone.

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

Parses and validates an agent did:web.

pub fn account_id(&self) -> &str

The agent’s own label: the leftmost component of the hostname.

pub fn host(&self) -> &str

The decoded hostname, without any port.

pub fn port(&self) -> Option<u16>

The decoded port, if this is a development DID that carries one.

pub fn authority(&self) -> String

The decoded authority: host, or host:port for a development DID.

This is the did:web identifier with its port colon decoded, which is what an atproto record key may contain — : is in the record-key character set and % is not. Anything keying a record by the server a DID names has to use this rather than the encoded form Self::as_str carries, and both sides of bot.did.operator do: didbot operate writes at this key and the server’s own poll reads at it. Deriving it here rather than at each end is what stops the two from disagreeing.

pub fn is_loopback(&self) -> bool

Whether this DID names a loopback host, and so is development-only.

pub fn did_json_url(&self) -> String

The URL the DID document is served at. Always https://: every server this project runs terminates TLS, on a developer’s machine as much as anywhere else.

A DID carries no port, so this is port 443 — except for a loopback host RESOLVE_PORTS names, which is how a harness reaches several servers at once on one machine.

pub fn as_str(&self) -> &str

The DID as written, with the port colon still encoded.

Trait Implementations

impl Clone for AccountDid

fn clone(&self) -> AccountDid

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccountDid

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

Formats the value using the given formatter.

impl Display for AccountDid

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

Formats the value using the given formatter.

impl FromStr for AccountDid

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 AccountDid

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 PartialEq for AccountDid

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

impl StructuralPartialEq for AccountDid