did-pkarr 0.0.0

PKARR based Decentralized Identifiers
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
146
147
148
149
150
151
152
153
154
155

use std::{future::Future, time::SystemTime};

pub use pkarr::Client;
use pkarr::Timestamp;

use crate::{
	doc::{ToPkarrErr, TryFromSignedPacketErr},
	DidPkarr, DidPkarrDocument,
};

#[derive(Debug, thiserror::Error)]
pub enum ResolveErr {
	#[error("could not resolve with PKARR")]
	NotFound,
	#[error("failed to convert from pkarr into DID Document")]
	Invalid(#[from] TryFromSignedPacketErr),
}

#[derive(Debug, thiserror::Error)]
pub enum PublishErr {
	#[error("failed to convert from DID Document to pkarr")]
	ToPkarr(#[from] ToPkarrErr),
	#[error("failed to publish with pkarr client")]
	IoErr(#[from] pkarr::errors::PublishError),
}

#[cfg(any(feature = "dht", feature = "http"))]
pub trait PkarrClientExt {
	/// Like [`pkarr::Client::resolve`] but for DIDs.
	fn resolve(
		&self,
		did: &DidPkarr,
	) -> impl Future<Output = Result<DidPkarrDocument, ResolveErr>> + Send;

	/// Like [`pkarr::Client::resolve_most_recent`] but for DIDs.
	fn resolve_most_recent(
		&self,
		did: &DidPkarr,
	) -> impl Future<Output = Result<DidPkarrDocument, ResolveErr>> + Send;

	/// Like [`pkarr::Client::publish`] but for DIDs.
	fn publish(
		&self,
		doc: &DidPkarrDocument,
		timestamp: Option<Timestamp>,
		signing_key: &ed25519_dalek::SigningKey,
	) -> impl Future<Output = Result<(), PublishErr>> + Send;
}

#[cfg(any(feature = "dht", feature = "http"))]
pub trait PkarrClientBlockingExt {
	/// Like [`pkarr::Client::resolve`] but for DIDs.
	fn resolve(&self, did: &DidPkarr) -> Result<DidPkarrDocument, ResolveErr>;

	/// Like [`pkarr::Client::resolve_most_recent`] but for DIDs.
	fn resolve_most_recent(
		&self,
		did: &DidPkarr,
	) -> Result<DidPkarrDocument, ResolveErr>;

	/// Like [`pkarr::Client::publish`] but for DIDs.
	fn publish(
		&self,
		doc: &DidPkarrDocument,
		timestamp: Option<Timestamp>,
		signing_key: &ed25519_dalek::SigningKey,
	) -> Result<(), PublishErr>;
}

#[cfg(any(feature = "dht", feature = "http"))]
impl PkarrClientExt for pkarr::Client {
	async fn resolve(&self, did: &DidPkarr) -> Result<DidPkarrDocument, ResolveErr> {
		{
			let public_key = pkarr::PublicKey::try_from(did.as_pubkey()).unwrap();
			let Some(packet) = self.resolve(&public_key).await else {
				return Err(ResolveErr::NotFound);
			};

			DidPkarrDocument::try_from(packet).map_err(ResolveErr::from)
		}
	}

	async fn resolve_most_recent(
		&self,
		did: &DidPkarr,
	) -> Result<DidPkarrDocument, ResolveErr> {
		let public_key = pkarr::PublicKey::try_from(did.as_pubkey()).unwrap();
		let Some(packet) = self.resolve_most_recent(&public_key).await else {
			return Err(ResolveErr::NotFound);
		};

		DidPkarrDocument::try_from(packet).map_err(ResolveErr::from)
	}

	async fn publish(
		&self,
		doc: &DidPkarrDocument,
		timestamp: Option<Timestamp>,
		signing_key: &ed25519_dalek::SigningKey,
	) -> Result<(), PublishErr> {
		let timestamp = if let Some(timestamp) = timestamp {
			timestamp
		} else {
			SystemTime::now().into()
		};
		let signed_packet = doc.to_pkarr_packet(signing_key, timestamp)?;

		self.publish(&signed_packet, Some(timestamp))
			.await
			.map_err(PublishErr::from)
	}
}

#[cfg(any(feature = "dht", feature = "http"))]
impl PkarrClientBlockingExt for pkarr::ClientBlocking {
	fn resolve(&self, did: &DidPkarr) -> Result<DidPkarrDocument, ResolveErr> {
		{
			let public_key = pkarr::PublicKey::try_from(did.as_pubkey()).unwrap();
			let Some(packet) = self.resolve(&public_key) else {
				return Err(ResolveErr::NotFound);
			};

			DidPkarrDocument::try_from(packet).map_err(ResolveErr::from)
		}
	}

	fn resolve_most_recent(
		&self,
		did: &DidPkarr,
	) -> Result<DidPkarrDocument, ResolveErr> {
		let public_key = pkarr::PublicKey::try_from(did.as_pubkey()).unwrap();
		let Some(packet) = self.resolve_most_recent(&public_key) else {
			return Err(ResolveErr::NotFound);
		};

		DidPkarrDocument::try_from(packet).map_err(ResolveErr::from)
	}

	fn publish(
		&self,
		doc: &DidPkarrDocument,
		timestamp: Option<Timestamp>,
		signing_key: &ed25519_dalek::SigningKey,
	) -> Result<(), PublishErr> {
		let timestamp = if let Some(timestamp) = timestamp {
			timestamp
		} else {
			SystemTime::now().into()
		};
		let signed_packet = doc.to_pkarr_packet(signing_key, timestamp)?;

		self.publish(&signed_packet, Some(timestamp))
			.map_err(PublishErr::from)
	}
}