ubl-id 0.3.0

Universal Business Ledger identity primitives: DIDs (did:ubl:*), CIDs (cid:blake3:*), Wallets, and PoP headers. RFC-0001 compliant.
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

//! DID and alias resolution against a UBL Directory
//!
//! Requires the `resolve` feature:
//! ```toml
//! ubl-id = { version = "0.2", features = ["resolve"] }
//! ```

use serde::{Deserialize, Serialize};

/// Subject information from the Directory
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Subject {
    pub did: String,
    pub kind: String,
    pub display_name: Option<String>,
    pub metadata: Option<serde_json::Value>,
}

/// Wallet registration in the Directory
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WalletInfo {
    pub did: String,
    pub owner_did: String,
    pub expires_at: Option<i64>,
}

/// Resolve a `namespace/name` alias to a DID
pub fn alias(dir_base: &str, namespace: &str, name: &str) -> Result<Option<String>, String> {
    let url = format!(
        "{}/v1/aliases/{}/{}",
        dir_base.trim_end_matches('/'),
        namespace,
        name
    );
    let resp = ureq::get(&url).call();
    match resp {
        Ok(r) => {
            let v: serde_json::Value = r.into_json().map_err(|e| e.to_string())?;
            Ok(v.get("did").and_then(|s| s.as_str()).map(|s| s.to_string()))
        }
        Err(ureq::Error::Status(404, _)) => Ok(None),
        Err(e) => Err(format!("{}", e)),
    }
}

/// Resolve a DID to subject information
pub fn subject(dir_base: &str, did: &str) -> Result<Option<Subject>, String> {
    // Simple percent-encoding for DID colons
    let encoded_did = did.replace(':', "%3A");
    let url = format!(
        "{}/v1/subjects/{}",
        dir_base.trim_end_matches('/'),
        encoded_did
    );
    let resp = ureq::get(&url).call();
    match resp {
        Ok(r) => {
            let s: Subject = r.into_json().map_err(|e| e.to_string())?;
            Ok(Some(s))
        }
        Err(ureq::Error::Status(404, _)) => Ok(None),
        Err(e) => Err(format!("{}", e)),
    }
}

/// Lookup wallet information (owner binding)
pub fn wallet(dir_base: &str, wallet_did: &str) -> Result<Option<WalletInfo>, String> {
    let encoded_did = wallet_did.replace(':', "%3A");
    let url = format!(
        "{}/v1/wallets/{}",
        dir_base.trim_end_matches('/'),
        encoded_did
    );
    let resp = ureq::get(&url).call();
    match resp {
        Ok(r) => {
            let w: WalletInfo = r.into_json().map_err(|e| e.to_string())?;
            Ok(Some(w))
        }
        Err(ureq::Error::Status(404, _)) => Ok(None),
        Err(e) => Err(format!("{}", e)),
    }
}

/// Register a wallet with the Directory
pub fn register_wallet(
    dir_base: &str,
    bearer_token: &str,
    pub_jwk: &crate::wallet::JwkPub,
    ttl_secs: Option<i64>,
) -> Result<WalletInfo, String> {
    let url = format!("{}/v1/wallets", dir_base.trim_end_matches('/'));
    let body = serde_json::json!({
        "pub_jwk": pub_jwk,
        "ttl_secs": ttl_secs.unwrap_or(3600)
    });
    let resp = ureq::post(&url)
        .set("authorization", &format!("Bearer {}", bearer_token))
        .set("content-type", "application/json")
        .send_json(&body)
        .map_err(|e| format!("request failed: {}", e))?;
    resp.into_json().map_err(|e| format!("json error: {}", e))
}