use thiserror::Error;
use crate::event::{Coordinate, Event, EventBuilder, EventId, Kind, Tag, TagKind};
use crate::key::PublicKey;
use crate::types::RelayUrl;
pub const KIND_USER_ASSERTION: Kind = Kind::USER_ASSERTION;
pub const KIND_EVENT_ASSERTION: Kind = Kind::EVENT_ASSERTION;
pub const KIND_ADDRESS_ASSERTION: Kind = Kind::ADDRESS_ASSERTION;
pub const KIND_EXTERNAL_ID_ASSERTION: Kind = Kind::EXTERNAL_ID_ASSERTION;
pub const KIND_TRUSTED_PROVIDER_LIST: Kind = Kind::TRUSTED_PROVIDER_LIST;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum AssertionSubject {
User(PublicKey),
Event(EventId),
Address(Coordinate),
ExternalId(String),
}
impl AssertionSubject {
#[must_use]
pub const fn kind(&self) -> Kind {
match self {
Self::User(_) => KIND_USER_ASSERTION,
Self::Event(_) => KIND_EVENT_ASSERTION,
Self::Address(_) => KIND_ADDRESS_ASSERTION,
Self::ExternalId(_) => KIND_EXTERNAL_ID_ASSERTION,
}
}
#[must_use]
pub fn identifier(&self) -> String {
match self {
Self::User(pubkey) => pubkey.to_hex(),
Self::Event(id) => id.to_hex(),
Self::Address(coordinate) => coordinate.to_wire(),
Self::ExternalId(id) => id.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TrustedAssertion {
pub subject: AssertionSubject,
pub attributes: Vec<(String, String)>,
}
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum AssertionError {
#[error("unexpected kind for NIP-85: {}", .0.as_u16())]
WrongKind(Kind),
#[error("NIP-85 assertion missing required `d` tag")]
MissingSubject,
#[error("NIP-85 `d` tag does not decode as the expected subject: {0}")]
InvalidSubject(String),
}
impl TrustedAssertion {
#[must_use]
pub const fn new(subject: AssertionSubject, attributes: Vec<(String, String)>) -> Self {
Self {
subject,
attributes,
}
}
#[must_use]
pub fn attribute(&self, name: &str) -> Option<&str> {
self.attributes
.iter()
.find(|(key, _)| key == name)
.map(|(_, value)| value.as_str())
}
#[must_use]
pub fn rank(&self) -> Option<u8> {
self.attribute("rank")?.parse().ok()
}
pub fn from_event(event: &Event) -> Result<Self, AssertionError> {
let raw = event
.tags
.identifier()
.ok_or(AssertionError::MissingSubject)?;
let invalid = || AssertionError::InvalidSubject(raw.to_owned());
let subject = match event.kind {
KIND_USER_ASSERTION => {
AssertionSubject::User(PublicKey::parse(raw).map_err(|_err| invalid())?)
}
KIND_EVENT_ASSERTION => {
AssertionSubject::Event(EventId::parse(raw).map_err(|_err| invalid())?)
}
KIND_ADDRESS_ASSERTION => {
AssertionSubject::Address(Coordinate::parse(raw).map_err(|_err| invalid())?)
}
KIND_EXTERNAL_ID_ASSERTION => AssertionSubject::ExternalId(raw.to_owned()),
other => return Err(AssertionError::WrongKind(other)),
};
let attributes = event
.tags
.iter()
.filter(|tag| tag.name() != "d")
.filter_map(|tag| Some((tag.name().to_owned(), tag.content()?.to_owned())))
.collect();
Ok(Self {
subject,
attributes,
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProviderEntry {
pub result_type: String,
pub service: PublicKey,
pub relay: Option<RelayUrl>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ProviderList {
pub entries: Vec<ProviderEntry>,
}
impl ProviderList {
pub fn from_event(event: &Event) -> Result<Self, AssertionError> {
if event.kind != KIND_TRUSTED_PROVIDER_LIST {
return Err(AssertionError::WrongKind(event.kind));
}
Ok(Self {
entries: Self::entries_from_tags(event.tags.iter()),
})
}
pub fn entries_from_tags<'t, I>(tags: I) -> Vec<ProviderEntry>
where
I: IntoIterator<Item = &'t Tag>,
{
tags.into_iter()
.filter_map(|tag| {
let head = tag.name();
let (kind_part, _tag_part) = head.split_once(':')?;
kind_part.parse::<u16>().ok()?;
let service = PublicKey::parse(tag.content()?).ok()?;
let relay = tag.get(2).and_then(|raw| RelayUrl::parse(raw).ok());
Some(ProviderEntry {
result_type: head.to_owned(),
service,
relay,
})
})
.collect()
}
}
impl EventBuilder {
#[must_use]
pub fn trusted_assertion(assertion: &TrustedAssertion) -> Self {
let mut builder =
Self::new(assertion.subject.kind(), "").tag(Tag::d(assertion.subject.identifier()));
for (name, value) in &assertion.attributes {
builder = builder.tag(Tag::with(&TagKind::from_wire(name), [value.clone()]));
}
builder
}
#[must_use]
pub fn trusted_provider_list<I>(entries: I) -> Self
where
I: IntoIterator<Item = ProviderEntry>,
{
Self::new(KIND_TRUSTED_PROVIDER_LIST, "").tags(entries.into_iter().map(|entry| {
let head = TagKind::from_wire(&entry.result_type);
let mut args = vec![entry.service.to_hex()];
if let Some(relay) = &entry.relay {
args.push(relay.as_str().to_owned());
}
Tag::with(&head, args)
}))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Keys;
fn keys() -> Keys {
Keys::parse("0000000000000000000000000000000000000000000000000000000000000003").unwrap()
}
fn subject_pubkey() -> PublicKey {
PublicKey::parse("e88a691e98d9987c964521dff60025f60700378a4879180dcbbb4a5027850411")
.unwrap()
}
#[test]
fn user_assertion_round_trip() {
let assertion = TrustedAssertion::new(
AssertionSubject::User(subject_pubkey()),
vec![
("rank".to_owned(), "89".to_owned()),
("followers".to_owned(), "1200".to_owned()),
],
);
let event = EventBuilder::trusted_assertion(&assertion)
.sign_with_keys(&keys())
.unwrap();
assert_eq!(event.kind, KIND_USER_ASSERTION);
let parsed = TrustedAssertion::from_event(&event).unwrap();
assert_eq!(parsed, assertion);
assert_eq!(parsed.rank(), Some(89));
assert_eq!(parsed.attribute("followers"), Some("1200"));
}
#[test]
fn address_assertion_round_trip() {
let coordinate =
Coordinate::parse(format!("30023:{}:my-article", subject_pubkey().to_hex())).unwrap();
let assertion = TrustedAssertion::new(
AssertionSubject::Address(coordinate.clone()),
vec![("rank".to_owned(), "42".to_owned())],
);
let event = EventBuilder::trusted_assertion(&assertion)
.sign_with_keys(&keys())
.unwrap();
assert_eq!(event.kind, KIND_ADDRESS_ASSERTION);
let parsed = TrustedAssertion::from_event(&event).unwrap();
assert_eq!(parsed.subject, AssertionSubject::Address(coordinate));
}
#[test]
fn external_id_assertion_round_trip() {
let assertion = TrustedAssertion::new(
AssertionSubject::ExternalId("isbn:9780765382030".to_owned()),
vec![("rank".to_owned(), "77".to_owned())],
);
let event = EventBuilder::trusted_assertion(&assertion)
.sign_with_keys(&keys())
.unwrap();
assert_eq!(event.kind, KIND_EXTERNAL_ID_ASSERTION);
let parsed = TrustedAssertion::from_event(&event).unwrap();
assert_eq!(parsed, assertion);
}
#[test]
fn invalid_subject_is_rejected() {
let event = EventBuilder::new(KIND_USER_ASSERTION, "")
.tag(Tag::d("not-a-pubkey"))
.sign_with_keys(&keys())
.unwrap();
assert!(matches!(
TrustedAssertion::from_event(&event),
Err(AssertionError::InvalidSubject(_))
));
}
#[test]
fn missing_subject_is_rejected() {
let event = EventBuilder::new(KIND_USER_ASSERTION, "")
.sign_with_keys(&keys())
.unwrap();
assert!(matches!(
TrustedAssertion::from_event(&event),
Err(AssertionError::MissingSubject)
));
}
#[test]
fn provider_list_round_trip() {
let entries = vec![
ProviderEntry {
result_type: "30382:rank".to_owned(),
service: subject_pubkey(),
relay: Some(RelayUrl::parse("wss://nip85.example/").unwrap()),
},
ProviderEntry {
result_type: "30382:zap_amt_sent".to_owned(),
service: subject_pubkey(),
relay: None,
},
];
let event = EventBuilder::trusted_provider_list(entries.clone())
.sign_with_keys(&keys())
.unwrap();
let parsed = ProviderList::from_event(&event).unwrap();
assert_eq!(parsed.entries, entries);
}
#[test]
fn non_provider_tags_are_skipped() {
let event = EventBuilder::new(KIND_TRUSTED_PROVIDER_LIST, "")
.tag(Tag::alt("provider list"))
.sign_with_keys(&keys())
.unwrap();
let parsed = ProviderList::from_event(&event).unwrap();
assert!(parsed.entries.is_empty());
}
}