commit 3415af7fe609038f23aa8aeb83f9a24a72f32796 parent 3daddc63e257db2c4dba87f05afb167219ac079b Author: triesap <tyson@radroots.org> Date: Fri, 20 Mar 2026 16:58:43 +0000 workspace: remove retired app crates Diffstat:
15 files changed, 0 insertions(+), 2205 deletions(-)
diff --git a/core/provenance/tera_core/ancestral_source/Cargo.toml b/core/provenance/tera_core/ancestral_source/Cargo.toml @@ -1,51 +0,0 @@ -[package] -name = "radroots-app-core" -version = "0.1.0-alpha.1" -edition.workspace = true -authors = ["Radroots Authors"] -rust-version.workspace = true -license.workspace = true -description = "Core application orchestration for Radroots Studio" -repository.workspace = true -homepage.workspace = true -readme.workspace = true - -[lib] -crate-type = ["rlib"] - -[lints.rust] -unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage_nightly)'] } - -[features] -default = ["rt", "nostr-client"] -rt = ["radroots-net-core/rt"] -nostr-client = [ - "radroots-net-core/nostr-client", - "dep:radroots-core", - "dep:radroots-events-codec", - "dep:radroots-trade", - "dep:radroots-identity", - "dep:radroots-nostr", -] -directories = ["radroots-net-core/directories"] -fs-persistence = ["radroots-net-core/fs-persistence"] - -[dependencies] -radroots-log = { workspace = true } -radroots-events = { workspace = true } -radroots-net-core = { workspace = true, features = ["std"] } -radroots-core = { workspace = true, optional = true } -radroots-identity = { workspace = true, optional = true, default-features = false, features = ["std"] } -radroots-events-codec = { workspace = true, features = ["serde_json"], optional = true } -radroots-trade = { workspace = true, features = ["std", "serde", "serde_json"], optional = true } -radroots-nostr = { workspace = true, features = ["events"], optional = true } -chrono = { workspace = true } -serde = { workspace = true, features = ["derive"] } -serde_json = { workspace = true } -thiserror = { workspace = true } -tracing = { workspace = true } -uniffi = { workspace = true } -tokio = { workspace = true } - -[dev-dependencies] -tracing-subscriber = { workspace = true } diff --git a/core/provenance/tera_core/ancestral_source/README b/core/provenance/tera_core/ancestral_source/README @@ -1,14 +0,0 @@ -# radroots-app-core - -Core application runtime primitives for Rad Roots app surfaces. - -## Goals - -- define stable application runtime, error, and lifecycle interfaces -- keep runtime and network wiring deterministic across supported targets -- support reusable integration points with `radroots-net-core` -- provide reusable application primitives for higher-level Rad Roots crates - -## License - -Licensed under AGPL-3.0. See LICENSE. diff --git a/core/provenance/tera_core/ancestral_source/build.rs b/core/provenance/tera_core/ancestral_source/build.rs @@ -1,47 +0,0 @@ -use std::{ - env, - process::Command, - time::{SystemTime, UNIX_EPOCH}, -}; - -fn main() { - println!("cargo:rerun-if-changed=build.rs"); - println!("cargo:rerun-if-env-changed=RUSTC"); - println!("cargo:rerun-if-env-changed=PROFILE"); - - let rustc = env::var("RUSTC").expect("missing required env var RUSTC"); - if let Ok(out) = Command::new(rustc).arg("--version").output() { - if out.status.success() { - if let Ok(ver) = String::from_utf8(out.stdout) { - println!("cargo:rustc-env=RUSTC_VERSION={}", ver.trim()); - } - } - } - - if let Ok(out) = Command::new("git") - .args(["rev-parse", "--short=12", "HEAD"]) - .output() - { - if out.status.success() { - let mut sha = String::from_utf8_lossy(&out.stdout).trim().to_string(); - let dirty = Command::new("git") - .args(["status", "--porcelain"]) - .output() - .ok() - .map_or(false, |o| o.status.success() && !o.stdout.is_empty()); - if dirty { - sha.push_str("-dirty"); - } - println!("cargo:rustc-env=GIT_HASH={sha}"); - } - } - - let profile = env::var("PROFILE").expect("missing required env var PROFILE"); - println!("cargo:rustc-env=PROFILE={profile}"); - - let epoch = SystemTime::now() - .duration_since(UNIX_EPOCH) - .map(|d| d.as_secs()) - .expect("system time before unix epoch"); - println!("cargo:rustc-env=BUILD_TIME_UNIX={epoch}"); -} diff --git a/core/provenance/tera_core/ancestral_source/src/error.rs b/core/provenance/tera_core/ancestral_source/src/error.rs @@ -1,7 +0,0 @@ -use thiserror::Error; - -#[derive(Debug, Error, uniffi::Error)] -pub enum RadrootsAppError { - #[error("{0}")] - Msg(String), -} diff --git a/core/provenance/tera_core/ancestral_source/src/lib.rs b/core/provenance/tera_core/ancestral_source/src/lib.rs @@ -1,10 +0,0 @@ -uniffi::setup_scaffolding!("radroots"); - -pub mod error; -pub mod logging; -pub mod runtime; - -pub use error::RadrootsAppError; -pub use radroots_net_core::net::{BuildInfo, NetInfo}; -pub use radroots_net_core::{Net, NetHandle}; -pub use runtime::RadrootsRuntime; diff --git a/core/provenance/tera_core/ancestral_source/src/logging.rs b/core/provenance/tera_core/ancestral_source/src/logging.rs @@ -1,45 +0,0 @@ -use std::path::PathBuf; - -#[cfg_attr(not(coverage_nightly), uniffi::export)] -pub fn init_logging( - dir: Option<String>, - file_name: Option<String>, - is_stdout: Option<bool>, -) -> Result<(), crate::RadrootsAppError> { - let opts = radroots_log::LoggingOptions { - dir: dir.map(PathBuf::from), - file_name: file_name.unwrap_or_else(|| "radroots.log".to_string()), - stdout: is_stdout.unwrap_or(true), - default_level: None, - }; - match radroots_log::init_logging(opts) { - Ok(()) => Ok(()), - Err(err) => Err(crate::RadrootsAppError::Msg(format!("{err}"))), - } -} - -#[cfg_attr(not(coverage_nightly), uniffi::export)] -pub fn init_logging_stdout() -> Result<(), crate::RadrootsAppError> { - match radroots_log::init_stdout() { - Ok(()) => Ok(()), - Err(err) => Err(crate::RadrootsAppError::Msg(format!("{err}"))), - } -} - -#[cfg_attr(not(coverage_nightly), uniffi::export)] -pub fn log_info(msg: String) -> Result<(), crate::RadrootsAppError> { - radroots_log::log_info(msg); - Ok(()) -} - -#[cfg_attr(not(coverage_nightly), uniffi::export)] -pub fn log_error(msg: String) -> Result<(), crate::RadrootsAppError> { - radroots_log::log_error(msg); - Ok(()) -} - -#[cfg_attr(not(coverage_nightly), uniffi::export)] -pub fn log_debug(msg: String) -> Result<(), crate::RadrootsAppError> { - radroots_log::log_debug(msg); - Ok(()) -} diff --git a/core/provenance/tera_core/ancestral_source/src/runtime/app_info.rs b/core/provenance/tera_core/ancestral_source/src/runtime/app_info.rs @@ -1,26 +0,0 @@ -#[derive(Debug, Clone, Default, serde::Serialize, uniffi::Record)] -pub struct AppInfoPlatform { - pub platform: Option<String>, - pub bundle_id: Option<String>, - pub version: Option<String>, - pub build_number: Option<String>, - pub build_sha: Option<String>, -} - -impl AppInfoPlatform { - pub fn new( - platform: Option<String>, - bundle_id: Option<String>, - version: Option<String>, - build_number: Option<String>, - build_sha: Option<String>, - ) -> Self { - Self { - platform, - bundle_id, - version, - build_number, - build_sha, - } - } -} diff --git a/core/provenance/tera_core/ancestral_source/src/runtime/builder.rs b/core/provenance/tera_core/ancestral_source/src/runtime/builder.rs @@ -1,53 +0,0 @@ -use radroots_net_core::NetHandle; -use radroots_net_core::builder::NetBuilder; -use radroots_net_core::config::NetConfig; - -use crate::RadrootsAppError; - -pub struct RuntimeBuilder { - config: NetConfig, - manage_runtime: bool, -} - -impl RuntimeBuilder { - pub fn new() -> Self { - Self { - config: NetConfig::default(), - manage_runtime: true, - } - } - - pub fn with_config(mut self, config: NetConfig) -> Self { - self.config = config; - self - } - - pub fn manage_runtime(mut self, manage: bool) -> Self { - self.manage_runtime = manage; - self - } - - pub fn build(self) -> Result<NetHandle, RadrootsAppError> { - #[cfg(feature = "rt")] - { - match NetBuilder::new() - .config(self.config) - .manage_runtime(self.manage_runtime) - .build() - { - Ok(handle) => Ok(handle), - Err(err) => Err(RadrootsAppError::Msg(format!("net build failed: {err}"))), - } - } - - #[cfg(not(feature = "rt"))] - { - let handle = NetBuilder::new() - .config(self.config) - .manage_runtime(self.manage_runtime) - .build() - .expect("net build must succeed when rt feature is disabled"); - Ok(handle) - } - } -} diff --git a/core/provenance/tera_core/ancestral_source/src/runtime/info.rs b/core/provenance/tera_core/ancestral_source/src/runtime/info.rs @@ -1,119 +0,0 @@ -use super::RadrootsRuntime; -use chrono::Utc; -use radroots_net_core::net; -use serde::Serialize; - -#[derive(Debug, Clone, Serialize, Default, uniffi::Record)] -pub struct NetBuildInfo { - pub crate_name: String, - pub crate_version: String, - pub rustc: Option<String>, - pub profile: Option<String>, - pub git_sha: Option<String>, - pub build_time_unix: Option<u64>, -} - -impl From<&net::BuildInfo> for NetBuildInfo { - fn from(b: &net::BuildInfo) -> Self { - Self { - crate_name: b.crate_name.to_string(), - crate_version: b.crate_version.to_string(), - rustc: b.rustc.map(|s| s.to_string()), - profile: b.profile.map(|s| s.to_string()), - git_sha: b.git_sha.map(|s| s.to_string()), - build_time_unix: b.build_time_unix, - } - } -} - -#[derive(Debug, Clone, Serialize, uniffi::Record)] -pub struct AppInfo { - pub build: NetBuildInfo, - pub started_unix_ms: i64, - pub uptime_millis: i64, - pub shutting_down: bool, - pub platform: Option<super::app_info::AppInfoPlatform>, -} - -#[derive(Debug, Clone, Serialize, uniffi::Record)] -pub struct RuntimeInfo { - pub app: AppInfo, - pub net: NetBuildInfo, -} - -pub fn gather_runtime_info(runtime: &RadrootsRuntime) -> RuntimeInfo { - let now_ms = Utc::now().timestamp_millis(); - let app_info = AppInfo { - build: app_build_info(), - started_unix_ms: runtime.started_unix_ms, - uptime_millis: now_ms - runtime.started_unix_ms, - shutting_down: runtime - .shutting_down - .load(std::sync::atomic::Ordering::SeqCst), - platform: runtime.platform_app.read().ok().and_then(|g| (*g).clone()), - }; - - let net_info = match runtime.net.lock() { - Ok(guard) => NetBuildInfo::from(&guard.info.build), - Err(_) => NetBuildInfo::default(), - }; - - RuntimeInfo { - app: app_info, - net: net_info, - } -} - -pub fn app_build_info() -> NetBuildInfo { - NetBuildInfo { - crate_name: env!("CARGO_PKG_NAME").to_string(), - crate_version: env!("CARGO_PKG_VERSION").to_string(), - rustc: env_opt_to_owned(option_env!("RUSTC_VERSION")), - profile: env_opt_to_owned(option_env!("PROFILE")), - git_sha: env_opt_to_owned(option_env!("GIT_HASH")), - build_time_unix: env_opt_to_u64(option_env!("BUILD_TIME_UNIX")), - } -} - -fn env_opt_to_owned(value: Option<&str>) -> Option<String> { - value.map(str::to_owned) -} - -fn env_opt_to_u64(value: Option<&str>) -> Option<u64> { - value.map(str::parse::<u64>).and_then(Result::ok) -} - -#[cfg(test)] -mod tests { - use super::NetBuildInfo; - use radroots_net_core::net; - - #[test] - fn net_build_info_from_copies_optional_fields() { - let source = net::BuildInfo { - crate_name: "radroots-net-core", - crate_version: "1.2.3", - rustc: Some("rustc 1.92.0"), - profile: Some("debug"), - git_sha: Some("abc123"), - build_time_unix: Some(1_700_000_000), - }; - - let out = NetBuildInfo::from(&source); - assert_eq!(out.crate_name, "radroots-net-core"); - assert_eq!(out.crate_version, "1.2.3"); - assert_eq!(out.rustc.as_deref(), Some("rustc 1.92.0")); - assert_eq!(out.profile.as_deref(), Some("debug")); - assert_eq!(out.git_sha.as_deref(), Some("abc123")); - assert_eq!(out.build_time_unix, Some(1_700_000_000)); - } - - #[test] - fn env_opt_helpers_cover_some_none_and_parse_failure() { - assert_eq!(super::env_opt_to_owned(Some("abc")).as_deref(), Some("abc")); - assert_eq!(super::env_opt_to_owned(None), None); - assert_eq!(super::env_opt_to_u64(Some("123")), Some(123)); - assert_eq!(super::env_opt_to_u64(Some("abc")), None); - assert_eq!(super::env_opt_to_u64(None), None); - } -} diff --git a/core/provenance/tera_core/ancestral_source/src/runtime/key_management.rs b/core/provenance/tera_core/ancestral_source/src/runtime/key_management.rs @@ -1,225 +0,0 @@ -use super::RadrootsRuntime; -use crate::RadrootsAppError; -#[cfg(feature = "nostr-client")] -use radroots_identity::{RadrootsIdentity, RadrootsIdentityId}; -#[cfg(feature = "nostr-client")] -use std::path::PathBuf; - -#[cfg_attr(not(coverage_nightly), uniffi::export)] -impl RadrootsRuntime { - pub fn accounts_has_selected_signing_identity(&self) -> bool { - #[cfg(feature = "nostr-client")] - { - if let Ok(guard) = self.net.lock() { - return guard - .accounts - .selected_signing_identity() - .ok() - .flatten() - .is_some(); - } - } - - #[cfg(not(feature = "nostr-client"))] - { - false - } - - #[cfg(feature = "nostr-client")] - false - } - - pub fn accounts_selected_npub(&self) -> Option<String> { - #[cfg(feature = "nostr-client")] - { - if let Ok(guard) = self.net.lock() { - return guard - .accounts - .selected_public_identity() - .ok() - .flatten() - .map(|identity| identity.public_key_npub); - } - } - - #[cfg(not(feature = "nostr-client"))] - { - None - } - - #[cfg(feature = "nostr-client")] - None - } - - pub fn accounts_list_ids(&self) -> Result<Vec<String>, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let accounts = guard - .accounts - .list_accounts() - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - return Ok(accounts - .into_iter() - .map(|account| account.account_id.to_string()) - .collect()); - } - #[cfg(not(feature = "nostr-client"))] - { - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn accounts_generate( - &self, - label: Option<String>, - make_selected: bool, - ) -> Result<String, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let mut guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let account_id = guard - .accounts - .generate_identity(label, make_selected) - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - guard.nostr = None; - return Ok(account_id.to_string()); - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = (label, make_selected); - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn accounts_import_secret( - &self, - secret_key: String, - label: Option<String>, - make_selected: bool, - ) -> Result<String, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let mut guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let identity = RadrootsIdentity::from_secret_key_str(secret_key.as_str()) - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - let account_id = guard - .accounts - .upsert_identity(&identity, label, make_selected) - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - guard.nostr = None; - return Ok(account_id.to_string()); - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = (secret_key, label, make_selected); - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn accounts_import_from_path( - &self, - path: String, - label: Option<String>, - make_selected: bool, - ) -> Result<String, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let mut guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let account_id = guard - .accounts - .migrate_legacy_identity_file(PathBuf::from(path), label, make_selected) - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - guard.nostr = None; - return Ok(account_id.to_string()); - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = (path, label, make_selected); - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn accounts_export_selected_secret_hex(&self) -> Result<Option<String>, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let Some(selected_id) = guard - .accounts - .selected_account_id() - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))? - else { - return Ok(None); - }; - return guard - .accounts - .export_secret_hex(&selected_id) - .map_err(|e| RadrootsAppError::Msg(format!("{e}"))); - } - #[cfg(not(feature = "nostr-client"))] - { - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn accounts_select(&self, account_id: String) -> Result<(), RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let mut guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let account_id = RadrootsIdentityId::parse(account_id.as_str()) - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - guard - .accounts - .select_account(&account_id) - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - guard.nostr = None; - Ok(()) - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = account_id; - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn accounts_remove(&self, account_id: String) -> Result<(), RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let mut guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let account_id = RadrootsIdentityId::parse(account_id.as_str()) - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - guard - .accounts - .remove_account(&account_id) - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - guard.nostr = None; - Ok(()) - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = account_id; - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } -} diff --git a/core/provenance/tera_core/ancestral_source/src/runtime/mod.rs b/core/provenance/tera_core/ancestral_source/src/runtime/mod.rs @@ -1,211 +0,0 @@ -pub mod app_info; -pub mod builder; -pub mod info; -pub mod key_management; -pub mod nostr; -#[cfg(feature = "nostr-client")] -pub mod trade_listing; - -use chrono::Utc; -use radroots_net_core::{NetHandle, builder::NetBuilder}; -#[cfg(feature = "nostr-client")] -use std::sync::Mutex; -use std::sync::{ - RwLock, - atomic::{AtomicBool, Ordering}, -}; -#[cfg(feature = "nostr-client")] -use tokio::sync::broadcast::Receiver; - -use self::{ - app_info::AppInfoPlatform, - info::{RuntimeInfo, gather_runtime_info}, -}; -use crate::RadrootsAppError; - -#[derive(uniffi::Object)] -pub struct RadrootsRuntime { - pub(crate) net: NetHandle, - pub(crate) started_unix_ms: i64, - pub(crate) shutting_down: AtomicBool, - pub(crate) platform_app: RwLock<Option<AppInfoPlatform>>, - #[cfg(feature = "nostr-client")] - pub(crate) post_events_rx: Mutex< - Option< - Receiver< - radroots_events_codec::parsed::RadrootsParsedData< - radroots_events::post::RadrootsPost, - >, - >, - >, - >, -} - -#[cfg_attr(not(coverage_nightly), uniffi::export)] -impl RadrootsRuntime { - #[cfg_attr(not(coverage_nightly), uniffi::constructor)] - pub fn new() -> Result<Self, RadrootsAppError> { - let cfg = radroots_net_core::config::NetConfig::default(); - #[cfg(feature = "rt")] - let handle = match NetBuilder::new().config(cfg).manage_runtime(true).build() { - Ok(handle) => handle, - Err(err) => return Err(RadrootsAppError::Msg(format!("net build failed: {err}"))), - }; - #[cfg(not(feature = "rt"))] - let handle = NetBuilder::new() - .config(cfg) - .manage_runtime(true) - .build() - .expect("net build must succeed when rt feature is disabled"); - - Ok(Self { - net: handle, - started_unix_ms: Utc::now().timestamp_millis(), - shutting_down: AtomicBool::new(false), - platform_app: RwLock::new(None), - #[cfg(feature = "nostr-client")] - post_events_rx: Mutex::new(None), - }) - } - - pub fn stop(&self) { - if self.shutting_down.swap(true, Ordering::SeqCst) { - let _ = crate::logging::log_info( - "Runtime stop already in progress or completed.".to_string(), - ); - return; - } - - #[cfg(feature = "rt")] - { - if let Ok(mut net) = self.net.lock() { - if let Some(_rt) = net.rt.take() { - let _ = crate::logging::log_info("Runtime stopped gracefully.".to_string()); - } else { - let _ = crate::logging::log_info("No runtime was active at stop.".to_string()); - } - } else { - let _ = crate::logging::log_info( - "Failed to acquire runtime lock during stop.".to_string(), - ); - } - } - - #[cfg(not(feature = "rt"))] - { - let _ = crate::logging::log_info( - "No managed runtime is available for this build.".to_string(), - ); - } - } - - pub fn uptime_millis(&self) -> i64 { - Utc::now().timestamp_millis() - self.started_unix_ms - } - - pub fn info(&self) -> RuntimeInfo { - gather_runtime_info(self) - } - - pub fn info_json(&self) -> String { - #[cfg(feature = "rt")] - { - return match serde_json::to_string_pretty(&self.info()) { - Ok(json) => json, - Err(err) => format!(r#"{{"error":"serialize RuntimeInfo: {err}"}}"#), - }; - } - #[cfg(not(feature = "rt"))] - { - serde_json::to_string_pretty(&self.info()).unwrap_or_default() - } - } - - pub fn set_app_info_platform( - &self, - platform: Option<String>, - bundle_id: Option<String>, - version: Option<String>, - build_number: Option<String>, - build_sha: Option<String>, - ) { - let platform_info = - AppInfoPlatform::new(platform, bundle_id, version, build_number, build_sha); - if let Ok(mut guard) = self.platform_app.write() { - *guard = Some(platform_info); - } - } -} - -#[cfg(test)] -mod tests { - use super::RadrootsRuntime; - use std::panic::{AssertUnwindSafe, catch_unwind}; - - fn init_info_logging() { - let _ = tracing_subscriber::fmt() - .with_test_writer() - .with_max_level(tracing::Level::INFO) - .try_init(); - } - - fn poison_net_lock(runtime: &RadrootsRuntime) { - let handle = runtime.net.clone(); - let _ = catch_unwind(AssertUnwindSafe(|| { - let _guard = handle.lock().expect("lock net"); - panic!("poison net lock"); - })); - } - - fn poison_platform_lock(runtime: &RadrootsRuntime) { - let _ = catch_unwind(AssertUnwindSafe(|| { - let _guard = runtime.platform_app.write().expect("lock platform"); - panic!("poison platform lock"); - })); - } - - #[test] - fn runtime_info_uses_default_net_info_when_lock_is_poisoned() { - init_info_logging(); - let runtime = RadrootsRuntime::new().expect("runtime"); - - let healthy = runtime.info(); - assert!(!healthy.net.crate_name.is_empty()); - poison_net_lock(&runtime); - - let _ = runtime.uptime_millis(); - let info = runtime.info(); - assert_eq!(info.net.crate_name, String::new()); - assert_eq!(info.net.crate_version, String::new()); - let json = runtime.info_json(); - assert!(json.contains("\"net\"")); - runtime.stop(); - runtime.stop(); - } - - #[test] - fn set_platform_info_handles_poisoned_lock() { - init_info_logging(); - let runtime = RadrootsRuntime::new().expect("runtime"); - runtime.set_app_info_platform( - Some("ios".to_string()), - Some("org.radroots.app".to_string()), - Some("1.0.0".to_string()), - Some("100".to_string()), - Some("abc123".to_string()), - ); - let info = runtime.info(); - assert_eq!( - info.app.platform.as_ref().and_then(|v| v.platform.clone()), - Some("ios".to_string()) - ); - poison_platform_lock(&runtime); - runtime.set_app_info_platform( - Some("ios".to_string()), - Some("org.radroots.app".to_string()), - Some("1.0.0".to_string()), - Some("100".to_string()), - Some("abc123".to_string()), - ); - } -} diff --git a/core/provenance/tera_core/ancestral_source/src/runtime/nostr.rs b/core/provenance/tera_core/ancestral_source/src/runtime/nostr.rs @@ -1,370 +0,0 @@ -use super::RadrootsRuntime; -use crate::RadrootsAppError; -#[cfg(feature = "nostr-client")] -use tokio::sync::broadcast::error::TryRecvError; - -#[derive(uniffi::Enum, Debug, Clone, Copy)] -pub enum NostrLight { - Red, - Yellow, - Green, -} - -#[derive(uniffi::Record, Debug, Clone)] -pub struct NostrConnectionStatus { - pub light: NostrLight, - pub connected: u32, - pub connecting: u32, - pub last_error: Option<String>, -} - -#[derive(uniffi::Record, Debug, Clone, Default)] -pub struct NostrProfile { - pub name: Option<String>, - pub display_name: Option<String>, - pub nip05: Option<String>, - pub about: Option<String>, - pub website: Option<String>, - pub picture: Option<String>, - pub banner: Option<String>, - pub lud06: Option<String>, - pub lud16: Option<String>, - pub bot: Option<String>, -} - -#[derive(uniffi::Record, Debug, Clone)] -pub struct NostrProfileEventMetadata { - pub id: String, - pub author: String, - pub published_at: u64, - pub profile: NostrProfile, -} - -#[derive(uniffi::Record, Debug, Clone)] -pub struct NostrEvent { - pub id: String, - pub author: String, - pub created_at: u64, - pub kind: u32, - pub content: String, -} - -#[derive(uniffi::Record, Debug, Clone)] -pub struct NostrPost { - pub content: String, -} - -#[derive(uniffi::Record, Debug, Clone)] -pub struct NostrPostEventMetadata { - pub id: String, - pub author: String, - pub published_at: u64, - pub post: NostrPost, -} - -#[cfg(feature = "nostr-client")] -fn map_post_event_metadata( - event: radroots_events_codec::parsed::RadrootsParsedData<radroots_events::post::RadrootsPost>, -) -> NostrPostEventMetadata { - NostrPostEventMetadata { - id: event.id, - author: event.author, - published_at: event.published_at as u64, - post: NostrPost { - content: event.data.content, - }, - } -} - -#[cfg_attr(not(coverage_nightly), uniffi::export)] -impl RadrootsRuntime { - pub fn nostr_set_default_relays(&self, relays: Vec<String>) -> Result<(), RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let mut guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - guard - .nostr_set_default_relays(&relays) - .map_err(|e| RadrootsAppError::Msg(format!("{e}"))) - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = relays; - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn nostr_connect_if_key_present(&self) -> Result<(), RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let mut guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - guard - .nostr_connect_if_key_present() - .map_err(|e| RadrootsAppError::Msg(format!("{e}"))) - } - #[cfg(not(feature = "nostr-client"))] - { - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn nostr_connection_status(&self) -> NostrConnectionStatus { - #[cfg(feature = "nostr-client")] - { - let guard = self.net.lock(); - if let Ok(g) = guard { - if let Some(s) = g.nostr_connection_snapshot() { - let light = match s.light { - radroots_net_core::nostr_client::Light::Green => NostrLight::Green, - radroots_net_core::nostr_client::Light::Yellow => NostrLight::Yellow, - radroots_net_core::nostr_client::Light::Red => NostrLight::Red, - }; - return NostrConnectionStatus { - light, - connected: s.connected as u32, - connecting: s.connecting as u32, - last_error: s.last_error, - }; - } - } - NostrConnectionStatus { - light: NostrLight::Red, - connected: 0, - connecting: 0, - last_error: None, - } - } - - #[cfg(not(feature = "nostr-client"))] - { - NostrConnectionStatus { - light: NostrLight::Red, - connected: 0, - connecting: 0, - last_error: None, - } - } - } - - pub fn nostr_profile_for_self(&self) -> Option<NostrProfileEventMetadata> { - #[cfg(feature = "nostr-client")] - { - let guard = self.net.lock().ok()?; - let keys = guard.selected_nostr_keys()?; - let pk = keys.public_key(); - let mgr = guard.nostr.as_ref()?; - let out = mgr.fetch_profile_event_blocking(pk).ok()?; - return out.map(|m| NostrProfileEventMetadata { - id: m.id, - author: m.author, - published_at: m.published_at as u64, - profile: NostrProfile { - name: m.data.profile.name.into(), - display_name: m.data.profile.display_name.into(), - nip05: m.data.profile.nip05.into(), - about: m.data.profile.about.into(), - website: m.data.profile.website, - picture: m.data.profile.picture, - banner: m.data.profile.banner, - lud06: m.data.profile.lud06, - lud16: m.data.profile.lud16, - bot: m.data.profile.bot, - }, - }); - } - #[cfg(not(feature = "nostr-client"))] - { - None - } - } - - pub fn nostr_post_profile( - &self, - name: Option<String>, - display_name: Option<String>, - nip05: Option<String>, - about: Option<String>, - ) -> Result<String, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - mgr.publish_profile_event_blocking(name, display_name, nip05, about) - .map_err(|e| RadrootsAppError::Msg(e.to_string())) - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = (name, display_name, nip05, about); - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn nostr_post_text_note(&self, content: String) -> Result<String, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - mgr.publish_post_event_blocking(content) - .map_err(|e| RadrootsAppError::Msg(e.to_string())) - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = content; - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn nostr_fetch_text_notes( - &self, - limit: u16, - since_unix: Option<u64>, - ) -> Result<Vec<NostrPostEventMetadata>, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - let items = mgr - .fetch_post_events_blocking(limit, since_unix) - .map_err(|e| RadrootsAppError::Msg(e.to_string()))?; - Ok(items.into_iter().map(map_post_event_metadata).collect()) - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = (limit, since_unix); - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn nostr_post_reply( - &self, - parent_event_id_hex: String, - parent_author_hex: String, - content: String, - root_event_id_hex: Option<String>, - ) -> Result<String, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - mgr.publish_post_reply_event_blocking( - parent_event_id_hex, - parent_author_hex, - content, - root_event_id_hex, - ) - .map_err(|e| RadrootsAppError::Msg(e.to_string())) - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = ( - parent_event_id_hex, - parent_author_hex, - content, - root_event_id_hex, - ); - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn nostr_start_post_event_stream( - &self, - since_unix: Option<u64>, - ) -> Result<(), RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - mgr.start_post_event_stream(since_unix); - if let Ok(mut rx_guard) = self.post_events_rx.lock() { - if rx_guard.is_none() { - *rx_guard = Some(mgr.subscribe_post_events()); - } - } - Ok(()) - } - #[cfg(not(feature = "nostr-client"))] - { - let _ = since_unix; - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn nostr_next_post_event(&self) -> Option<NostrPostEventMetadata> { - #[cfg(feature = "nostr-client")] - { - let mut rx_guard = self.post_events_rx.lock().ok()?; - let rx = rx_guard.as_mut()?; - match rx.try_recv() { - Ok(event) => Some(map_post_event_metadata(event)), - Err(TryRecvError::Empty) => None, - Err(TryRecvError::Lagged(_)) => None, - Err(TryRecvError::Closed) => { - *rx_guard = None; - None - } - } - } - #[cfg(not(feature = "nostr-client"))] - { - None - } - } - - pub fn nostr_stop_post_event_stream(&self) -> Result<(), RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let guard = match self.net.lock() { - Ok(guard) => guard, - Err(err) => return Err(RadrootsAppError::Msg(format!("{err}"))), - }; - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - mgr.stop_post_event_stream(); - if let Ok(mut rx_guard) = self.post_events_rx.lock() { - *rx_guard = None; - } - Ok(()) - } - #[cfg(not(feature = "nostr-client"))] - { - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } -} diff --git a/core/provenance/tera_core/ancestral_source/src/runtime/trade_listing.rs b/core/provenance/tera_core/ancestral_source/src/runtime/trade_listing.rs @@ -1,865 +0,0 @@ -#![forbid(unsafe_code)] - -use core::str::FromStr; - -use radroots_core::{ - RadrootsCoreCurrency, RadrootsCoreDecimal, RadrootsCoreMoney, RadrootsCoreQuantity, - RadrootsCoreQuantityPrice, RadrootsCoreUnit, -}; -use radroots_events::{ - RadrootsNostrEventPtr, - listing::{ - RadrootsListing, RadrootsListingAvailability, RadrootsListingBin, - RadrootsListingDeliveryMethod, RadrootsListingFarmRef, RadrootsListingLocation, - RadrootsListingProduct, RadrootsListingStatus, - }, -}; -use radroots_events_codec::listing::encode::to_wire_parts as listing_to_wire_parts; -use radroots_nostr::prelude::{ - RadrootsNostrFilter, RadrootsNostrKind, RadrootsNostrTimestamp, radroots_event_from_nostr, - radroots_nostr_parse_pubkey, -}; -use radroots_trade::listing::{ - dvm::TradeListingAddress, - dvm::{ - TradeListingEnvelope, TradeListingMessagePayload, TradeListingMessageType, - TradeListingValidateRequest, - }, - kinds::TRADE_LISTING_KINDS, - order::{TradeOrder, TradeOrderItem, TradeOrderStatus}, - tags::trade_listing_dvm_tags, - validation::{RadrootsTradeListing, validate_listing_event}, -}; - -use super::RadrootsRuntime; -use crate::RadrootsAppError; - -const LISTING_KIND: u32 = 30402; - -#[derive(uniffi::Record, Debug, Clone)] -pub struct TradeListingDraft { - pub listing_id: Option<String>, - pub farm_pubkey: String, - pub farm_d_tag: String, - pub title: String, - pub description: String, - pub category: String, - pub bin_display_amount: String, - pub bin_display_unit: String, - pub unit_price: String, - pub currency: String, - pub bin_label: Option<String>, - pub bin_id: Option<String>, - pub inventory: String, - pub delivery_method: String, - pub location_primary: String, - pub location_city: Option<String>, - pub location_region: Option<String>, - pub location_country: Option<String>, -} - -#[derive(uniffi::Record, Debug, Clone)] -pub struct TradeListingSummary { - pub event_id: String, - pub seller_pubkey: String, - pub published_at: u64, - pub listing_id: String, - pub listing_addr: String, - pub title: String, - pub description: String, - pub product_type: String, - pub primary_bin_id: String, - pub unit_price_amount: String, - pub unit_price_currency: String, - pub unit_price_unit: String, - pub bin_display_amount: String, - pub bin_display_unit: String, - pub bin_display_label: Option<String>, - pub inventory_available: String, - pub availability: String, - pub location: String, - pub delivery_method: String, -} - -#[derive(uniffi::Record, Debug, Clone)] -pub struct TradeOrderDraft { - pub listing_addr: String, - pub seller_pubkey: String, - pub bin_id: String, - pub bin_count: String, - pub notes: Option<String>, - pub order_id: Option<String>, - pub recipient_pubkey: String, -} - -#[derive(uniffi::Record, Debug, Clone)] -pub struct TradeOrderSendResult { - pub event_id: String, - pub order_id: String, -} - -#[derive(uniffi::Record, Debug, Clone)] -pub struct TradeListingMessageSummary { - pub event_id: String, - pub author: String, - pub published_at: u64, - pub kind: u32, - pub message_type: String, - pub listing_addr: String, - pub order_id: Option<String>, - pub summary: String, - pub payload_json: String, -} - -#[cfg_attr(not(coverage_nightly), uniffi::export)] -impl RadrootsRuntime { - pub fn trade_listing_publish( - &self, - draft: TradeListingDraft, - ) -> Result<String, RadrootsAppError> { - let guard = self - .net - .lock() - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - #[cfg(feature = "nostr-client")] - { - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - let listing = listing_from_draft(&draft)?; - let current_pubkey = current_pubkey_hex(self)?; - if listing.farm.pubkey != current_pubkey { - return Err(RadrootsAppError::Msg( - "farm_pubkey must match the active key".into(), - )); - } - let parts = listing_to_wire_parts(&listing) - .map_err(|e| RadrootsAppError::Msg(format!("listing encode failed: {e}")))?; - mgr.send_custom_event_blocking(parts.kind, parts.content, parts.tags) - .map_err(|e| RadrootsAppError::Msg(e.to_string())) - } - #[cfg(not(feature = "nostr-client"))] - { - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn trade_listings_fetch( - &self, - limit: u16, - since_unix: Option<u64>, - ) -> Result<Vec<TradeListingSummary>, RadrootsAppError> { - let guard = self - .net - .lock() - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - #[cfg(feature = "nostr-client")] - { - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - let mut filter = - RadrootsNostrFilter::new().kind(RadrootsNostrKind::Custom(LISTING_KIND as u16)); - filter = filter.limit(limit.into()); - if let Some(since) = since_unix { - filter = filter.since(RadrootsNostrTimestamp::from(since)); - } - - let events = mgr - .fetch_events_blocking(filter, core::time::Duration::from_secs(10)) - .map_err(|e| RadrootsAppError::Msg(e.to_string()))?; - let mut out = Vec::new(); - for ev in events { - let event = radroots_event_from_nostr(&ev); - if event.kind != LISTING_KIND { - continue; - } - match validate_listing_event(&event) { - Ok(listing) => { - out.push(listing_summary_from_trade(listing, &event)); - } - Err(_) => continue, - } - } - out.sort_by(|a, b| b.published_at.cmp(&a.published_at)); - Ok(out) - } - #[cfg(not(feature = "nostr-client"))] - { - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn trade_listing_send_validation_request( - &self, - listing_event_id: String, - seller_pubkey: String, - listing_id: String, - recipient_pubkey: String, - ) -> Result<String, RadrootsAppError> { - let listing_addr = listing_addr_from_parts(&seller_pubkey, &listing_id)?; - let payload = - TradeListingMessagePayload::ListingValidateRequest(TradeListingValidateRequest { - listing_event: Some(RadrootsNostrEventPtr { - id: listing_event_id, - relays: None, - }), - }); - self.send_trade_listing_message( - TradeListingMessageType::ListingValidateRequest, - listing_addr, - None, - payload, - recipient_pubkey, - ) - } - - pub fn trade_listing_send_order_request( - &self, - draft: TradeOrderDraft, - ) -> Result<TradeOrderSendResult, RadrootsAppError> { - #[cfg(feature = "nostr-client")] - { - let order_id = normalize_optional_id(draft.order_id); - let order_id = order_id - .unwrap_or_else(|| format!("order-{}", chrono::Utc::now().timestamp_millis())); - let buyer_pubkey = current_pubkey_hex(self)?; - let seller_pubkey = normalize_pubkey(&draft.seller_pubkey)?; - - let bin_id = draft.bin_id.trim(); - if bin_id.is_empty() { - return Err(RadrootsAppError::Msg("bin_id is required".into())); - } - let bin_count = parse_u32(&draft.bin_count, "bin_count")?; - if bin_count == 0 { - return Err(RadrootsAppError::Msg("bin_count must be > 0".into())); - } - - let item = TradeOrderItem { - bin_id: bin_id.to_string(), - bin_count, - }; - - let notes = draft - .notes - .as_deref() - .map(|s| s.trim()) - .filter(|s| !s.is_empty()) - .map(|s| s.to_string()); - - let order = TradeOrder { - order_id: order_id.clone(), - listing_addr: draft.listing_addr.clone(), - buyer_pubkey, - seller_pubkey, - items: vec![item], - discounts: None, - notes, - status: TradeOrderStatus::Requested, - }; - - let payload = TradeListingMessagePayload::OrderRequest(order); - let event_id = self.send_trade_listing_message( - TradeListingMessageType::OrderRequest, - draft.listing_addr, - Some(order_id.clone()), - payload, - draft.recipient_pubkey, - )?; - - Ok(TradeOrderSendResult { event_id, order_id }) - } - #[cfg(not(feature = "nostr-client"))] - { - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } - - pub fn trade_listing_fetch_messages( - &self, - listing_addr: String, - order_id: Option<String>, - limit: u16, - since_unix: Option<u64>, - ) -> Result<Vec<TradeListingMessageSummary>, RadrootsAppError> { - let guard = self - .net - .lock() - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - #[cfg(feature = "nostr-client")] - { - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - - let kinds: Vec<RadrootsNostrKind> = TRADE_LISTING_KINDS - .iter() - .map(|k| RadrootsNostrKind::Custom(*k)) - .collect(); - - let mut filter = RadrootsNostrFilter::new().kinds(kinds); - filter = filter.limit(limit.into()); - if let Some(since) = since_unix { - filter = filter.since(RadrootsNostrTimestamp::from(since)); - } - - let events = mgr - .fetch_events_blocking(filter, core::time::Duration::from_secs(10)) - .map_err(|e| RadrootsAppError::Msg(e.to_string()))?; - - let mut out = Vec::new(); - for ev in events { - let content = ev.content.clone(); - let envelope: TradeListingEnvelope<TradeListingMessagePayload> = - match serde_json::from_str(&content) { - Ok(env) => env, - Err(_) => continue, - }; - if envelope.validate().is_err() { - continue; - } - if envelope.listing_addr != listing_addr { - continue; - } - if let Some(ref oid) = order_id { - if envelope.order_id.as_deref() != Some(oid) { - continue; - } - } - let kind_u32 = ev.kind.as_u16() as u32; - if envelope.message_type.kind() as u32 != kind_u32 { - continue; - } - - let summary = message_summary(&envelope.payload); - out.push(TradeListingMessageSummary { - event_id: ev.id.to_string(), - author: ev.pubkey.to_string(), - published_at: ev.created_at.as_secs(), - kind: kind_u32, - message_type: message_type_label(envelope.message_type).to_string(), - listing_addr: envelope.listing_addr.clone(), - order_id: envelope.order_id.clone(), - summary, - payload_json: content, - }); - } - out.sort_by(|a, b| b.published_at.cmp(&a.published_at)); - Ok(out) - } - #[cfg(not(feature = "nostr-client"))] - { - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } -} - -impl RadrootsRuntime { - fn send_trade_listing_message( - &self, - message_type: TradeListingMessageType, - listing_addr: String, - order_id: Option<String>, - payload: TradeListingMessagePayload, - recipient_pubkey: String, - ) -> Result<String, RadrootsAppError> { - let guard = self - .net - .lock() - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - #[cfg(feature = "nostr-client")] - { - let mgr = guard - .nostr - .as_ref() - .ok_or_else(|| RadrootsAppError::Msg("nostr not initialized".into()))?; - let recipient_hex = normalize_pubkey(&recipient_pubkey)?; - let envelope = TradeListingEnvelope::new( - message_type, - listing_addr.clone(), - order_id.clone(), - payload, - ); - envelope - .validate() - .map_err(|e| RadrootsAppError::Msg(e.to_string()))?; - let content = serde_json::to_string(&envelope) - .map_err(|e| RadrootsAppError::Msg(format!("encode envelope failed: {e}")))?; - let tags = trade_listing_dvm_tags(recipient_hex, listing_addr, order_id); - mgr.send_custom_event_blocking(message_type.kind() as u32, content, tags) - .map_err(|e| RadrootsAppError::Msg(e.to_string())) - } - #[cfg(not(feature = "nostr-client"))] - { - Err(RadrootsAppError::Msg("nostr disabled".into())) - } - } -} - -fn listing_from_draft(draft: &TradeListingDraft) -> Result<RadrootsListing, RadrootsAppError> { - let listing_id = draft - .listing_id - .as_deref() - .map(|s| s.trim()) - .filter(|s| !s.is_empty()) - .map(|s| s.to_string()) - .unwrap_or_else(|| format!("listing-{}", chrono::Utc::now().timestamp_millis())); - let farm_pubkey = draft.farm_pubkey.trim(); - if farm_pubkey.is_empty() { - return Err(RadrootsAppError::Msg("farm_pubkey is required".into())); - } - let farm_pubkey = normalize_pubkey(farm_pubkey)?; - let farm_d_tag = draft.farm_d_tag.trim(); - if farm_d_tag.is_empty() { - return Err(RadrootsAppError::Msg("farm_d_tag is required".into())); - } - - let title = draft.title.trim(); - if title.is_empty() { - return Err(RadrootsAppError::Msg("title is required".into())); - } - let description = draft.description.trim(); - if description.is_empty() { - return Err(RadrootsAppError::Msg("description is required".into())); - } - let category = draft.category.trim(); - if category.is_empty() { - return Err(RadrootsAppError::Msg("category is required".into())); - } - let location_primary = draft.location_primary.trim(); - if location_primary.is_empty() { - return Err(RadrootsAppError::Msg("location is required".into())); - } - - let display_amount = parse_decimal(&draft.bin_display_amount, "bin_display_amount")?; - ensure_non_negative(&display_amount, "bin_display_amount")?; - let display_unit = parse_unit(&draft.bin_display_unit)?; - let unit_price_amount = parse_decimal(&draft.unit_price, "unit_price")?; - ensure_non_negative(&unit_price_amount, "unit_price")?; - let currency = parse_currency(&draft.currency)?; - let inventory = parse_decimal(&draft.inventory, "inventory")?; - ensure_non_negative(&inventory, "inventory")?; - - let display_quantity = RadrootsCoreQuantity::new(display_amount, display_unit); - let canonical_quantity = display_quantity - .to_canonical() - .map_err(|e| RadrootsAppError::Msg(format!("invalid bin_display_unit: {e}")))?; - let unit_price = RadrootsCoreMoney::new(unit_price_amount, currency); - let price_per_display_unit = RadrootsCoreQuantityPrice::new( - unit_price.clone(), - RadrootsCoreQuantity::new(RadrootsCoreDecimal::ONE, display_unit), - ); - let price_per_canonical_unit = price_per_display_unit - .try_to_canonical_unit_price() - .map_err(|e| RadrootsAppError::Msg(format!("invalid unit_price: {e:?}")))?; - let bin_label = clean_optional(&draft.bin_label); - let bin_id = normalize_optional_id(draft.bin_id.clone()).unwrap_or_else(|| "bin-1".to_string()); - let bin = RadrootsListingBin { - bin_id: bin_id.clone(), - quantity: canonical_quantity, - price_per_canonical_unit, - display_amount: Some(display_amount), - display_unit: Some(display_unit), - display_label: bin_label, - display_price: Some(unit_price), - display_price_unit: Some(display_unit), - }; - - let delivery_method = parse_delivery_method(&draft.delivery_method)?; - - Ok(RadrootsListing { - d_tag: listing_id, - farm: RadrootsListingFarmRef { - pubkey: farm_pubkey, - d_tag: farm_d_tag.to_string(), - }, - product: RadrootsListingProduct { - key: category.to_string(), - title: title.to_string(), - category: category.to_string(), - summary: Some(description.to_string()), - process: None, - lot: None, - location: None, - profile: None, - year: None, - }, - primary_bin_id: bin_id, - bins: vec![bin], - resource_area: None, - plot: None, - discounts: None, - inventory_available: Some(inventory), - availability: Some(RadrootsListingAvailability::Status { - status: RadrootsListingStatus::Active, - }), - delivery_method: Some(delivery_method), - location: Some(RadrootsListingLocation { - primary: location_primary.to_string(), - city: clean_optional(&draft.location_city), - region: clean_optional(&draft.location_region), - country: clean_optional(&draft.location_country), - lat: None, - lng: None, - geohash: None, - }), - images: None, - }) -} - -fn listing_summary_from_trade( - listing: RadrootsTradeListing, - event: &radroots_events::RadrootsNostrEvent, -) -> TradeListingSummary { - let bin = listing - .listing - .bins - .iter() - .find(|bin| bin.bin_id == listing.primary_bin_id) - .or_else(|| listing.listing.bins.first()) - .expect("validated listing must include bins"); - let (display_amount, display_unit) = match (bin.display_amount.as_ref(), bin.display_unit) { - (Some(amount), Some(unit)) => (amount.clone(), unit), - _ => (bin.quantity.amount.clone(), bin.quantity.unit), - }; - let display_label = bin.display_label.clone().or(bin.quantity.label.clone()); - let display_label = clean_optional(&display_label); - let (unit_price_amount, unit_price_currency, unit_price_unit) = - match bin.price_per_canonical_unit.try_to_unit_price(display_unit) { - Ok(price) => ( - price.amount.amount.to_string(), - price.amount.currency.to_string(), - price.quantity.unit.to_string(), - ), - Err(_) => match (&bin.display_price, bin.display_price_unit) { - (Some(price), Some(unit)) => ( - price.amount.to_string(), - price.currency.to_string(), - unit.to_string(), - ), - _ => ( - bin.price_per_canonical_unit.amount.amount.to_string(), - bin.price_per_canonical_unit.amount.currency.to_string(), - bin.price_per_canonical_unit.quantity.unit.to_string(), - ), - }, - }; - - TradeListingSummary { - event_id: event.id.clone(), - seller_pubkey: event.author.clone(), - published_at: event.created_at as u64, - listing_id: listing.listing_id, - listing_addr: listing.listing_addr, - title: listing.title, - description: listing.description, - product_type: listing.product_type, - primary_bin_id: listing.primary_bin_id, - unit_price_amount, - unit_price_currency, - unit_price_unit, - bin_display_amount: display_amount.to_string(), - bin_display_unit: display_unit.to_string(), - bin_display_label: display_label, - inventory_available: listing.inventory_available.to_string(), - availability: availability_label(&listing.availability), - location: format_location(&listing.location), - delivery_method: delivery_method_label(&listing.delivery_method).to_string(), - } -} - -fn listing_addr_from_parts( - seller_pubkey: &str, - listing_id: &str, -) -> Result<String, RadrootsAppError> { - let listing_id = listing_id.trim(); - if listing_id.is_empty() { - return Err(RadrootsAppError::Msg("listing_id is required".into())); - } - let seller_hex = normalize_pubkey(seller_pubkey)?; - Ok(TradeListingAddress { - kind: LISTING_KIND as u16, - seller_pubkey: seller_hex, - listing_id: listing_id.to_string(), - } - .as_str()) -} - -fn normalize_pubkey(pubkey: &str) -> Result<String, RadrootsAppError> { - let key = radroots_nostr_parse_pubkey(pubkey.trim()) - .map_err(|e| RadrootsAppError::Msg(e.to_string()))?; - Ok(key.to_hex()) -} - -fn normalize_optional_id(id: Option<String>) -> Option<String> { - id.as_deref() - .map(|s| s.trim()) - .filter(|s| !s.is_empty()) - .map(|s| s.to_string()) -} - -#[cfg(feature = "nostr-client")] -fn current_pubkey_hex(runtime: &RadrootsRuntime) -> Result<String, RadrootsAppError> { - let guard = runtime - .net - .lock() - .map_err(|e| RadrootsAppError::Msg(format!("{e}")))?; - let keys = guard - .selected_nostr_keys() - .ok_or_else(|| RadrootsAppError::Msg("no selected signing identity".into()))?; - Ok(keys.public_key().to_hex()) -} - -fn parse_decimal(value: &str, label: &str) -> Result<RadrootsCoreDecimal, RadrootsAppError> { - RadrootsCoreDecimal::from_str(value.trim()) - .map_err(|e| RadrootsAppError::Msg(format!("invalid {label}: {e}"))) -} - -fn parse_unit(value: &str) -> Result<RadrootsCoreUnit, RadrootsAppError> { - RadrootsCoreUnit::from_str(value.trim()) - .map_err(|e| RadrootsAppError::Msg(format!("invalid unit: {e}"))) -} - -fn parse_currency(value: &str) -> Result<RadrootsCoreCurrency, RadrootsAppError> { - RadrootsCoreCurrency::from_str(value.trim()) - .map_err(|e| RadrootsAppError::Msg(format!("invalid currency: {e}"))) -} - -fn parse_u32(value: &str, label: &str) -> Result<u32, RadrootsAppError> { - value - .trim() - .parse::<u32>() - .map_err(|e| RadrootsAppError::Msg(format!("invalid {label}: {e}"))) -} - -fn ensure_non_negative(value: &RadrootsCoreDecimal, label: &str) -> Result<(), RadrootsAppError> { - if value.is_sign_negative() { - return Err(RadrootsAppError::Msg(format!( - "{label} must be non-negative" - ))); - } - Ok(()) -} - -fn parse_delivery_method(value: &str) -> Result<RadrootsListingDeliveryMethod, RadrootsAppError> { - let raw = value.trim(); - if raw.is_empty() { - return Err(RadrootsAppError::Msg("delivery_method is required".into())); - } - let lowered = raw.to_ascii_lowercase(); - Ok(match lowered.as_str() { - "pickup" => RadrootsListingDeliveryMethod::Pickup, - "local_delivery" | "local delivery" => RadrootsListingDeliveryMethod::LocalDelivery, - "shipping" => RadrootsListingDeliveryMethod::Shipping, - _ => RadrootsListingDeliveryMethod::Other { - method: raw.to_string(), - }, - }) -} - -fn availability_label(availability: &RadrootsListingAvailability) -> String { - match availability { - RadrootsListingAvailability::Status { status } => match status { - RadrootsListingStatus::Active => "active".to_string(), - RadrootsListingStatus::Sold => "sold".to_string(), - RadrootsListingStatus::Other { value } => value.clone(), - }, - RadrootsListingAvailability::Window { start, end } => { - let start = start - .map(|s| s.to_string()) - .unwrap_or_else(|| "unknown".into()); - let end = end - .map(|s| s.to_string()) - .unwrap_or_else(|| "unknown".into()); - format!("{start} - {end}") - } - } -} - -fn delivery_method_label(method: &RadrootsListingDeliveryMethod) -> &'static str { - match method { - RadrootsListingDeliveryMethod::Pickup => "pickup", - RadrootsListingDeliveryMethod::LocalDelivery => "local delivery", - RadrootsListingDeliveryMethod::Shipping => "shipping", - RadrootsListingDeliveryMethod::Other { .. } => "other", - } -} - -fn format_location(location: &RadrootsListingLocation) -> String { - let mut parts = Vec::with_capacity(4); - if !location.primary.trim().is_empty() { - parts.push(location.primary.trim()); - } - if let Some(city) = location.city.as_deref() { - if !city.trim().is_empty() { - parts.push(city.trim()); - } - } - if let Some(region) = location.region.as_deref() { - if !region.trim().is_empty() { - parts.push(region.trim()); - } - } - if let Some(country) = location.country.as_deref() { - if !country.trim().is_empty() { - parts.push(country.trim()); - } - } - if parts.is_empty() { - "n/a".to_string() - } else { - parts.join(", ") - } -} - -fn clean_optional(value: &Option<String>) -> Option<String> { - value - .as_deref() - .map(|s| s.trim()) - .filter(|s| !s.is_empty()) - .map(|s| s.to_string()) -} - -fn message_type_label(message_type: TradeListingMessageType) -> &'static str { - match message_type { - TradeListingMessageType::ListingValidateRequest => "listing_validate_request", - TradeListingMessageType::ListingValidateResult => "listing_validate_result", - TradeListingMessageType::OrderRequest => "order_request", - TradeListingMessageType::OrderResponse => "order_response", - TradeListingMessageType::OrderRevision => "order_revision", - TradeListingMessageType::OrderRevisionAccept => "order_revision_accept", - TradeListingMessageType::OrderRevisionDecline => "order_revision_decline", - TradeListingMessageType::Question => "question", - TradeListingMessageType::Answer => "answer", - TradeListingMessageType::DiscountRequest => "discount_request", - TradeListingMessageType::DiscountOffer => "discount_offer", - TradeListingMessageType::DiscountAccept => "discount_accept", - TradeListingMessageType::DiscountDecline => "discount_decline", - TradeListingMessageType::Cancel => "cancel", - TradeListingMessageType::FulfillmentUpdate => "fulfillment_update", - TradeListingMessageType::Receipt => "receipt", - } -} - -fn message_summary(payload: &TradeListingMessagePayload) -> String { - match payload { - TradeListingMessagePayload::ListingValidateRequest(_) => { - "Listing validation requested".to_string() - } - TradeListingMessagePayload::ListingValidateResult(result) => { - if result.valid { - "Listing validated".to_string() - } else if let Some(first) = result.errors.first() { - format!("Listing invalid: {first}") - } else { - "Listing invalid".to_string() - } - } - TradeListingMessagePayload::OrderRequest(order) => { - let item = order.items.first(); - match item { - Some(i) => format!("Order requested: {}x {}", i.bin_count, i.bin_id), - None => "Order requested".to_string(), - } - } - TradeListingMessagePayload::OrderResponse(res) => { - if res.accepted { - "Order accepted".to_string() - } else if let Some(reason) = res.reason.as_deref() { - format!("Order declined: {reason}") - } else { - "Order declined".to_string() - } - } - TradeListingMessagePayload::OrderRevision(_) => "Order revision proposed".to_string(), - TradeListingMessagePayload::OrderRevisionAccept(_) => "Order revision accepted".to_string(), - TradeListingMessagePayload::OrderRevisionDecline(_) => { - "Order revision declined".to_string() - } - TradeListingMessagePayload::Question(q) => format!("Question: {}", q.question_text), - TradeListingMessagePayload::Answer(a) => format!("Answer: {}", a.answer_text), - TradeListingMessagePayload::DiscountRequest(_) => "Discount requested".to_string(), - TradeListingMessagePayload::DiscountOffer(_) => "Discount offered".to_string(), - TradeListingMessagePayload::DiscountAccept(_) => "Discount accepted".to_string(), - TradeListingMessagePayload::DiscountDecline(_) => "Discount declined".to_string(), - TradeListingMessagePayload::Cancel(c) => { - if let Some(reason) = c.reason.as_deref() { - format!("Order cancelled: {reason}") - } else { - "Order cancelled".to_string() - } - } - TradeListingMessagePayload::FulfillmentUpdate(update) => { - format!("Fulfillment update: {:?}", update.status) - } - TradeListingMessagePayload::Receipt(receipt) => { - if receipt.acknowledged { - "Receipt acknowledged".to_string() - } else { - "Receipt update".to_string() - } - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn listing_from_draft_requires_fields() { - let draft = TradeListingDraft { - listing_id: None, - farm_pubkey: "".into(), - farm_d_tag: "".into(), - title: "".into(), - description: "Desc".into(), - category: "Coffee".into(), - bin_display_amount: "1".into(), - bin_display_unit: "lb".into(), - unit_price: "10.00".into(), - currency: "USD".into(), - bin_label: None, - bin_id: None, - inventory: "10".into(), - delivery_method: "shipping".into(), - location_primary: "Farm".into(), - location_city: None, - location_region: None, - location_country: None, - }; - assert!(listing_from_draft(&draft).is_err()); - } - - #[test] - fn listing_from_draft_builds_listing() { - let draft = TradeListingDraft { - listing_id: Some("AAAAAAAAAAAAAAAAAAAAAg".into()), - farm_pubkey: "npub180cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwsyjh6w6".into(), - farm_d_tag: "AAAAAAAAAAAAAAAAAAAAAA".into(), - title: "Coffee".into(), - description: "Washed".into(), - category: "coffee".into(), - bin_display_amount: "1".into(), - bin_display_unit: "lb".into(), - unit_price: "12.50".into(), - currency: "USD".into(), - bin_label: Some("bag".into()), - bin_id: None, - inventory: "5".into(), - delivery_method: "shipping".into(), - location_primary: "Farm".into(), - location_city: Some("Town".into()), - location_region: Some("Region".into()), - location_country: Some("US".into()), - }; - let listing = listing_from_draft(&draft).expect("listing builds"); - assert_eq!(listing.d_tag, "AAAAAAAAAAAAAAAAAAAAAg"); - assert_eq!(listing.product.title, "Coffee"); - assert!(listing.delivery_method.is_some()); - assert!(listing.location.is_some()); - } -} diff --git a/core/provenance/tera_core/ancestral_source/tests/logging_error.rs b/core/provenance/tera_core/ancestral_source/tests/logging_error.rs @@ -1,9 +0,0 @@ -use radroots_studio_app_core::RadrootsAppError; -use radroots_studio_app_core::logging; - -#[test] -fn init_logging_stdout_maps_global_subscriber_error() { - let _ = tracing_subscriber::fmt().try_init(); - let err = logging::init_logging_stdout(); - assert!(matches!(err, Err(RadrootsAppError::Msg(_)))); -} diff --git a/core/provenance/tera_core/ancestral_source/tests/no_nostr_runtime.rs b/core/provenance/tera_core/ancestral_source/tests/no_nostr_runtime.rs @@ -1,153 +0,0 @@ -#![cfg(not(feature = "nostr-client"))] - -use radroots_studio_app_core::logging; -use radroots_studio_app_core::runtime::builder::RuntimeBuilder; -use radroots_studio_app_core::runtime::nostr::{ - NostrConnectionStatus, NostrEvent, NostrLight, NostrPost, NostrPostEventMetadata, NostrProfile, - NostrProfileEventMetadata, -}; -use radroots_studio_app_core::{RadrootsAppError, RadrootsRuntime}; -use radroots_net_core::config::NetConfig; - -fn expect_disabled<T>(result: Result<T, RadrootsAppError>) { - match result { - Err(RadrootsAppError::Msg(message)) => assert_eq!(message, "nostr disabled"), - _ => panic!("expected nostr disabled error"), - } -} - -#[test] -fn runtime_info_and_platform_paths_are_exercised() { - let runtime = RadrootsRuntime::new().expect("runtime"); - assert!(runtime.uptime_millis() >= 0); - - runtime.stop(); - runtime.stop(); -} - -#[test] -fn key_management_disabled_paths_are_exercised() { - let runtime = RadrootsRuntime::new().expect("runtime"); - - assert!(!runtime.accounts_has_selected_signing_identity()); - assert_eq!(runtime.accounts_selected_npub(), None); - expect_disabled(runtime.accounts_list_ids()); - expect_disabled(runtime.accounts_generate(Some("alpha".to_string()), true)); - expect_disabled(runtime.accounts_import_secret( - "deadbeef".to_string(), - Some("alpha".to_string()), - true, - )); - expect_disabled(runtime.accounts_import_from_path( - "/tmp/nostr.json".to_string(), - Some("alpha".to_string()), - true, - )); - expect_disabled(runtime.accounts_export_selected_secret_hex()); - expect_disabled(runtime.accounts_select("account-1".to_string())); - expect_disabled(runtime.accounts_remove("account-1".to_string())); -} - -#[test] -fn nostr_disabled_paths_are_exercised() { - let runtime = RadrootsRuntime::new().expect("runtime"); - - let status = runtime.nostr_connection_status(); - assert_eq!(status.connected, 0); - assert_eq!(status.connecting, 0); - assert!(status.last_error.is_none()); - - assert!(runtime.nostr_profile_for_self().is_none()); - assert!(runtime.nostr_next_post_event().is_none()); - - expect_disabled(runtime.nostr_set_default_relays(vec!["wss://relay.example.com".to_string()])); - expect_disabled(runtime.nostr_connect_if_key_present()); - expect_disabled(runtime.nostr_post_profile(None, None, None, None)); - expect_disabled(runtime.nostr_post_text_note("hello".to_string())); - expect_disabled(runtime.nostr_fetch_text_notes(25, Some(0))); - expect_disabled(runtime.nostr_post_reply( - "event-id".to_string(), - "author".to_string(), - "reply".to_string(), - None, - )); - expect_disabled(runtime.nostr_start_post_event_stream(None)); - expect_disabled(runtime.nostr_stop_post_event_stream()); -} - -#[test] -fn runtime_builder_and_logging_paths_are_exercised() { - let handle = RuntimeBuilder::new() - .with_config(NetConfig::default()) - .manage_runtime(false) - .build() - .expect("build net handle"); - drop(handle); - let default_handle = RuntimeBuilder::new() - .build() - .expect("build default net handle"); - drop(default_handle); - - let err = logging::init_logging(Some("/dev/null/file.log".to_string()), None, Some(false)); - assert!(matches!(err, Err(RadrootsAppError::Msg(_)))); - let _ = logging::init_logging(None, None, None); - let _ = logging::init_logging(None, Some("app.log".to_string()), Some(false)); - let _ = logging::init_logging_stdout(); - - assert!(logging::log_info("info".to_string()).is_ok()); - assert!(logging::log_error("error".to_string()).is_ok()); - assert!(logging::log_debug("debug".to_string()).is_ok()); -} - -#[test] -fn nostr_records_and_enums_are_exercised() { - let status = NostrConnectionStatus { - light: NostrLight::Yellow, - connected: 1, - connecting: 2, - last_error: Some("err".to_string()), - }; - let _status_debug = format!("{status:?}"); - let _status_clone = status.clone(); - - let profile = NostrProfile::default(); - let _profile_debug = format!("{profile:?}"); - let _profile_clone = profile.clone(); - - let profile_event = NostrProfileEventMetadata { - id: "id".to_string(), - author: "author".to_string(), - published_at: 1, - profile, - }; - let _profile_event_debug = format!("{profile_event:?}"); - let _profile_event_clone = profile_event.clone(); - - let event = NostrEvent { - id: "event-id".to_string(), - author: "event-author".to_string(), - created_at: 2, - kind: 1, - content: "content".to_string(), - }; - let _event_debug = format!("{event:?}"); - let _event_clone = event.clone(); - - let post = NostrPost { - content: "post".to_string(), - }; - let _post_debug = format!("{post:?}"); - let _post_clone = post.clone(); - - let post_event = NostrPostEventMetadata { - id: "id".to_string(), - author: "author".to_string(), - published_at: 3, - post, - }; - let _post_event_debug = format!("{post_event:?}"); - let _post_event_clone = post_event.clone(); - - assert!(matches!(NostrLight::Red, NostrLight::Red)); - assert!(matches!(NostrLight::Green, NostrLight::Green)); -}