hanzo-did 1.1.11

Hanzo AI - Did Library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! DID Resolution
//! 
//! Based on: https://www.w3.org/TR/did-core/#resolution

use async_trait::async_trait;
use std::collections::HashMap;

use crate::{DID, DIDDocument, DIDError};

/// DID Resolver trait
#[async_trait]
pub trait DIDResolver {
    /// Resolve a DID to its document
    async fn resolve(&self, did: &DID) -> Result<DIDDocument, DIDError>;
    
    /// Resolve with options
    async fn resolve_with_options(
        &self,
        did: &DID,
        options: ResolveOptions,
    ) -> Result<ResolveResult, DIDError>;
}

/// Options for DID resolution
#[derive(Debug, Default)]
pub struct ResolveOptions {
    /// Accept header for content negotiation
    pub accept: Option<String>,
    
    /// Version of the DID document to retrieve
    pub version_id: Option<String>,
    
    /// Timestamp to retrieve document at
    pub version_time: Option<String>,
    
    /// Whether to dereference fragments
    pub no_cache: bool,
}

/// Result of DID resolution
#[derive(Debug)]
pub struct ResolveResult {
    /// The resolved DID document
    pub document: DIDDocument,
    
    /// Resolution metadata
    pub metadata: ResolutionMetadata,
    
    /// Document metadata
    pub document_metadata: DocumentMetadata,
}

/// Metadata about the resolution process
#[derive(Debug, Default)]
pub struct ResolutionMetadata {
    /// Content type of the document
    pub content_type: Option<String>,
    
    /// Error message if resolution failed
    pub error: Option<String>,
    
    /// Additional properties
    pub properties: HashMap<String, serde_json::Value>,
}

/// Metadata about the DID document
#[derive(Debug, Default)]
pub struct DocumentMetadata {
    /// When the document was created
    pub created: Option<String>,
    
    /// When the document was last updated
    pub updated: Option<String>,
    
    /// Whether the DID has been deactivated
    pub deactivated: Option<bool>,
    
    /// Version ID of this document
    pub version_id: Option<String>,
    
    /// Next version ID
    pub next_version_id: Option<String>,
    
    /// Canonical ID
    pub canonical_id: Option<String>,
    
    /// Equivalent IDs
    pub equivalent_id: Option<Vec<String>>,
}

/// Universal DID Resolver supporting multiple methods
pub struct UniversalResolver {
    resolvers: HashMap<String, Box<dyn DIDResolver + Send + Sync>>,
}

impl Default for UniversalResolver {
    fn default() -> Self {
        Self::new()
    }
}

impl UniversalResolver {
    /// Create a new universal resolver
    pub fn new() -> Self {
        Self {
            resolvers: HashMap::new(),
        }
    }
    
    /// Register a resolver for a DID method
    pub fn register_resolver(
        &mut self,
        method: String,
        resolver: Box<dyn DIDResolver + Send + Sync>,
    ) {
        self.resolvers.insert(method, resolver);
    }
}

#[async_trait]
impl DIDResolver for UniversalResolver {
    async fn resolve(&self, did: &DID) -> Result<DIDDocument, DIDError> {
        let resolver = self.resolvers
            .get(&did.method)
            .ok_or_else(|| DIDError::ResolutionFailed(
                format!("No resolver for method: {}", did.method)
            ))?;
        
        resolver.resolve(did).await
    }
    
    async fn resolve_with_options(
        &self,
        did: &DID,
        options: ResolveOptions,
    ) -> Result<ResolveResult, DIDError> {
        let resolver = self.resolvers
            .get(&did.method)
            .ok_or_else(|| DIDError::ResolutionFailed(
                format!("No resolver for method: {}", did.method)
            ))?;
        
        resolver.resolve_with_options(did, options).await
    }
}