radrootsd

JSON-RPC bridge for Radroots event publishing
git clone https://radroots.dev/git/radrootsd.git
Log | Files | Refs | README | LICENSE

state.rs (2947B)

      1 use anyhow::Result;
      2 use radroots_identity::RadrootsIdentity;
      3 use radroots_nostr::prelude::{
      4     RadrootsNostrClient, RadrootsNostrKeys, RadrootsNostrMetadata, RadrootsNostrPublicKey,
      5 };
      6 
      7 use crate::app::config::{Nip46Config, PublishProxyConfig};
      8 use crate::core::publish_proxy::PublishProxy;
      9 
     10 #[derive(Clone)]
     11 pub struct Radrootsd {
     12     pub client: RadrootsNostrClient,
     13     pub keys: RadrootsNostrKeys,
     14     pub pubkey: RadrootsNostrPublicKey,
     15     pub metadata: RadrootsNostrMetadata,
     16     pub info: serde_json::Value,
     17     pub publish_proxy: PublishProxy,
     18     pub(crate) nip46_sessions: crate::core::nip46::session::Nip46SessionStore,
     19     pub nip46_config: Nip46Config,
     20 }
     21 
     22 impl Radrootsd {
     23     pub fn new(
     24         identity: RadrootsIdentity,
     25         metadata: RadrootsNostrMetadata,
     26         publish_proxy_config: PublishProxyConfig,
     27         nip46_config: Nip46Config,
     28     ) -> Result<Self> {
     29         let keys: RadrootsNostrKeys = identity.keys().clone();
     30         let pubkey = keys.public_key();
     31         let client = RadrootsNostrClient::new(keys.clone());
     32         let info = serde_json::json!({
     33             "version": env!("CARGO_PKG_VERSION"),
     34             "build": option_env!("GIT_HASH").unwrap_or("unknown"),
     35         });
     36         #[cfg(test)]
     37         let publish_proxy = PublishProxy::memory(publish_proxy_config)?;
     38         #[cfg(not(test))]
     39         let publish_proxy = PublishProxy::open(publish_proxy_config)?;
     40         let nip46_sessions = crate::core::nip46::session::Nip46SessionStore::new();
     41 
     42         Ok(Self {
     43             client,
     44             keys,
     45             pubkey,
     46             metadata,
     47             info,
     48             publish_proxy,
     49             nip46_sessions,
     50             nip46_config,
     51         })
     52     }
     53 }
     54 
     55 #[cfg(test)]
     56 mod tests {
     57     use super::Radrootsd;
     58     use crate::app::config::{Nip46Config, PublishProxyConfig};
     59     use radroots_identity::RadrootsIdentity;
     60     use radroots_nostr::prelude::RadrootsNostrMetadata;
     61 
     62     #[test]
     63     fn new_sets_core_fields() {
     64         let identity = RadrootsIdentity::generate();
     65         let metadata: RadrootsNostrMetadata =
     66             serde_json::from_str(r#"{"name":"radrootsd-test"}"#).expect("metadata");
     67         let publish_proxy_cfg = PublishProxyConfig::default();
     68         let cfg = Nip46Config::default();
     69         let state = Radrootsd::new(
     70             identity.clone(),
     71             metadata.clone(),
     72             publish_proxy_cfg.clone(),
     73             cfg.clone(),
     74         )
     75         .expect("state");
     76 
     77         assert_eq!(state.pubkey, identity.public_key());
     78         assert_eq!(state.metadata, metadata);
     79         assert_eq!(
     80             state.publish_proxy.config.enabled,
     81             publish_proxy_cfg.enabled
     82         );
     83         assert_eq!(state.nip46_config.session_ttl_secs, cfg.session_ttl_secs);
     84         assert_eq!(state.nip46_config.perms, cfg.perms);
     85         assert_eq!(state.info["version"], env!("CARGO_PKG_VERSION"));
     86         assert_eq!(state.info["build"], "unknown");
     87     }
     88 }