Struct DhtKey 

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

DHT key derived from trust root and capability path.

A 256-bit hash used as the key in a Kademlia-style DHT. Keys are derived deterministically from trust root and capability path, enabling capability-based discovery.

Key Derivation

key = SHA256(trust_root || "/" || capability_path)

Examples

use agent_uri::{TrustRoot, CapabilityPath};
use agent_uri_dht::DhtKey;

let trust_root = TrustRoot::parse("anthropic.com").unwrap();
let path = CapabilityPath::parse("assistant/chat").unwrap();
let key = DhtKey::derive(&trust_root, &path);

// Keys are deterministic
let key2 = DhtKey::derive(&trust_root, &path);
assert_eq!(key, key2);

Implementations

impl DhtKey

pub const fn from_bytes(bytes: [u8; 32]) -> Self

Creates a DhtKey from raw bytes.

Arguments

• bytes - 32-byte array representing the key

pub const fn as_bytes(&self) -> &[u8; 32]

Returns the key as a byte slice.

pub fn derive(trust_root: &TrustRoot, capability_path: &CapabilityPath) -> Self

Derives a DHT key from trust root and capability path.

The key is computed as: SHA256(trust_root || "/" || capability_path)

Arguments

• trust_root - The trust root (authority)
• capability_path - The capability path

Returns

A deterministic 256-bit key for DHT lookup.

pub fn derive_at_depth( trust_root: &TrustRoot, capability_path: &CapabilityPath, depth: usize, ) -> Option<Self>

Derives a DHT key for a specific path depth (prefix query support).

This enables hierarchical discovery by deriving keys for path prefixes.

Arguments

• trust_root - The trust root (authority)
• capability_path - The full capability path
• depth - The number of path segments to include (1-indexed)

Returns

A key for the path truncated to the specified depth. Returns None if depth is 0 or exceeds the path depth.

Examples

use agent_uri::{TrustRoot, CapabilityPath};
use agent_uri_dht::DhtKey;

let trust_root = TrustRoot::parse("anthropic.com").unwrap();
let path = CapabilityPath::parse("assistant/chat/streaming").unwrap();

// Key for "assistant" only
let key1 = DhtKey::derive_at_depth(&trust_root, &path, 1).unwrap();

// Key for "assistant/chat"
let key2 = DhtKey::derive_at_depth(&trust_root, &path, 2).unwrap();

// Full path key
let key3 = DhtKey::derive_at_depth(&trust_root, &path, 3).unwrap();
assert_eq!(key3, DhtKey::derive(&trust_root, &path));

pub fn distance(&self, other: &Self) -> Self

Computes the XOR distance to another key.

This is the fundamental distance metric for Kademlia routing. Closer keys (lower XOR distance) are more likely to be stored on the same or nearby nodes.

Arguments

• other - The key to compute distance to

Returns

A DhtKey representing the XOR distance (interpretable as a 256-bit unsigned integer).

pub fn leading_zeros(&self) -> u32

Returns the leading zero bits in the key.

Useful for Kademlia bucket calculations.

Trait Implementations

impl AsRef<[u8]> for DhtKey

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for DhtKey

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DhtKey

impl Debug for DhtKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DhtKey

Available on crate feature serde only.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DhtKey

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

Formats the value using the given formatter.

impl Eq for DhtKey

impl Hash for DhtKey

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 DhtKey

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 DhtKey

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for DhtKey

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 DhtKey

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DhtKey