Merge #225: ffi(nostr): complete nips module

Author: yukibtc

bindings/nostr-ffi/src/error.rs

@@ -85,6 +85,12 @@ impl From<nostr::event::tag::Error> for NostrError {
     }
 }
 
+impl From<nostr::nips::nip01::Error> for NostrError {
+    fn from(e: nostr::nips::nip01::Error) -> NostrError {
+        Self::Generic { err: e.to_string() }
+    }
+}
+
 impl From<nostr::nips::nip04::Error> for NostrError {
     fn from(e: nostr::nips::nip04::Error) -> NostrError {
         Self::Generic { err: e.to_string() }
@@ -133,6 +139,12 @@ impl From<nostr::nips::nip46::Error> for NostrError {
     }
 }
 
+impl From<nostr::nips::nip47::Error> for NostrError {
+    fn from(e: nostr::nips::nip47::Error) -> NostrError {
+        Self::Generic { err: e.to_string() }
+    }
+}
+
 impl From<nostr::nips::nip53::Error> for NostrError {
     fn from(e: nostr::nips::nip53::Error) -> NostrError {
         Self::Generic { err: e.to_string() }

bindings/nostr-ffi/src/event/mod.rs

@@ -168,8 +168,11 @@ impl Event {
     }
 
     /// Extract coordinates from tags (`a` tag)
-    pub fn coordinates(&self) -> Vec<Coordinate> {
-        self.inner.coordinates().map(|p| p.into()).collect()
+    pub fn coordinates(&self) -> Vec<Arc<Coordinate>> {
+        self.inner
+            .coordinates()
+            .map(|p| Arc::new(p.into()))
+            .collect()
     }
 
     #[uniffi::constructor]

bindings/nostr-ffi/src/nips/mod.rs

@@ -6,13 +6,18 @@ pub mod nip01;
 pub mod nip04;
 pub mod nip05;
 pub mod nip11;
+pub mod nip13;
 pub mod nip15;
 pub mod nip19;
+pub mod nip21;
+pub mod nip26;
 pub mod nip44;
 pub mod nip46;
+pub mod nip47;
 pub mod nip48;
 pub mod nip53;
 pub mod nip57;
+pub mod nip65;
 pub mod nip90;
 pub mod nip94;
 pub mod nip98;

bindings/nostr-ffi/src/nips/nip01.rs

@@ -1,47 +1,85 @@
 // Copyright (c) 2023-2024 Rust Nostr Developers
 // Distributed under the MIT software license
 
+use std::str::FromStr;
 use std::sync::Arc;
 
 use nostr::nips::nip01;
-use uniffi::Record;
+use nostr::nips::nip19::{FromBech32, ToBech32};
+use nostr::nips::nip21::NostrURI;
+use uniffi::Object;
 
+use crate::error::Result;
 use crate::PublicKey;
 
 /// Coordinate for event (`a` tag)
-#[derive(Record)]
+#[derive(Object)]
 pub struct Coordinate {
-    /// Kind
-    pub kind: u64,
-    /// Public Key
-    pub pubkey: Arc<PublicKey>,
-    /// `d` tag identifier
-    ///
-    /// Needed for a parametrized replaceable event.
-    /// Leave empty for a replaceable event.
-    pub identifier: String,
-    /// Relays
-    pub relays: Vec<String>,
+    inner: nip01::Coordinate,
+}
+
+#[uniffi::export]
+impl Coordinate {
+    #[uniffi::constructor]
+    pub fn new(kind: u64, public_key: Arc<PublicKey>) -> Self {
+        Self {
+            inner: nip01::Coordinate::new(kind.into(), **public_key),
+        }
+    }
+
+    #[uniffi::constructor]
+    pub fn parse(coordinate: String) -> Result<Self> {
+        Ok(nip01::Coordinate::from_str(&coordinate)?.into())
+    }
+
+    #[uniffi::constructor]
+    pub fn from_bech32(bech32: String) -> Result<Self> {
+        Ok(nip01::Coordinate::from_bech32(bech32)?.into())
+    }
+
+    #[uniffi::constructor]
+    pub fn from_nostr_uri(uri: String) -> Result<Self> {
+        Ok(nip01::Coordinate::from_nostr_uri(uri)?.into())
+    }
+
+    pub fn to_bech32(&self) -> Result<String> {
+        Ok(self.inner.to_bech32()?)
+    }
+
+    pub fn to_nostr_uri(&self) -> Result<String> {
+        Ok(self.inner.to_nostr_uri()?)
+    }
+
+    pub fn kind(&self) -> u64 {
+        self.inner.kind.into()
+    }
+
+    pub fn public_key(&self) -> Arc<PublicKey> {
+        Arc::new(self.inner.pubkey.into())
+    }
+
+    pub fn identifier(&self) -> String {
+        self.inner.identifier.clone()
+    }
+
+    pub fn relays(&self) -> Vec<String> {
+        self.inner.relays.clone()
+    }
 }
 
 impl From<Coordinate> for nip01::Coordinate {
     fn from(value: Coordinate) -> Self {
         Self {
-            kind: value.kind.into(),
-            pubkey: **value.pubkey,
-            identifier: value.identifier,
-            relays: value.relays,
+            kind: value.inner.kind,
+            pubkey: value.inner.pubkey,
+            identifier: value.inner.identifier,
+            relays: value.inner.relays,
         }
     }
 }
 
 impl From<nip01::Coordinate> for Coordinate {
-    fn from(value: nip01::Coordinate) -> Self {
-        Self {
-            kind: value.kind.into(),
-            pubkey: Arc::new(value.pubkey.into()),
-            identifier: value.identifier,
-            relays: value.relays,
-        }
+    fn from(inner: nip01::Coordinate) -> Self {
+        Self { inner }
     }
 }

bindings/nostr-ffi/src/nips/nip11.rs

@@ -7,9 +7,10 @@ use std::sync::Arc;
 
 use nostr::nips::nip11;
 use nostr::Url;
-use uniffi::Object;
+use uniffi::{Enum, Object, Record};
 
 use crate::error::Result;
+use crate::Timestamp;
 
 #[derive(Object)]
 pub struct RelayInformationDocument {
@@ -24,6 +25,14 @@ impl From<nip11::RelayInformationDocument> for RelayInformationDocument {
 
 #[uniffi::export]
 impl RelayInformationDocument {
+    #[uniffi::constructor]
+    /// Create new empty [`RelayInformationDocument`]
+    pub fn new() -> Self {
+        Self {
+            inner: nip11::RelayInformationDocument::new(),
+        }
+    }
+
     #[uniffi::constructor]
     pub fn get(url: String, proxy: Option<String>) -> Result<Arc<Self>> {
         let url: Url = Url::parse(&url)?;
@@ -63,4 +72,201 @@ impl RelayInformationDocument {
     pub fn version(&self) -> Option<String> {
         self.inner.version.clone()
     }
+
+    pub fn limitation(&self) -> Option<Limitation> {
+        self.inner.limitation.clone().map(|l| l.into())
+    }
+
+    pub fn retention(&self) -> Vec<Retention> {
+        self.inner
+            .retention
+            .clone()
+            .into_iter()
+            .map(|l| l.into())
+            .collect()
+    }
+
+    pub fn relay_countries(&self) -> Vec<String> {
+        self.inner.relay_countries.clone()
+    }
+
+    pub fn language_tags(&self) -> Vec<String> {
+        self.inner.language_tags.clone()
+    }
+
+    pub fn tags(&self) -> Vec<String> {
+        self.inner.tags.clone()
+    }
+
+    pub fn posting_policy(&self) -> Option<String> {
+        self.inner.posting_policy.clone()
+    }
+
+    pub fn payments_url(&self) -> Option<String> {
+        self.inner.payments_url.clone()
+    }
+
+    pub fn fees(&self) -> Option<FeeSchedules> {
+        self.inner.fees.clone().map(|f| f.into())
+    }
+
+    pub fn icon(&self) -> Option<String> {
+        self.inner.icon.clone()
+    }
+}
+
+/// These are limitations imposed by the relay on clients. Your client should
+/// expect that requests which exceed these practical limitations are rejected or fail immediately.
+#[derive(Record)]
+pub struct Limitation {
+    /// Maximum number of bytes for incoming JSON that the relay will attempt to decode and act upon
+    pub max_message_length: Option<i32>,
+    /// Total number of subscriptions that may be active on a single websocket connection
+    pub max_subscriptions: Option<i32>,
+    /// Maximum number of filter values in each subscription
+    pub max_filters: Option<i32>,
+    /// Relay will clamp each filter's limit value to this number
+    pub max_limit: Option<i32>,
+    /// Maximum length of subscription id as a string
+    pub max_subid_length: Option<i32>,
+    /// Maximum number of elements in the tags list
+    pub max_event_tags: Option<i32>,
+    /// Maximum number of characters in the content field of any event
+    pub max_content_length: Option<i32>,
+    /// New events will require at least this difficulty of PoW,
+    pub min_pow_difficulty: Option<i32>,
+    /// Relay requires NIP-42 authentication to happen before a new connection may perform any other action
+    pub auth_required: Option<bool>,
+    /// Relay requires payment before a new connection may perform any action
+    pub payment_required: Option<bool>,
+    /// 'created_at' lower limit
+    pub created_at_lower_limit: Option<Arc<Timestamp>>,
+    /// 'created_at' upper limit
+    pub created_at_upper_limit: Option<Arc<Timestamp>>,
+}
+
+impl From<nip11::Limitation> for Limitation {
+    fn from(inner: nip11::Limitation) -> Self {
+        let nip11::Limitation {
+            max_message_length,
+            max_subscriptions,
+            max_filters,
+            max_limit,
+            max_subid_length,
+            max_event_tags,
+            max_content_length,
+            min_pow_difficulty,
+            auth_required,
+            payment_required,
+            created_at_lower_limit,
+            created_at_upper_limit,
+        } = inner;
+        Self {
+            max_message_length,
+            max_subscriptions,
+            max_filters,
+            max_limit,
+            max_subid_length,
+            max_event_tags,
+            max_content_length,
+            min_pow_difficulty,
+            auth_required,
+            payment_required,
+            created_at_lower_limit: created_at_lower_limit.map(|c| Arc::new(c.into())),
+            created_at_upper_limit: created_at_upper_limit.map(|c| Arc::new(c.into())),
+        }
+    }
+}
+
+/// A retention shedule for the relay
+#[derive(Record)]
+pub struct Retention {
+    /// The event kinds this retention pertains to
+    pub kinds: Option<Vec<RetentionKind>>,
+    /// The amount of time these events are kept
+    pub time: Option<u64>,
+    /// The max number of events kept before removing older events
+    pub count: Option<u64>,
+}
+
+impl From<nip11::Retention> for Retention {
+    fn from(inner: nip11::Retention) -> Self {
+        let nip11::Retention { kinds, time, count } = inner;
+        Self {
+            kinds: kinds.map(|k| k.into_iter().map(|k| k.into()).collect()),
+            time,
+            count,
+        }
+    }
+}
+
+#[derive(Enum)]
+pub enum RetentionKind {
+    Single { single: u64 },
+    Range { start: u64, end: u64 },
+}
+
+impl From<nip11::RetentionKind> for RetentionKind {
+    fn from(value: nip11::RetentionKind) -> Self {
+        match value {
+            nip11::RetentionKind::Single(s) => Self::Single { single: s },
+            nip11::RetentionKind::Range(s, e) => Self::Range { start: s, end: e },
+        }
+    }
+}
+
+/// Available fee schedules
+#[derive(Record)]
+pub struct FeeSchedules {
+    /// Fees for admission to use the relay
+    pub admission: Vec<FeeSchedule>,
+    /// Fees for subscription to use the relay
+    pub subscription: Vec<FeeSchedule>,
+    /// Fees to publish to the relay
+    pub publication: Vec<FeeSchedule>,
+}
+
+impl From<nip11::FeeSchedules> for FeeSchedules {
+    fn from(inner: nip11::FeeSchedules) -> Self {
+        let nip11::FeeSchedules {
+            admission,
+            subscription,
+            publication,
+        } = inner;
+        Self {
+            admission: admission.into_iter().map(|a| a.into()).collect(),
+            subscription: subscription.into_iter().map(|s| s.into()).collect(),
+            publication: publication.into_iter().map(|p| p.into()).collect(),
+        }
+    }
+}
+
+/// The specific information about a fee schedule
+#[derive(Record)]
+pub struct FeeSchedule {
+    /// The fee amount
+    pub amount: i32,
+    /// The denomination of the feed
+    pub unit: String,
+    /// The duration for which the fee is valid
+    pub period: Option<i32>,
+    /// The event kinds the fee allows the client to publish to the relay
+    pub kinds: Option<Vec<String>>,
+}
+
+impl From<nip11::FeeSchedule> for FeeSchedule {
+    fn from(inner: nip11::FeeSchedule) -> Self {
+        let nip11::FeeSchedule {
+            amount,
+            unit,
+            period,
+            kinds,
+        } = inner;
+        Self {
+            amount,
+            unit,
+            period,
+            kinds,
+        }
+    }
 }