anp 0.7.1

Rust SDK for Agent Network Protocol (ANP)
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

use std::fs;
use std::path::PathBuf;

use anp::authentication::{create_did_wba_document, DidDocumentOptions, DidProfile};

fn main() {
    let mut profile = DidProfile::E1;
    let mut hostname = "demo.agent-network".to_string();

    let mut args = std::env::args().skip(1);
    while let Some(arg) = args.next() {
        match arg.as_str() {
            "--profile" => {
                if let Some(value) = args.next() {
                    profile = DidProfile::from_str(&value)
                        .expect("profile must be one of: e1, k1, plain_legacy");
                }
            }
            "--hostname" => {
                hostname = args.next().expect("hostname value is required");
            }
            _ => {}
        }
    }

    let bundle = create_did_wba_document(
        &hostname,
        DidDocumentOptions::default()
            .with_profile(profile)
            .with_path_segments(["agents", "demo"])
            .with_agent_description_url(format!("https://{hostname}/agents/demo")),
    )
    .expect("DID creation should succeed");

    let output_dir = PathBuf::from("examples/generated").join(profile.as_str());
    fs::create_dir_all(&output_dir).expect("output directory should be created");

    let did_path = output_dir.join("did.json");
    fs::write(
        &did_path,
        serde_json::to_vec_pretty(&bundle.did_document).expect("DID document should serialize"),
    )
    .expect("DID document should be written");
    println!("DID document saved to {}", did_path.display());

    for (fragment, key_pair) in &bundle.keys {
        let private_path = output_dir.join(format!("{}_private.pem", fragment));
        let public_path = output_dir.join(format!("{}_public.pem", fragment));
        fs::write(&private_path, &key_pair.private_key_pem).expect("private key should be written");
        fs::write(&public_path, &key_pair.public_key_pem).expect("public key should be written");
        println!(
            "Registered verification method {} -> private key: {} public key: {}",
            fragment,
            private_path.file_name().unwrap().to_string_lossy(),
            public_path.file_name().unwrap().to_string_lossy(),
        );
    }

    println!(
        "Generated DID identifier: {}",
        bundle.did().unwrap_or("<unknown>")
    );
    if let Some(proof) = bundle.did_document.get("proof") {
        println!(
            "Generated proof profile: {} {}",
            proof
                .get("type")
                .and_then(serde_json::Value::as_str)
                .unwrap_or("<unknown>"),
            proof
                .get("cryptosuite")
                .and_then(serde_json::Value::as_str)
                .unwrap_or("<legacy>"),
        );
    }
}