use alloc::borrow::ToOwned;
use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;
use core::fmt;
use core::str::FromStr;
use crate::{EventId, Kind, PublicKey, SecretKey};
use bech32::primitives::decode::{CheckedHrpstring, CheckedHrpstringError};
use bech32::{ByteIterExt, Checksum, Fe32, Fe32IterExt, Fe1024, Hrp};
use zeroize::Zeroizing;
pub const BECH32_MAX_LEN: usize = 5000;
pub(crate) enum Nip19Bech32 {}
impl Checksum for Nip19Bech32 {
type MidstateRepr = u32;
type CorrectionField = Fe1024;
const ROOT_GENERATOR: Self::CorrectionField = Fe1024::new([Fe32::P, Fe32::X]);
const ROOT_EXPONENTS: core::ops::RangeInclusive<usize> = 24..=26;
const CODE_LENGTH: usize = BECH32_MAX_LEN;
const CHECKSUM_LENGTH: usize = 6;
const GENERATOR_SH: [u32; 5] = [
0x3b6a_57b2,
0x2650_8e6d,
0x1ea1_19fa,
0x3d42_33dd,
0x2a14_62b3,
];
const TARGET_RESIDUE: u32 = 1;
}
const HRP_NPROFILE: Hrp = Hrp::parse_unchecked("nprofile");
const HRP_NEVENT: Hrp = Hrp::parse_unchecked("nevent");
const HRP_NADDR: Hrp = Hrp::parse_unchecked("naddr");
const HRP_NSEC: Hrp = Hrp::parse_unchecked("nsec");
const HRP_NPUB: Hrp = Hrp::parse_unchecked("npub");
const HRP_NOTE: Hrp = Hrp::parse_unchecked("note");
const TLV_SPECIAL: u8 = 0;
const TLV_RELAY: u8 = 1;
const TLV_AUTHOR: u8 = 2;
const TLV_KIND: u8 = 3;
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("invalid bech32")]
Bech32 {
#[source]
source: DecodeError,
},
#[error("bech32 string exceeds 5000 characters: {len}")]
TooLong {
len: usize,
},
#[error("unknown bech32 prefix {prefix}")]
UnknownPrefix {
prefix: String,
},
#[error("expected a {expected} string, got {found}")]
UnexpectedPrefix {
expected: &'static str,
found: String,
},
#[error("invalid length: expected {expected} bytes, got {found}")]
InvalidLength {
expected: usize,
found: usize,
},
#[error("invalid secret key")]
InvalidSecretKey,
#[error("missing required {tlv}")]
MissingTlv {
tlv: &'static str,
},
#[error("invalid {tlv}")]
InvalidTlv {
tlv: &'static str,
},
#[error("TLV value exceeds 255 bytes: {len}")]
TlvTooLong {
len: usize,
},
#[error("kind {kind} is out of the 0-65535 range")]
KindOutOfRange {
kind: u32,
},
}
#[derive(Debug)]
pub enum DecodeError {
Bech32(CheckedHrpstringError),
Padding,
}
impl fmt::Display for DecodeError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Bech32(error) => fmt::Display::fmt(error, f),
Self::Padding => f.write_str("non-zero padding in bech32 payload"),
}
}
}
impl core::error::Error for DecodeError {}
pub(crate) fn encode_bech32(hrp: Hrp, data: &[u8]) -> String {
data.iter()
.copied()
.bytes_to_fes()
.with_checksum::<Nip19Bech32>(&hrp)
.chars()
.collect()
}
fn encode_bech32_tlv(hrp: Hrp, data: &[u8]) -> Result<String, Error> {
let code = encode_bech32(hrp, data);
if code.len() > BECH32_MAX_LEN {
return Err(Error::TooLong { len: code.len() });
}
Ok(code)
}
pub(crate) fn decode_bech32(code: &str) -> Result<(Hrp, Vec<u8>), DecodeError> {
let checked = CheckedHrpstring::new::<Nip19Bech32>(code).map_err(DecodeError::Bech32)?;
let fes: Vec<Fe32> = checked.fe32_iter().collect();
let leftover = (fes.len() * 5) % 8;
let last = fes.last().map_or(0, |fe| fe.to_u8());
if leftover >= 5 || (leftover > 0 && last & ((1u8 << leftover) - 1) != 0) {
return Err(DecodeError::Padding);
}
Ok((checked.hrp(), fes.iter().copied().fes_to_bytes().collect()))
}
fn decode_nip19_bech32(code: &str) -> Result<(Hrp, Vec<u8>), Error> {
decode_bech32(code).map_err(|e| Error::Bech32 { source: e })
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct ProfilePointer {
pub pubkey: PublicKey,
pub relays: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct EventPointer {
pub id: EventId,
pub relays: Vec<String>,
pub author: Option<PublicKey>,
pub kind: Option<Kind>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct AddressPointer {
pub identifier: String,
pub pubkey: PublicKey,
pub kind: Kind,
pub relays: Vec<String>,
}
#[non_exhaustive]
#[derive(Clone, Debug)]
pub enum Entity {
Profile(ProfilePointer),
Event(EventPointer),
Address(AddressPointer),
Secret(SecretKey),
Public(PublicKey),
Note(EventId),
}
impl Entity {
const fn prefix(&self) -> &'static str {
match self {
Self::Profile(_) => "nprofile",
Self::Event(_) => "nevent",
Self::Address(_) => "naddr",
Self::Secret(_) => "nsec",
Self::Public(_) => "npub",
Self::Note(_) => "note",
}
}
}
type Tlvs<'a> = BTreeMap<u8, Vec<&'a [u8]>>;
fn parse_tlv(data: &[u8]) -> Result<Tlvs<'_>, Error> {
let mut tlvs: Tlvs<'_> = BTreeMap::new();
let mut rest = data;
while !rest.is_empty() {
let Some(&[ty, len]) = rest
.get(..2)
.and_then(|head| <&[u8; 2]>::try_from(head).ok())
else {
return Err(Error::InvalidTlv { tlv: "TLV stream" });
};
let Some((value, tail)) = rest
.get(2..)
.and_then(|body| body.split_at_checked(usize::from(len)))
else {
return Err(Error::InvalidTlv { tlv: "TLV stream" });
};
tlvs.entry(ty).or_default().push(value);
rest = tail;
}
Ok(tlvs)
}
fn first_tlv<'a>(tlvs: &'a Tlvs<'_>, ty: u8) -> Option<&'a [u8]> {
tlvs.get(&ty).and_then(|vs| vs.first()).copied()
}
fn required_tlv<'a>(tlvs: &'a Tlvs<'_>, ty: u8, tlv: &'static str) -> Result<&'a [u8], Error> {
first_tlv(tlvs, ty).ok_or(Error::MissingTlv { tlv })
}
fn tlv_bytes<const N: usize>(tlvs: &Tlvs<'_>, ty: u8, tlv: &'static str) -> Result<[u8; N], Error> {
let value = required_tlv(tlvs, ty, tlv)?;
value.try_into().map_err(|_| Error::InvalidTlv { tlv })
}
fn tlv_relays(tlvs: &Tlvs<'_>) -> Vec<String> {
tlvs.get(&TLV_RELAY).map_or_else(Vec::new, |values| {
values
.iter()
.map(|v| String::from_utf8_lossy(v).into_owned())
.collect()
})
}
fn read_kind(tlvs: &Tlvs<'_>, ty: u8, tlv: &'static str) -> Result<Kind, Error> {
let raw = u32::from_be_bytes(tlv_bytes::<4>(tlvs, ty, tlv)?);
u16::try_from(raw)
.map(Kind::new)
.map_err(|_| Error::KindOutOfRange { kind: raw })
}
fn push_tlv(out: &mut Vec<u8>, ty: u8, value: &[u8]) -> Result<(), Error> {
let len = u8::try_from(value.len()).map_err(|_| Error::TlvTooLong { len: value.len() })?;
out.push(ty);
out.push(len);
out.extend_from_slice(value);
Ok(())
}
impl ProfilePointer {
pub fn to_bech32(&self) -> Result<String, Error> {
let mut data = Vec::new();
push_tlv(&mut data, TLV_SPECIAL, self.pubkey.as_bytes())?;
for relay in &self.relays {
push_tlv(&mut data, TLV_RELAY, relay.as_bytes())?;
}
encode_bech32_tlv(HRP_NPROFILE, &data)
}
pub fn from_bech32(code: &str) -> Result<Self, Error> {
match Entity::from_bech32(code)? {
Entity::Profile(pointer) => Ok(pointer),
other => Err(Error::UnexpectedPrefix {
expected: "nprofile",
found: other.prefix().to_owned(),
}),
}
}
}
impl EventPointer {
pub fn to_bech32(&self) -> Result<String, Error> {
let mut data = Vec::new();
push_tlv(&mut data, TLV_SPECIAL, self.id.as_bytes())?;
for relay in &self.relays {
push_tlv(&mut data, TLV_RELAY, relay.as_bytes())?;
}
if let Some(author) = self.author {
push_tlv(&mut data, TLV_AUTHOR, author.as_bytes())?;
}
if let Some(kind) = self.kind {
push_tlv(&mut data, TLV_KIND, &u32::from(kind.as_u16()).to_be_bytes())?;
}
encode_bech32_tlv(HRP_NEVENT, &data)
}
pub fn from_bech32(code: &str) -> Result<Self, Error> {
match Entity::from_bech32(code)? {
Entity::Event(pointer) => Ok(pointer),
other => Err(Error::UnexpectedPrefix {
expected: "nevent",
found: other.prefix().to_owned(),
}),
}
}
}
impl AddressPointer {
pub fn to_bech32(&self) -> Result<String, Error> {
let mut data = Vec::new();
push_tlv(&mut data, TLV_SPECIAL, self.identifier.as_bytes())?;
for relay in &self.relays {
push_tlv(&mut data, TLV_RELAY, relay.as_bytes())?;
}
push_tlv(&mut data, TLV_AUTHOR, self.pubkey.as_bytes())?;
push_tlv(
&mut data,
TLV_KIND,
&u32::from(self.kind.as_u16()).to_be_bytes(),
)?;
encode_bech32_tlv(HRP_NADDR, &data)
}
pub fn from_bech32(code: &str) -> Result<Self, Error> {
match Entity::from_bech32(code)? {
Entity::Address(pointer) => Ok(pointer),
other => Err(Error::UnexpectedPrefix {
expected: "naddr",
found: other.prefix().to_owned(),
}),
}
}
}
impl Entity {
pub fn to_bech32(&self) -> Result<String, Error> {
match self {
Self::Profile(pointer) => pointer.to_bech32(),
Self::Event(pointer) => pointer.to_bech32(),
Self::Address(pointer) => pointer.to_bech32(),
Self::Secret(secret) => Ok(secret.to_bech32()),
Self::Public(pubkey) => Ok(pubkey.to_bech32()),
Self::Note(id) => Ok(id.to_bech32()),
}
}
pub fn from_bech32(code: &str) -> Result<Self, Error> {
let (hrp, data) = decode_nip19_bech32(code)?;
let data = Zeroizing::new(data);
if hrp == HRP_NPROFILE {
let tlvs = parse_tlv(&data)?;
let pubkey = tlv_bytes::<32>(&tlvs, TLV_SPECIAL, "nprofile pubkey TLV")?;
Ok(Self::Profile(ProfilePointer {
pubkey: PublicKey::from_bytes(pubkey),
relays: tlv_relays(&tlvs),
}))
} else if hrp == HRP_NEVENT {
let tlvs = parse_tlv(&data)?;
let id = tlv_bytes::<32>(&tlvs, TLV_SPECIAL, "nevent id TLV")?;
let author = match first_tlv(&tlvs, TLV_AUTHOR) {
Some(value) => Some(PublicKey::from_bytes(value.try_into().map_err(|_| {
Error::InvalidTlv {
tlv: "nevent author TLV",
}
})?)),
None => None,
};
let kind = match first_tlv(&tlvs, TLV_KIND) {
Some(_) => Some(read_kind(&tlvs, TLV_KIND, "nevent kind TLV")?),
None => None,
};
Ok(Self::Event(EventPointer {
id: EventId::from_bytes(id),
relays: tlv_relays(&tlvs),
author,
kind,
}))
} else if hrp == HRP_NADDR {
let tlvs = parse_tlv(&data)?;
let identifier = required_tlv(&tlvs, TLV_SPECIAL, "naddr identifier TLV")?;
let pubkey = tlv_bytes::<32>(&tlvs, TLV_AUTHOR, "naddr pubkey TLV")?;
let kind = read_kind(&tlvs, TLV_KIND, "naddr kind TLV")?;
Ok(Self::Address(AddressPointer {
identifier: String::from_utf8_lossy(identifier).into_owned(),
pubkey: PublicKey::from_bytes(pubkey),
kind,
relays: tlv_relays(&tlvs),
}))
} else if hrp == HRP_NSEC {
let secret = if data.len() == 32 {
SecretKey::from_slice(&data).map_err(|_| Error::InvalidSecretKey)
} else {
Err(Error::InvalidLength {
expected: 32,
found: data.len(),
})
};
Ok(Self::Secret(secret?))
} else if hrp == HRP_NPUB {
let bytes: [u8; 32] = data
.as_slice()
.try_into()
.map_err(|_| Error::InvalidLength {
expected: 32,
found: data.len(),
})?;
Ok(Self::Public(PublicKey::from_bytes(bytes)))
} else if hrp == HRP_NOTE {
let bytes: [u8; 32] = data
.as_slice()
.try_into()
.map_err(|_| Error::InvalidLength {
expected: 32,
found: data.len(),
})?;
Ok(Self::Note(EventId::from_bytes(bytes)))
} else {
Err(Error::UnknownPrefix {
prefix: hrp.as_str().to_owned(),
})
}
}
}
impl FromStr for Entity {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Error> {
Self::from_bech32(s)
}
}
impl PublicKey {
#[must_use]
pub fn to_bech32(self) -> String {
encode_bech32(HRP_NPUB, self.as_bytes())
}
pub fn from_bech32(code: &str) -> Result<Self, Error> {
match Entity::from_bech32(code)? {
Entity::Public(pubkey) => Ok(pubkey),
other => Err(Error::UnexpectedPrefix {
expected: "npub",
found: other.prefix().to_owned(),
}),
}
}
}
impl EventId {
#[must_use]
pub fn to_bech32(self) -> String {
encode_bech32(HRP_NOTE, self.as_bytes())
}
pub fn from_bech32(code: &str) -> Result<Self, Error> {
match Entity::from_bech32(code)? {
Entity::Note(id) => Ok(id),
other => Err(Error::UnexpectedPrefix {
expected: "note",
found: other.prefix().to_owned(),
}),
}
}
}
impl SecretKey {
#[must_use]
pub fn to_bech32(&self) -> String {
self.with_secret_bytes(|bytes| encode_bech32(HRP_NSEC, bytes))
}
pub fn from_bech32(code: &str) -> Result<Self, Error> {
match Entity::from_bech32(code)? {
Entity::Secret(secret) => Ok(secret),
other => Err(Error::UnexpectedPrefix {
expected: "nsec",
found: other.prefix().to_owned(),
}),
}
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::panic, reason = "tests fail by panicking")]
use alloc::borrow::ToOwned;
use alloc::format;
use alloc::vec;
use core::error::Error as _;
use super::*;
const PK: [u8; 32] = [0x42; 32];
const ID: [u8; 32] = [0x11; 32];
fn pubkey() -> PublicKey {
PublicKey::from_bytes(PK)
}
fn event_id() -> EventId {
EventId::from_bytes(ID)
}
fn craft(hrp: &str, data: &[u8]) -> String {
encode_bech32(Hrp::parse_unchecked(hrp), data)
}
#[test]
fn nip19_checksum_matches_stock_bech32() {
let stock = bech32::encode::<bech32::Bech32>(HRP_NPUB, &PK).unwrap();
assert_eq!(pubkey().to_bech32(), stock);
}
#[test]
fn npub_round_trip() {
let code = pubkey().to_bech32();
assert!(code.starts_with("npub1"));
let Entity::Public(decoded) = Entity::from_bech32(&code).unwrap() else {
panic!("expected npub entity");
};
assert_eq!(decoded, pubkey());
assert_eq!(Entity::Public(pubkey()).to_bech32().unwrap(), code);
assert_eq!(PublicKey::from_bech32(&code).unwrap(), pubkey());
}
#[test]
fn note_round_trip() {
let code = event_id().to_bech32();
assert!(code.starts_with("note1"));
let Entity::Note(decoded) = Entity::from_bech32(&code).unwrap() else {
panic!("expected note entity");
};
assert_eq!(decoded, event_id());
assert_eq!(Entity::Note(event_id()).to_bech32().unwrap(), code);
assert_eq!(EventId::from_bech32(&code).unwrap(), event_id());
}
#[test]
fn nsec_round_trip() {
let secret = SecretKey::from_bytes([3; 32]).unwrap();
let code = secret.to_bech32();
assert!(code.starts_with("nsec1"));
let Entity::Secret(decoded) = Entity::from_bech32(&code).unwrap() else {
panic!("expected nsec entity");
};
assert_eq!(decoded.with_secret_bytes(|b| *b), [3; 32]);
assert_eq!(Entity::Secret(decoded).to_bech32().unwrap(), code);
let key = SecretKey::from_bech32(&code).unwrap();
assert_eq!(key.with_secret_bytes(|b| *b), [3; 32]);
}
#[test]
fn nprofile_round_trip_with_relays() {
let pointer = ProfilePointer {
pubkey: pubkey(),
relays: vec!["wss://r.example".to_owned(), "wss://例え.jp".to_owned()],
};
let code = pointer.to_bech32().unwrap();
assert!(code.starts_with("nprofile1"));
let Entity::Profile(decoded) = Entity::from_bech32(&code).unwrap() else {
panic!("expected nprofile entity");
};
assert_eq!(decoded, pointer);
assert_eq!(ProfilePointer::from_bech32(&code).unwrap(), pointer);
}
#[test]
fn nevent_round_trip_optional_fields() {
let bare = EventPointer {
id: event_id(),
relays: Vec::new(),
author: None,
kind: None,
};
let Entity::Event(decoded) = Entity::from_bech32(&bare.to_bech32().unwrap()).unwrap()
else {
panic!("expected nevent entity");
};
assert_eq!(decoded, bare);
let full = EventPointer {
id: event_id(),
relays: vec!["wss://r.example".to_owned()],
author: Some(pubkey()),
kind: Some(Kind::new(65535)),
};
let code = full.to_bech32().unwrap();
let Entity::Event(decoded_full) = Entity::from_bech32(&code).unwrap() else {
panic!("expected nevent entity");
};
assert_eq!(decoded_full, full);
assert_eq!(EventPointer::from_bech32(&code).unwrap(), full);
}
#[test]
fn naddr_round_trip() {
let pointer = AddressPointer {
identifier: "article".to_owned(),
pubkey: pubkey(),
kind: Kind::new(30023),
relays: vec!["wss://r.example".to_owned()],
};
let Entity::Address(decoded) = Entity::from_bech32(&pointer.to_bech32().unwrap()).unwrap()
else {
panic!("expected naddr entity");
};
assert_eq!(decoded, pointer);
let empty = AddressPointer {
identifier: String::new(),
pubkey: pubkey(),
kind: Kind::new(0),
relays: Vec::new(),
};
let Entity::Address(decoded_empty) =
Entity::from_bech32(&empty.to_bech32().unwrap()).unwrap()
else {
panic!("expected naddr entity");
};
assert_eq!(decoded_empty, empty);
assert_eq!(
AddressPointer::from_bech32(&pointer.to_bech32().unwrap()).unwrap(),
pointer
);
}
#[test]
fn entity_from_str_matches_from_bech32() {
let code = pubkey().to_bech32();
assert!(matches!(
code.parse::<Entity>(),
Ok(Entity::Public(pk)) if pk == pubkey()
));
}
#[test]
fn typed_from_bech32_rejects_other_prefixes() {
let pubkey_code = pubkey().to_bech32();
assert!(matches!(
EventId::from_bech32(&pubkey_code),
Err(Error::UnexpectedPrefix {
expected: "note",
..
})
));
assert!(matches!(
SecretKey::from_bech32(&pubkey_code),
Err(Error::UnexpectedPrefix {
expected: "nsec",
..
})
));
assert!(matches!(
ProfilePointer::from_bech32(&pubkey_code),
Err(Error::UnexpectedPrefix {
expected: "nprofile",
..
})
));
let note_code = event_id().to_bech32();
assert!(matches!(
PublicKey::from_bech32(¬e_code),
Err(Error::UnexpectedPrefix {
expected: "npub",
..
})
));
}
#[test]
fn tlv_write_order_is_ascending() {
let pointer = EventPointer {
id: event_id(),
relays: vec!["r".to_owned()],
author: Some(pubkey()),
kind: Some(Kind::new(1)),
};
let (_, data) = decode_nip19_bech32(&pointer.to_bech32().unwrap()).unwrap();
assert_eq!(data.first(), Some(&TLV_SPECIAL));
assert_eq!(data.get(34), Some(&TLV_RELAY));
assert_eq!(data.get(37), Some(&TLV_AUTHOR));
assert_eq!(data.get(71), Some(&TLV_KIND));
}
#[test]
fn decode_accepts_unsorted_tlv_and_first_value_wins() {
let other = [0x99; 32];
let mut data = Vec::new();
push_tlv(&mut data, TLV_SPECIAL, &ID).unwrap();
push_tlv(&mut data, TLV_SPECIAL, &other).unwrap();
push_tlv(&mut data, TLV_RELAY, b"wss://a").unwrap();
push_tlv(&mut data, TLV_RELAY, b"wss://b").unwrap();
let Entity::Profile(decoded) = Entity::from_bech32(&craft("nprofile", &data)).unwrap()
else {
panic!("expected nprofile entity");
};
assert_eq!(decoded.pubkey.as_bytes(), &ID);
assert_eq!(decoded.relays, ["wss://a", "wss://b"]);
}
#[test]
fn unknown_tlv_types_are_ignored() {
let mut data = Vec::new();
push_tlv(&mut data, 42, b"unknown").unwrap();
push_tlv(&mut data, TLV_SPECIAL, &ID).unwrap();
let Entity::Profile(decoded) = Entity::from_bech32(&craft("nprofile", &data)).unwrap()
else {
panic!("expected nprofile entity");
};
assert_eq!(decoded.pubkey.as_bytes(), &ID);
}
#[test]
fn lossy_utf8_in_identifier_and_relays() {
let mut data = Vec::new();
push_tlv(&mut data, TLV_SPECIAL, &[0x66, 0x80]).unwrap(); push_tlv(&mut data, TLV_RELAY, &[0xff]).unwrap();
push_tlv(&mut data, TLV_AUTHOR, &PK).unwrap();
push_tlv(&mut data, TLV_KIND, &1u32.to_be_bytes()).unwrap();
let Entity::Address(decoded) = Entity::from_bech32(&craft("naddr", &data)).unwrap() else {
panic!("expected naddr entity");
};
assert_eq!(decoded.identifier, "f\u{fffd}");
assert_eq!(decoded.relays, ["\u{fffd}"]);
}
#[test]
fn uppercase_decodes_mixed_case_rejected() {
let lower = pubkey().to_bech32();
let upper = lower.to_uppercase();
let Entity::Public(decoded) = Entity::from_bech32(&upper).unwrap() else {
panic!("expected npub entity");
};
assert_eq!(decoded, pubkey());
let mut mixed = lower;
mixed.replace_range(5..6, "P");
assert!(matches!(
Entity::from_bech32(&mixed),
Err(Error::Bech32 { .. })
));
}
#[test]
fn wrong_checksum_rejected() {
let mut code = pubkey().to_bech32();
let last = code.pop().unwrap();
code.push(if last == 'q' { 'p' } else { 'q' });
let err = Entity::from_bech32(&code).unwrap_err();
assert!(matches!(err, Error::Bech32 { .. }));
assert!(err.source().is_some());
}
#[test]
fn unknown_prefix_rejected() {
let code = craft("nzzz", &[1, 2, 3]);
assert!(matches!(
Entity::from_bech32(&code),
Err(Error::UnknownPrefix { .. })
));
}
#[test]
fn wrong_length_payloads_rejected() {
for hrp in ["npub", "note", "nsec"] {
assert!(
matches!(
Entity::from_bech32(&craft(hrp, &[0u8; 16])),
Err(Error::InvalidLength {
expected: 32,
found: 16
})
),
"{hrp}"
);
}
}
#[test]
fn invalid_nsec_scalars_rejected() {
for scalar in [[0u8; 32], [0xff; 32]] {
assert!(matches!(
Entity::from_bech32(&craft("nsec", &scalar)),
Err(Error::InvalidSecretKey)
));
assert!(matches!(
SecretKey::from_bech32(&craft("nsec", &scalar)),
Err(Error::InvalidSecretKey)
));
}
}
#[test]
fn kind_boundaries() {
let pointer = AddressPointer {
identifier: String::new(),
pubkey: pubkey(),
kind: Kind::new(65535),
relays: Vec::new(),
};
Entity::from_bech32(&pointer.to_bech32().unwrap()).unwrap();
let mut data = Vec::new();
push_tlv(&mut data, TLV_SPECIAL, b"").unwrap();
push_tlv(&mut data, TLV_AUTHOR, &PK).unwrap();
push_tlv(&mut data, TLV_KIND, &65536u32.to_be_bytes()).unwrap();
assert!(matches!(
Entity::from_bech32(&craft("naddr", &data)),
Err(Error::KindOutOfRange { kind: 65536 })
));
let mut event_data = Vec::new();
push_tlv(&mut event_data, TLV_SPECIAL, &ID).unwrap();
push_tlv(&mut event_data, TLV_KIND, &u32::MAX.to_be_bytes()).unwrap();
assert!(matches!(
Entity::from_bech32(&craft("nevent", &event_data)),
Err(Error::KindOutOfRange { kind: u32::MAX })
));
}
#[test]
fn malformed_tlv_rejected() {
assert!(matches!(
Entity::from_bech32(&craft("nprofile", &[1])),
Err(Error::InvalidTlv { .. })
));
assert!(matches!(
Entity::from_bech32(&craft("nprofile", &[TLV_RELAY, 9, 1, 2])),
Err(Error::InvalidTlv { .. })
));
assert!(matches!(
Entity::from_bech32(&craft("nprofile", &[])),
Err(Error::MissingTlv { .. })
));
assert!(matches!(
Entity::from_bech32(&craft("naddr", &[TLV_SPECIAL, 0])),
Err(Error::MissingTlv { .. })
));
let mut short = Vec::new();
push_tlv(&mut short, TLV_SPECIAL, &[0u8; 16]).unwrap();
assert!(matches!(
Entity::from_bech32(&craft("nprofile", &short)),
Err(Error::InvalidTlv { .. })
));
let mut bad_author = Vec::new();
push_tlv(&mut bad_author, TLV_SPECIAL, &ID).unwrap();
push_tlv(&mut bad_author, TLV_AUTHOR, &[0u8; 16]).unwrap();
assert!(matches!(
Entity::from_bech32(&craft("nevent", &bad_author)),
Err(Error::InvalidTlv { .. })
));
let mut bad_kind = Vec::new();
push_tlv(&mut bad_kind, TLV_SPECIAL, &ID).unwrap();
push_tlv(&mut bad_kind, TLV_KIND, &[0u8; 2]).unwrap();
assert!(matches!(
Entity::from_bech32(&craft("nevent", &bad_kind)),
Err(Error::InvalidTlv { .. })
));
}
#[test]
fn relay_over_255_bytes_fails_to_encode() {
let relay = format!("wss://{}", "a".repeat(300));
let pointer = ProfilePointer {
pubkey: pubkey(),
relays: vec![relay.clone()],
};
assert!(matches!(
pointer.to_bech32(),
Err(Error::TlvTooLong { len: 306 })
));
let event = EventPointer {
id: event_id(),
relays: vec![relay],
author: None,
kind: None,
};
assert!(matches!(
event.to_bech32(),
Err(Error::TlvTooLong { len: 306 })
));
let address = AddressPointer {
identifier: "x".repeat(300),
pubkey: pubkey(),
kind: Kind::new(1),
relays: Vec::new(),
};
assert!(matches!(
address.to_bech32(),
Err(Error::TlvTooLong { len: 300 })
));
}
#[test]
fn length_boundary_5000() {
let mut data = Vec::new();
push_tlv(&mut data, TLV_SPECIAL, b"d").unwrap();
push_tlv(&mut data, TLV_AUTHOR, &PK).unwrap();
push_tlv(&mut data, TLV_KIND, &1u32.to_be_bytes()).unwrap();
while data.len() < 3117 {
let room = 3117 - data.len();
let vlen = room.saturating_sub(2).min(255);
push_tlv(&mut data, 99, &vec![0x55; vlen]).unwrap();
}
assert_eq!(data.len(), 3117);
let code = craft("naddr", &data);
assert_eq!(code.len(), BECH32_MAX_LEN);
assert!(Entity::from_bech32(&code).is_ok());
data.push(0);
let over = craft("naddr", &data);
assert_eq!(over.len(), BECH32_MAX_LEN + 1);
assert!(matches!(
Entity::from_bech32(&over),
Err(Error::Bech32 { .. })
));
}
#[test]
fn non_canonical_padding_rejected() {
let mut fes: Vec<Fe32> = PK.iter().copied().bytes_to_fes().collect();
let last = fes.last_mut().unwrap();
*last = Fe32::try_from(last.to_u8() | 0b0001).unwrap();
let code: String = fes
.iter()
.copied()
.with_checksum::<Nip19Bech32>(&HRP_NPUB)
.chars()
.collect();
assert!(matches!(
Entity::from_bech32(&code),
Err(Error::Bech32 { .. })
));
}
}