use alloc::string::String;
use alloc::vec::Vec;
pub const INFO_KIND: u16 = 13194;
pub const REQUEST_KIND: u16 = 23194;
pub const RESPONSE_KIND: u16 = 23195;
pub const ENCRYPTION_NIP44: &str = "nip44_v2";
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Error {
Uri,
Event,
Response,
}
impl core::fmt::Display for Error {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(match self {
Self::Uri => "invalid NWC connection URI",
Self::Event => "invalid NIP-47 event",
Self::Response => "invalid NIP-47 response",
})
}
}
#[cfg(feature = "std")]
impl std::error::Error for Error {}
pub type Result<T> = core::result::Result<T, Error>;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NwcConnection {
pub wallet_pubkey: String,
pub relays: Vec<String>,
pub secret: [u8; 32],
pub lud16: Option<String>,
}
const fn hex_nibble(byte: u8) -> Option<u8> {
match byte {
b'0'..=b'9' => Some(byte - b'0'),
b'a'..=b'f' => Some(byte - b'a' + 10),
b'A'..=b'F' => Some(byte - b'A' + 10),
_ => None,
}
}
fn hex32(text: &str) -> Result<[u8; 32]> {
let (chunks, []) = text.as_bytes().as_chunks::<2>() else {
return Err(Error::Uri);
};
if chunks.len() != 32 {
return Err(Error::Uri);
}
let mut out = [0u8; 32];
for (dst, [hi, lo]) in out.iter_mut().zip(chunks) {
match (hex_nibble(*hi), hex_nibble(*lo)) {
(Some(h), Some(l)) => *dst = (h << 4) | l,
_ => return Err(Error::Uri),
}
}
Ok(out)
}
fn pct_decode(text: &str) -> Result<String> {
let mut out = Vec::with_capacity(text.len());
let mut bytes = text.bytes();
while let Some(byte) = bytes.next() {
if byte == b'%' {
let hi = bytes.next().and_then(hex_nibble).ok_or(Error::Uri)?;
let lo = bytes.next().and_then(hex_nibble).ok_or(Error::Uri)?;
out.push((hi << 4) | lo);
} else {
out.push(byte);
}
}
String::from_utf8(out).map_err(|_| Error::Uri)
}
fn is_loopback_ws(url: &str) -> bool {
url.starts_with("ws://localhost") || url.starts_with("ws://127.0.0.1")
}
pub fn parse_connection_uri(uri: &str) -> Result<NwcConnection> {
let rest = uri
.strip_prefix("nostr+walletconnect://")
.ok_or(Error::Uri)?;
let (host, query) = rest.split_once('?').ok_or(Error::Uri)?;
let wallet_pubkey = pct_decode(host)?.to_lowercase();
hex32(&wallet_pubkey)?;
let mut relays = Vec::new();
let mut secret = None;
let mut lud16 = None;
for part in query.split('&') {
let (key, raw) = part.split_once('=').ok_or(Error::Uri)?;
let value = pct_decode(raw)?;
match key {
"relay" => {
if !value.starts_with("wss://") && !is_loopback_ws(&value) {
return Err(Error::Uri);
}
relays.push(value);
}
"secret" => secret = Some(hex32(&value)?),
"lud16" => lud16 = Some(value),
_ => {}
}
}
if relays.is_empty() {
return Err(Error::Uri);
}
Ok(NwcConnection {
wallet_pubkey,
relays,
secret: secret.ok_or(Error::Uri)?,
lud16,
})
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NwcInfo {
pub methods: Vec<String>,
pub encryptions: Vec<String>,
pub extensions: Vec<String>,
pub nip44: bool,
}
pub fn parse_info_event(kind: u16, content: &str, tags: &[(String, String)]) -> Result<NwcInfo> {
if kind != INFO_KIND {
return Err(Error::Event);
}
let split = |s: &str| -> Vec<String> { s.split_whitespace().map(String::from).collect() };
let mut encryptions = Vec::new();
let mut extensions = Vec::new();
for (k, v) in tags {
match k.as_str() {
"encryption" => encryptions = split(v),
"extensions" => extensions = split(v),
_ => {}
}
}
Ok(NwcInfo {
methods: split(content),
nip44: encryptions.iter().any(|entry| entry == ENCRYPTION_NIP44),
encryptions,
extensions,
})
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NwcOutcome {
Ok(serde_json::Value),
Err(String),
}
fn is_msat(value: &serde_json::Value) -> bool {
value.as_u64().is_some_and(|n| n <= 9_007_199_254_740_991)
}
pub fn decode_response_payload(method: &str, json: &str) -> Result<NwcOutcome> {
const CODES: &[&str] = &[
"RATE_LIMITED",
"NOT_IMPLEMENTED",
"INSUFFICIENT_BALANCE",
"QUOTA_EXCEEDED",
"RESTRICTED",
"UNAUTHORIZED",
"INTERNAL",
"UNSUPPORTED_ENCRYPTION",
"OTHER",
"PAYMENT_FAILED",
"NOT_FOUND",
];
let doc: serde_json::Value = serde_json::from_str(json).map_err(|_| Error::Response)?;
let obj = doc.as_object().ok_or(Error::Response)?;
if obj.get("result_type").and_then(|v| v.as_str()) != Some(method) {
return Err(Error::Response);
}
let result = obj.get("result").filter(|v| !v.is_null());
let error = obj.get("error").filter(|v| !v.is_null());
match (result, error) {
(Some(r), None) => {
for key in ["amount", "balance", "fees_paid"] {
if let Some(v) = r.get(key).filter(|v| !is_msat(v)) {
let _ = v;
return Err(Error::Response);
}
}
Ok(NwcOutcome::Ok(r.clone()))
}
(None, Some(e)) => {
let code = e
.get("code")
.and_then(|c| c.as_str())
.ok_or(Error::Response)?;
if !CODES.contains(&code) {
return Err(Error::Response);
}
if !e.get("message").is_some_and(serde_json::Value::is_string) {
return Err(Error::Response);
}
Ok(NwcOutcome::Err(String::from(code)))
}
_ => Err(Error::Response),
}
}