commit 7e06829b72657707cb4de95e837af9b188745f65 parent 605c23d5d5edfdbf86e548b7ac0ce57cd0a7ca22 Author: triesap <tyson@radroots.org> Date: Tue, 20 Oct 2026 03:51:04 +0000 transport: Separate the shared Nostr session from native I/O - Keep one upstream session and exact writer over an explicit neutral host - Adopt the native provider in SDK and facade callers with retained socket tests - Preserve ingress budgets and support browser IntoFuture deadlines - Allocate the native package with reviewed APIs and verified owning gates Diffstat:
68 files changed, 2878 insertions(+), 2803 deletions(-)
diff --git a/AGENTS.md b/AGENTS.md @@ -196,7 +196,7 @@ Before editing code: - Preserve deferred flake expressions as unqualified compatibility inputs; do not use their evaluation or outputs as evidence until an accepted contract explicitly reactivates them. -- `contracts/crates/release.v2.toml` records the twenty-one current public Lib +- `contracts/crates/release.v2.toml` records the twenty-two current public Lib packages, including `radroots_sdk` and `radroots`. Release V1's earlier repository split remains history. The approved successor replaces old SDK/trade/model boundaries directly and retains ancillary capabilities; diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md @@ -10,7 +10,7 @@ reviewable. Before editing, read these files in order: crate-surface work 5. the affected manifests, implementation, contracts, and tests -Release V2 records the twenty-one current public Lib packages, including +Release V2 records the twenty-two current public Lib packages, including `radroots_sdk` and `radroots`. The earlier `radroots.crates.release.v1` repository split remains immutable history. The approved successor is `contracts/architecture/decisions/shared_sdk_refactor.v1.json`: Lib owns shared diff --git a/Cargo.lock b/Cargo.lock @@ -3058,6 +3058,7 @@ dependencies = [ "radroots_trade", "radroots_transport", "radroots_transport_nostr", + "radroots_transport_nostr_native", "serde_json", "sqlx", "tempfile", @@ -3444,6 +3445,7 @@ dependencies = [ "radroots_trade", "radroots_transport", "radroots_transport_nostr", + "radroots_transport_nostr_native", "reqwest", "serde", "serde_json", @@ -3770,21 +3772,19 @@ dependencies = [ "async-utility", "async-wsocket", "futures", + "getrandom 0.4.2", "nostr-sdk", "radroots_event_codec", "radroots_nostr", "radroots_protocol", "radroots_transport", - "rustls", "serde_json", "sha2", "tokio", - "tokio-rustls", "tokio-tungstenite", "url", "wasm-bindgen-futures", "web-time", - "webpki-roots 0.26.11", ] [[package]] @@ -3792,9 +3792,12 @@ name = "radroots_transport_nostr_native" version = "0.1.0-alpha" dependencies = [ "futures", + "nostr-sdk", + "radroots_event_codec", "radroots_transport", "radroots_transport_nostr", "rustls", + "serde_json", "tokio", "tokio-rustls", "tokio-tungstenite", diff --git a/Cargo.toml b/Cargo.toml @@ -74,6 +74,7 @@ default-members = [ "crates/storage", "crates/storage_sqlite", "crates/transport_nostr", + "crates/transport_nostr_native", "crates/sync", "crates/geonames", "crates/sdk", @@ -195,6 +196,7 @@ flate2 = { version = "1" } fs2 = { version = "0.4" } goblin = { version = "0.8.2" } getrandom = { version = "0.2", default-features = false } +getrandom_04 = { package = "getrandom", version = "=0.4.2", default-features = false } hkdf = { version = "0.12", default-features = false } hmac = { version = "0.12", default-features = false } http = { version = "1" } diff --git a/contracts/api_baselines/radroots_transport_nostr.txt b/contracts/api_baselines/radroots_transport_nostr.txt @@ -86,7 +86,7 @@ pub fn radroots_transport_nostr::NostrTransport::admission_is_closed(&self) -> b pub fn radroots_transport_nostr::NostrTransport::close_admission(&self) pub const fn radroots_transport_nostr::NostrTransport::config(&self) -> &radroots_transport_nostr::Config pub fn radroots_transport_nostr::NostrTransport::has_in_flight_operations(&self) -> bool -pub fn radroots_transport_nostr::NostrTransport::new(radroots_transport_nostr::Config) -> Self +pub fn radroots_transport_nostr::NostrTransport::new(radroots_transport_nostr::Config, alloc::sync::Arc<dyn radroots_transport::host::websocket::Connector>) -> Self pub fn radroots_transport_nostr::NostrTransport::relay_status(&self) -> radroots_transport_nostr::RelayStatusReport pub async fn radroots_transport_nostr::NostrTransport::shutdown(&self) impl radroots_transport_nostr::NostrTransport diff --git a/contracts/api_baselines/radroots_transport_nostr_native.txt b/contracts/api_baselines/radroots_transport_nostr_native.txt @@ -0,0 +1,6 @@ +pub mod radroots_transport_nostr_native +pub struct radroots_transport_nostr_native::NativeConnector +impl radroots_transport::host::websocket::Connector for radroots_transport_nostr_native::NativeConnector +pub fn radroots_transport_nostr_native::NativeConnector::connect<'a>(&'a self, &'a str, core::time::Duration, core::num::nonzero::NonZeroUsize, alloc::sync::Arc<dyn radroots_transport::host::websocket::Admission>) -> radroots_transport::host::websocket::IoFuture<'a, core::result::Result<alloc::sync::Arc<dyn radroots_transport::host::websocket::Socket>, radroots_transport::host::websocket::Error>> +pub fn radroots_transport_nostr_native::NativeConnector::supports_ping(&self) -> bool +pub fn radroots_transport_nostr_native::create_transport(radroots_transport_nostr::client::Config) -> radroots_transport_nostr::client::NostrTransport diff --git a/contracts/crates/catalog.v2.toml b/contracts/crates/catalog.v2.toml @@ -6,7 +6,7 @@ version = "0.1.0-alpha" rust_version = "1.99.0" edition = "2024" resolver = "3" -public_package_count = 21 +public_package_count = 22 package_count = 55 digest_algorithm = "sha256-raw-bytes-v1" source_tree_digest_algorithm = "sha256-git-ls-tree-r-v1" @@ -396,7 +396,7 @@ visibility = "public_release" publish = true version = "0.1.0-alpha" license = "MIT OR Apache-2.0" -platforms = ["native"] +platforms = ["native", "wasm32"] groups = ["coverage_required", "portable", "public_native"] owners = ["transport"] permitted_dependency_tiers = ["foundation", "domain", "spi", "adapter"] @@ -413,17 +413,17 @@ name = "radroots_transport_nostr_native" path = "crates/transport_nostr_native" state = "active" tier = "adapter" -visibility = "private_adapter" -publish = false +visibility = "public_release" +publish = true version = "0.1.0-alpha" license = "MIT OR Apache-2.0" platforms = ["native"] -groups = ["coverage_required"] +groups = ["coverage_required", "portable", "public_native"] owners = ["transport"] permitted_dependency_tiers = ["foundation", "domain", "spi", "adapter"] provenance_kind = "native" introduction_tree_sha256 = "41069127e5d92252c4610c17b277fc817529052c416a43f798124cd890f420f7" -compatibility = ["package_private", "rust_api", "network"] +compatibility = ["package", "rust_api", "network"] replaces = [] [[package]] diff --git a/contracts/crates/generated/package_groups.v1.toml b/contracts/crates/generated/package_groups.v1.toml @@ -1,5 +1,5 @@ schema = "radroots.workspace.package-groups.v1" -catalog_sha256 = "ab9b926b02a729d897246902ac2bed7aa98c61ec002d5be959ecd1f624d14488" +catalog_sha256 = "9dc291f170c1888cd2f9e9acb10c1251e32dd7b94c9b3c347feb7a6eaa44b475" [[group]] id = "boundaries" @@ -15,8 +15,8 @@ reserved_packages = [] [[group]] id = "portable" -packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr"] -active_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr"] +packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native"] +active_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native"] reserved_packages = [] [[group]] @@ -27,8 +27,8 @@ reserved_packages = [] [[group]] id = "public_native" -packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr"] -active_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr"] +packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native"] +active_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native"] reserved_packages = [] [[group]] diff --git a/contracts/crates/generated/platform_inventory.v1.toml b/contracts/crates/generated/platform_inventory.v1.toml @@ -1,5 +1,5 @@ schema = "radroots.workspace.platform-inventory.v1" -catalog_sha256 = "ab9b926b02a729d897246902ac2bed7aa98c61ec002d5be959ecd1f624d14488" +catalog_sha256 = "9dc291f170c1888cd2f9e9acb10c1251e32dd7b94c9b3c347feb7a6eaa44b475" [[platform]] id = "any" @@ -11,4 +11,4 @@ packages = ["radroots_core_bindings", "radroots_event_bindings", "radroots_geona [[platform]] id = "wasm32" -packages = ["radroots_event_codec_wasm", "radroots_replica_store_wasm", "radroots_replica_sync_wasm", "radroots_sdk_sql_wasm_runtime", "radroots_sql_core", "radroots_storage_indexeddb"] +packages = ["radroots_event_codec_wasm", "radroots_replica_store_wasm", "radroots_replica_sync_wasm", "radroots_sdk_sql_wasm_runtime", "radroots_sql_core", "radroots_storage_indexeddb", "radroots_transport_nostr"] diff --git a/contracts/crates/generated/release_inventory.v2.toml b/contracts/crates/generated/release_inventory.v2.toml @@ -1,7 +1,7 @@ schema = "radroots.workspace.release-inventory.v2" -catalog_sha256 = "ab9b926b02a729d897246902ac2bed7aa98c61ec002d5be959ecd1f624d14488" +catalog_sha256 = "9dc291f170c1888cd2f9e9acb10c1251e32dd7b94c9b3c347feb7a6eaa44b475" architecture = "radroots.crates.release.v2" version = "0.1.0-alpha" -public_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr"] -private_packages = ["radroots_core_bindings", "radroots_event_bindings", "radroots_event_codec_wasm", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostrdb", "radroots_replica_schema", "radroots_replica_schema_bindings", "radroots_replica_store", "radroots_replica_store_wasm", "radroots_replica_sync", "radroots_replica_sync_wasm", "radroots_runtime_distribution", "radroots_runtime_manager", "radroots_runtime_paths", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_service_host", "radroots_service_sqlite", "radroots_simplex_agent_proto", "radroots_simplex_app_store", "radroots_simplex_chat_proto", "radroots_simplex_smp_crypto", "radroots_simplex_smp_proto", "radroots_simplex_smp_transport", "radroots_sql_core", "radroots_storage_indexeddb", "radroots_test_fixtures", "radroots_trade_bindings", "radroots_transport_nostr_native", "radroots_transport_reticulum", "xtask"] +public_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_domain", "radroots_event", "radroots_event_codec", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_nostr", "radroots_nostr_connect", "radroots_protocol", "radroots_sdk", "radroots_secrets", "radroots_signing", "radroots_storage", "radroots_storage_sqlite", "radroots_sync", "radroots_trade", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native"] +private_packages = ["radroots_core_bindings", "radroots_event_bindings", "radroots_event_codec_wasm", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostrdb", "radroots_replica_schema", "radroots_replica_schema_bindings", "radroots_replica_store", "radroots_replica_store_wasm", "radroots_replica_sync", "radroots_replica_sync_wasm", "radroots_runtime_distribution", "radroots_runtime_manager", "radroots_runtime_paths", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_service_host", "radroots_service_sqlite", "radroots_simplex_agent_proto", "radroots_simplex_app_store", "radroots_simplex_chat_proto", "radroots_simplex_smp_crypto", "radroots_simplex_smp_proto", "radroots_simplex_smp_transport", "radroots_sql_core", "radroots_storage_indexeddb", "radroots_test_fixtures", "radroots_trade_bindings", "radroots_transport_reticulum", "xtask"] reserved_packages = [] diff --git a/contracts/crates/release.v2.toml b/contracts/crates/release.v2.toml @@ -4,7 +4,7 @@ status = "approved_not_published" supersedes_without_mutation = "radroots.crates.release.v1" canonical_repository = "https://github.com/radrootslabs/lib" version = "0.1.0-alpha" -public_package_count = 21 +public_package_count = 22 publication_authorized = false public_packages = [ "radroots_domain", @@ -24,6 +24,7 @@ public_packages = [ "radroots_storage", "radroots_storage_sqlite", "radroots_transport_nostr", + "radroots_transport_nostr_native", "radroots_sync", "radroots_geonames", "radroots_sdk", diff --git a/contracts/manifest.toml b/contracts/manifest.toml @@ -24,6 +24,7 @@ algorithm_crates = [ "radroots_storage_sqlite", "radroots_sync", "radroots_transport_nostr", + "radroots_transport_nostr_native", ] [surface.rust_crate_tiers] @@ -47,6 +48,7 @@ published_support = [ "radroots_storage_sqlite", "radroots_sync", "radroots_transport_nostr", + "radroots_transport_nostr_native", ] deferred_publication = [ "radroots_transport_reticulum", diff --git a/contracts/operations.toml b/contracts/operations.toml @@ -284,6 +284,7 @@ algorithm_crates = [ "radroots_storage_sqlite", "radroots_sync", "radroots_transport_nostr", + "radroots_transport_nostr_native", ] [operations.blossom_parse_hash_path] diff --git a/contracts/releases/api_boundaries.toml b/contracts/releases/api_boundaries.toml @@ -83,6 +83,10 @@ name = "radroots_transport_nostr" allowed_public_paths = [] [[package]] +name = "radroots_transport_nostr_native" +allowed_public_paths = [] + +[[package]] name = "radroots_sync" allowed_public_paths = [] diff --git a/contracts/releases/api_semver.toml b/contracts/releases/api_semver.toml @@ -24,6 +24,7 @@ packages = [ "radroots_trade", "radroots_transport", "radroots_transport_nostr", + "radroots_transport_nostr_native", "radroots_sdk", "radroots", ] @@ -43,3 +44,7 @@ revision = "52e2a15a90aa4f07f053930be4dda203a0f6631a" [[baseline_override]] package = "radroots_execution" revision = "52e2a15a90aa4f07f053930be4dda203a0f6631a" + +[[baseline_override]] +package = "radroots_transport_nostr_native" +revision = "605c23d5d5edfdbf86e548b7ac0ce57cd0a7ca22" diff --git a/contracts/releases/package_tiers.toml b/contracts/releases/package_tiers.toml @@ -35,6 +35,7 @@ packages = [ "radroots_nostr_connect", "radroots_storage_sqlite", "radroots_transport_nostr", + "radroots_transport_nostr_native", "radroots_geonames", ] diff --git a/contracts/releases/publish_policy.toml b/contracts/releases/publish_policy.toml @@ -24,6 +24,7 @@ approved_packages = [ "radroots_storage", "radroots_storage_sqlite", "radroots_transport_nostr", + "radroots_transport_nostr_native", "radroots_sync", "radroots_geonames", "radroots_sdk", @@ -47,6 +48,7 @@ local_packages = [ "radroots_storage", "radroots_storage_sqlite", "radroots_transport_nostr", + "radroots_transport_nostr_native", "radroots_sync", "radroots_geonames", "radroots_sdk", @@ -64,7 +66,6 @@ private = [ "radroots_service_sqlite", "radroots_sql_core", "radroots_storage_indexeddb", - "radroots_transport_nostr_native", ] build_codegen = [ "radroots_core_bindings", @@ -115,6 +116,7 @@ crates = [ "radroots_storage", "radroots_storage_sqlite", "radroots_transport_nostr", + "radroots_transport_nostr_native", "radroots_sync", "radroots_execution", "radroots_geonames", diff --git a/contracts/releases/supply_chain.toml b/contracts/releases/supply_chain.toml @@ -136,3 +136,7 @@ manifest_path = "crates/domain/Cargo.toml" [[package]] name = "radroots_execution" manifest_path = "crates/execution/Cargo.toml" + +[[package]] +name = "radroots_transport_nostr_native" +manifest_path = "crates/transport_nostr_native/Cargo.toml" diff --git a/crates/radroots/Cargo.toml b/crates/radroots/Cargo.toml @@ -49,6 +49,7 @@ radroots_storage = { workspace = true } radroots_storage_sqlite = { workspace = true, optional = true } radroots_nostr = { workspace = true, features = ["signing", "nip17"], optional = true } radroots_transport_nostr = { workspace = true, optional = true } +radroots_transport_nostr_native = { workspace = true, optional = true } radroots_trade = { workspace = true, features = ["json", "std"] } radroots_transport = { workspace = true } tokio = { workspace = true, features = ["rt", "sync"], optional = true } @@ -56,7 +57,7 @@ tokio = { workspace = true, features = ["rt", "sync"], optional = true } [features] default = ["client"] client = ["radroots_sdk/default", "radroots_storage/memory"] -native = ["client", "radroots_sdk/native", "dep:radroots_storage_sqlite", "dep:futures", "dep:tokio", "dep:radroots_nostr", "dep:radroots_transport_nostr"] +native = ["client", "radroots_sdk/native", "dep:radroots_storage_sqlite", "dep:futures", "dep:tokio", "dep:radroots_nostr", "dep:radroots_transport_nostr", "dep:radroots_transport_nostr_native"] nostr = ["client", "radroots_sdk/nostr"] blossom = ["client", "radroots_sdk/blossom"] nip46 = ["nostr", "radroots_sdk/nip46"] @@ -75,6 +76,7 @@ futures = { workspace = true } radroots_event_codec = { workspace = true, default-features = false } radroots_nostr = { workspace = true, features = ["signing", "nip17"] } radroots_transport_nostr = { workspace = true } +radroots_transport_nostr_native = { workspace = true } tokio-tungstenite = { workspace = true } serde_json = { workspace = true, features = ["std"] } tempfile = { workspace = true } diff --git a/crates/radroots/src/native_inquiry.rs b/crates/radroots/src/native_inquiry.rs @@ -53,7 +53,7 @@ impl NativeInquiry { .validate_for(&write) .map_err(|_| OperationError::InvalidCommand)?; Ok(Self { - transport: NostrTransport::new(config), + transport: radroots_transport_nostr_native::create_transport(config), read, write, policy, diff --git a/crates/radroots/tests/package_boundary.rs b/crates/radroots/tests/package_boundary.rs @@ -27,6 +27,7 @@ fn package_has_final_identity_and_exact_dependencies() { "radroots_trade", "radroots_transport", "radroots_transport_nostr", + "radroots_transport_nostr_native", "tokio", ]) ); @@ -40,7 +41,7 @@ fn features_forward_the_exact_user_oriented_graph() { for forwarding in [ "default = [\"client\"]", "client = [\"radroots_sdk/default\", \"radroots_storage/memory\"]", - "native = [\"client\", \"radroots_sdk/native\", \"dep:radroots_storage_sqlite\", \"dep:futures\", \"dep:tokio\", \"dep:radroots_nostr\", \"dep:radroots_transport_nostr\"]", + "native = [\"client\", \"radroots_sdk/native\", \"dep:radroots_storage_sqlite\", \"dep:futures\", \"dep:tokio\", \"dep:radroots_nostr\", \"dep:radroots_transport_nostr\", \"dep:radroots_transport_nostr_native\"]", "nostr = [\"client\", \"radroots_sdk/nostr\"]", "nip46 = [\"nostr\", \"radroots_sdk/nip46\"]", "radrootsd = [\"client\", \"radroots_sdk/radrootsd\"]", diff --git a/crates/radroots/tests/support/receipt_delivery.rs b/crates/radroots/tests/support/receipt_delivery.rs @@ -20,8 +20,7 @@ use radroots_transport::{ policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, }; use radroots_transport_nostr::{ - Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, - RelayUrlPolicy, + Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, }; use std::{ num::NonZeroU64, @@ -350,7 +349,7 @@ async fn native_delivery_retains_exact_outer_before_loopback_and_reopen_preserve .await .unwrap(); }); - let transport = NostrTransport::new(ready.config.clone()); + let transport = radroots_transport_nostr_native::create_transport(ready.config.clone()); let request = attempt.transport_request().unwrap(); let receipt = transport.deliver(request.clone()).await.unwrap(); receipt.validate_for_request(&request).unwrap(); diff --git a/crates/radroots/tests/support/receipt_delivery_faults.rs b/crates/radroots/tests/support/receipt_delivery_faults.rs @@ -347,7 +347,7 @@ async fn actual_loopback_wrong_ack_timeout_disconnect_and_rejection_remain_disti }); let request = attempt.transport_request().unwrap(); let target = request.target_set().targets()[0].fingerprint(); - let transport = NostrTransport::new(ready.config.clone()); + let transport = radroots_transport_nostr_native::create_transport(ready.config.clone()); let result = transport.deliver(request.clone()).await; let observation = match result { Ok(receipt) => { diff --git a/crates/sdk/Cargo.toml b/crates/sdk/Cargo.toml @@ -46,7 +46,7 @@ default = ["memory"] memory = ["radroots_storage/memory"] sqlite = ["dep:radroots_storage_sqlite"] sync = ["dep:radroots_sync", "dep:uuid"] -nostr = ["sync", "blossom", "dep:radroots_transport_nostr"] +nostr = ["sync", "blossom", "dep:radroots_transport_nostr", "dep:radroots_transport_nostr_native"] blossom = [ "dep:radroots_blossom", "dep:radroots_nostr", @@ -97,6 +97,7 @@ radroots_secrets = { workspace = true, optional = true, default-features = false radroots_storage_sqlite = { workspace = true, optional = true, default-features = false } radroots_sync = { workspace = true, optional = true, default-features = false } radroots_transport_nostr = { workspace = true, optional = true, default-features = false } +radroots_transport_nostr_native = { workspace = true, optional = true, default-features = false } reqwest = { workspace = true, optional = true, default-features = false, features = [ "json", diff --git a/crates/sdk/src/transport.rs b/crates/sdk/src/transport.rs @@ -2027,7 +2027,7 @@ impl NostrSlot { return Err(crate::Error::client_closed()); } current.current = Some(NostrState { - transport: Arc::new(radroots_transport_nostr::NostrTransport::new(config)), + transport: Arc::new(radroots_transport_nostr_native::create_transport(config)), read_targets, write_targets, }); diff --git a/crates/sdk/tests/package_boundary.rs b/crates/sdk/tests/package_boundary.rs @@ -40,6 +40,7 @@ fn manifest_has_final_identity_and_dependency_boundary() { "radroots_trade", "radroots_transport", "radroots_transport_nostr", + "radroots_transport_nostr_native", ]); assert_eq!(dependencies, expected); for forbidden in [ diff --git a/crates/transport_nostr/Cargo.toml b/crates/transport_nostr/Cargo.toml @@ -41,25 +41,26 @@ radroots_nostr = { workspace = true, default-features = false, features = [ "events", ] } radroots_protocol = { workspace = true, default-features = false } -radroots_transport = { workspace = true, default-features = false } +radroots_transport = { workspace = true, default-features = false, features = ["std"] } async-wsocket = { workspace = true } futures = { workspace = true } nostr-sdk = { workspace = true } -rustls = { workspace = true } serde_json = { workspace = true, features = ["std"] } sha2 = { workspace = true, default-features = false } -tokio = { workspace = true, features = ["net", "time"] } -tokio-rustls = { workspace = true } -tokio-tungstenite = { workspace = true } +tokio = { workspace = true, features = ["sync"] } url = { workspace = true } -webpki-roots = { workspace = true } + +[target.'cfg(not(target_arch = "wasm32"))'.dependencies] +tokio = { workspace = true, features = ["time"] } [target.'cfg(target_arch = "wasm32")'.dependencies] async-utility = { workspace = true } +getrandom_04 = { workspace = true, features = ["wasm_js"] } wasm-bindgen-futures = { workspace = true } web-time = { workspace = true } [dev-dependencies] +tokio-tungstenite = { workspace = true } tokio = { workspace = true, features = [ "macros", "net", diff --git a/crates/transport_nostr/README.md b/crates/transport_nostr/README.md @@ -27,7 +27,8 @@ Fractional waits round up, long waits use bounded signed-delay chunks, and each wake rechecks the deadline before reporting expiry. Its isolated page/worker fixture lives in `tests/browser_time`; this does not qualify the -complete transport, which still requires native socket I/O at this checkpoint. +complete browser connector or ordinary client. Native socket ownership belongs +to `radroots_transport_nostr_native`; shared protocol state stays here. ## Configure without connecting @@ -41,6 +42,8 @@ use radroots_transport_nostr::{ RelayProfileKind, RelayUrlPolicy, }; +# fn configure(host: std::sync::Arc<dyn radroots_transport::host::websocket::Connector>) +# -> Result<(), Box<dyn std::error::Error>> { let endpoint = RelayEndpoint::new( "wss://relay.example.com", RelayUrlPolicy::Public, @@ -48,7 +51,7 @@ let endpoint = RelayEndpoint::new( )?; let profile = RelayProfile::explicit(RelayProfileKind::Public, [endpoint])?; let config = Config::from_profile(profile).with_timeouts(5_000, 20_000, 2_000)?; -let transport = NostrTransport::new(config); +let transport = NostrTransport::new(config, host); let source: &dyn EventSource = &transport; let subscriber: &dyn EventSubscriber = &transport; @@ -56,7 +59,8 @@ let sink: &dyn EventSink = &transport; drop(source.status()); let _ = subscriber; drop(sink.status()); -# Ok::<(), Box<dyn std::error::Error>>(()) +# Ok(()) +# } ``` A runnable version is available at @@ -340,8 +344,12 @@ event JSON. ## Features and runtime requirements -The package has no Cargo features. It is a standard-library native adapter; -Tokio and the upstream Nostr relay client are private implementation choices. +The package has no Cargo features. It is the standard-library shared protocol +adapter. Its constructor requires an explicit socket host through +`radroots_transport::host::websocket`. Native callers use +`radroots_transport_nostr_native::create_transport`; the browser provider is +separately governed. Concrete DNS, TCP, TLS and plaintext WebSocket metering do +not live in this package. The upstream Nostr relay client remains private. The crate never creates an executor, installs a runtime, launches an adapter-owned worker, installs a tracing subscriber, or owns process lifecycle. The host must poll operations from a compatible executor and provide diff --git a/crates/transport_nostr/examples/configure_transport.rs b/crates/transport_nostr/examples/configure_transport.rs @@ -4,7 +4,9 @@ use radroots_transport_nostr::{ RelayUrlPolicy, }; -fn main() -> Result<(), Box<dyn std::error::Error>> { +pub fn configure_transport( + host: std::sync::Arc<dyn radroots_transport::host::websocket::Connector>, +) -> Result<(), Box<dyn std::error::Error>> { let endpoint = RelayEndpoint::new( "wss://relay.example.com", RelayUrlPolicy::Public, @@ -12,7 +14,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> { )?; let profile = RelayProfile::explicit(RelayProfileKind::Public, [endpoint])?; let config = Config::from_profile(profile).with_timeouts(5_000, 20_000, 2_000)?; - let transport = NostrTransport::new(config); + let transport = NostrTransport::new(config, host); let source: &dyn EventSource = &transport; let subscriber: &dyn EventSubscriber = &transport; @@ -24,3 +26,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> { println!("configured a Nostr source, subscriber, and sink without opening a relay connection"); Ok(()) } + +fn main() { + println!("call configure_transport with an explicit socket host"); +} diff --git a/crates/transport_nostr/src/auth.rs b/crates/transport_nostr/src/auth.rs @@ -321,7 +321,7 @@ mod tests { .expect("profile"), ); let client = Arc::new(MockAuthClient(AtomicUsize::new(0))); - let transport = NostrTransport::new(config).with_auth_client(client.clone()); + let transport = crate::test_host::transport(config).with_auth_client(client.clone()); (transport, client, relay) } diff --git a/crates/transport_nostr/src/client.rs b/crates/transport_nostr/src/client.rs @@ -253,7 +253,7 @@ impl nostr_sdk::policy::AdmitPolicy for VerifiedEventAdmission { _relay_url: &'a nostr_sdk::prelude::RelayUrl, _subscription_id: &'a nostr_sdk::prelude::SubscriptionId, event: &'a nostr_sdk::prelude::Event, - ) -> radroots_transport::BoxFuture< + ) -> futures::future::BoxFuture< 'a, Result<nostr_sdk::policy::AdmitStatus, nostr_sdk::error::Error>, > { @@ -284,10 +284,14 @@ pub struct NostrTransport { impl NostrTransport { /// Creates an inert transport from validated explicit configuration. - pub fn new(config: Config) -> Self { - let connector = crate::relay::HardenedWebsocketTransport::new( + pub fn new( + config: Config, + host: Arc<dyn radroots_transport::host::websocket::Connector>, + ) -> Self { + let connector = crate::session_socket::SessionWebsocketTransport::new( config.endpoints(), std::time::Duration::from_millis(config.connect_timeout_ms()), + host, ); let writers = connector.writers.clone(); let ingress = connector.ingress.clone(); @@ -550,7 +554,7 @@ mod tests { .is_err() ); - let transport = NostrTransport::new(config.clone()); + let transport = crate::test_host::transport(config.clone()); assert_eq!(transport.config(), &config); let debug = format!("{transport:?}"); assert!(debug.contains("NostrTransport")); @@ -567,7 +571,7 @@ mod tests { ) .expect("profile"), ); - let transport = NostrTransport::new(config); + let transport = crate::test_host::transport(config); assert_eq!(transport.next_subscription_sequence(), Ok(1)); assert_eq!(transport.next_subscription_sequence(), Ok(2)); transport diff --git a/crates/transport_nostr/src/exact_delivery.rs b/crates/transport_nostr/src/exact_delivery.rs @@ -1,6 +1,6 @@ //! Exact retained EVENT framing and connection-local acknowledgement handling. -use crate::{relay::MAX_WIRE_MESSAGE_BYTES, socket_write::WriterRegistry, status}; +use crate::{session_socket::MAX_WIRE_MESSAGE_BYTES, socket_write::WriterRegistry, status}; use futures::StreamExt; use nostr_sdk::prelude::{EventId, RelayMessage}; use nostr_sdk::relay::{RelayNotification, RelayStatus}; diff --git a/crates/transport_nostr/src/host_time_browser.rs b/crates/transport_nostr/src/host_time_browser.rs @@ -1,6 +1,6 @@ //! Absolute deadlines with timer disposal confined to its local owner. -use core::{future::Future, pin::pin, time::Duration}; +use core::{future::IntoFuture, pin::pin, time::Duration}; use futures::{ channel::oneshot, future::{Either, select}, @@ -10,14 +10,14 @@ pub(crate) use web_time::Instant; #[derive(Debug)] pub(crate) struct Elapsed; -pub(crate) async fn timeout<F: Future>( +pub(crate) async fn timeout<F: IntoFuture>( duration: Duration, future: F, ) -> Result<F::Output, Elapsed> { timeout_at(Instant::now() + duration, future).await } -pub(crate) async fn timeout_at<F: Future>( +pub(crate) async fn timeout_at<F: IntoFuture>( deadline: Instant, future: F, ) -> Result<F::Output, Elapsed> { @@ -32,7 +32,7 @@ pub(crate) async fn timeout_at<F: Future>( let _ = elapsed.send(()); } }); - let result = match select(pin!(future), pin!(receiver)).await { + let result = match select(pin!(future.into_future()), pin!(receiver)).await { Either::Left((value, _)) => Ok(value), Either::Right(_) => Err(Elapsed), }; diff --git a/crates/transport_nostr/src/lib.rs b/crates/transport_nostr/src/lib.rs @@ -11,13 +11,16 @@ mod exact_delivery; mod host_time; mod profile; mod relay; +mod session_socket; mod sink; mod socket_write; mod source; mod source_ingress; -mod source_wire; + mod status; mod subscription; +#[cfg(test)] +mod test_host; pub use client::{Config, NostrTransport, ReconnectBackoff}; pub use cursor::RelayCursor; diff --git a/crates/transport_nostr/src/native_backend_tests.rs b/crates/transport_nostr/src/native_backend_tests.rs @@ -21,8 +21,11 @@ async fn queued_subscription_is_sent_once_after_a_real_socket_reconnect() { crate::RelayAccess::ReadOnly, ) .unwrap(); - let connector = - crate::relay::HardenedWebsocketTransport::new(&[endpoint], Duration::from_secs(1)); + let connector = crate::session_socket::SessionWebsocketTransport::new( + &[endpoint], + Duration::from_secs(1), + std::sync::Arc::new(crate::test_host::LoopbackConnector), + ); let client = Client::builder().websocket_transport(connector).build(); client.add_relay(&url).await.unwrap(); let (closed, closure) = tokio::sync::oneshot::channel(); @@ -109,8 +112,11 @@ async fn actual_native_receivers_report_local_repeated_gaps_and_continue() { crate::RelayAccess::ReadOnly, ) .unwrap(); - let connector = - crate::relay::HardenedWebsocketTransport::new(&[endpoint], Duration::from_secs(1)); + let connector = crate::session_socket::SessionWebsocketTransport::new( + &[endpoint], + Duration::from_secs(1), + std::sync::Arc::new(crate::test_host::LoopbackConnector), + ); let client = Client::builder() .websocket_transport(connector) .notification_channel_size(NonZeroUsize::new(2).unwrap()) diff --git a/crates/transport_nostr/src/relay.rs b/crates/transport_nostr/src/relay.rs @@ -1,27 +1,12 @@ //! Nostr relay identifiers and network policy. -use crate::{Error, RelayEndpoint}; -use async_wsocket::Message; -use async_wsocket::futures_util::stream::SplitSink; -use async_wsocket::futures_util::{Sink, SinkExt, StreamExt}; +use crate::Error; use core::fmt; -use core::pin::Pin; use nostr_sdk::error::Error as TransportError; -use nostr_sdk::transport::websocket::{WebSocketSink, WebSocketStream, WebSocketTransport}; -use radroots_transport::{BoxFuture, Target, TargetNetworkPolicy, TransportId}; -use std::collections::BTreeMap; -use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr}; -use std::sync::Arc; -use std::task::{Context, Poll}; -use std::time::Duration; -use tokio::net::TcpStream; -use tokio_tungstenite::tungstenite::Message as WireMessage; -use tokio_tungstenite::{MaybeTlsStream, WebSocketStream as TokioWebSocketStream}; +use radroots_transport::{Target, TargetNetworkPolicy, TransportId}; +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; use url::Url; -const MAX_RESOLVED_ADDRESSES: usize = 32; -pub(crate) const MAX_WIRE_MESSAGE_BYTES: usize = 512 * 1024; - /// Validated canonical Nostr relay URL. #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] pub struct RelayUrl(String); @@ -93,173 +78,6 @@ impl fmt::Display for RelayUrl { } } -/// WebSocket connector that validates and pins DNS results before opening a -/// socket while retaining the original host name for TLS verification. -#[derive(Clone, Debug)] -pub(crate) struct HardenedWebsocketTransport { - policies: Arc<BTreeMap<String, RelayUrlPolicy>>, - connect_timeout: Duration, - pub(crate) writers: crate::socket_write::WriterRegistry, - pub(crate) ingress: crate::source_ingress::IngressRegistry, -} - -impl HardenedWebsocketTransport { - pub(crate) fn new(endpoints: &[RelayEndpoint], connect_timeout: Duration) -> Self { - Self { - connect_timeout, - ingress: crate::source_ingress::IngressRegistry::new( - endpoints - .iter() - .map(|endpoint| endpoint.url().as_str().to_owned()), - ), - writers: crate::socket_write::WriterRegistry::new( - endpoints - .iter() - .map(|endpoint| endpoint.url().as_str().to_owned()), - ), - policies: Arc::new( - endpoints - .iter() - .map(|endpoint| (endpoint.url().as_str().to_owned(), endpoint.policy())) - .collect(), - ), - } - } -} - -impl WebSocketTransport for HardenedWebsocketTransport { - fn support_ping(&self) -> bool { - true - } - - // Direct DNS/socket/TLS behavior is verified by the network-hardening - // integration suite; deterministic coverage owns the surrounding policy. - #[cfg_attr(coverage_nightly, coverage(off))] - fn connect<'a>( - &'a self, - url: &'a Url, - proxy: Option<SocketAddr>, - ) -> BoxFuture<'a, Result<(WebSocketSink, WebSocketStream), TransportError>> { - Box::pin(async move { - if proxy.is_some() { - return Err(policy_error( - "proxy and Tor connection modes are not configured", - )); - } - let policy = self - .policies - .get(configured_policy_key(url)) - .copied() - .ok_or_else(|| policy_error("relay URL is not configured"))?; - let relay = RelayUrl::parse(url.as_str(), policy) - .map_err(|_| policy_error("relay URL is denied by network policy"))?; - let parsed = - Url::parse(relay.as_str()).map_err(|_| policy_error("relay URL is invalid"))?; - let host = parsed - .host_str() - .ok_or_else(|| policy_error("relay URL host is missing"))?; - let port = parsed - .port_or_known_default() - .ok_or_else(|| policy_error("relay URL port is missing"))?; - - let connect = async { - let ingress = self - .ingress - .connection(relay.as_str()) - .ok_or_else(|| policy_error("relay ingress unavailable"))?; - let addresses = resolve_bounded(host, port).await?; - relay - .validate_resolved_addresses(policy, addresses.iter().map(SocketAddr::ip)) - .map_err(|_| policy_error("relay DNS result is denied by network policy"))?; - let tcp = connect_pinned(addresses.as_slice()).await?; - let plaintext = if parsed.scheme() == "wss" { - let mut roots = rustls::RootCertStore::empty(); - roots.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned()); - let tls_config = rustls::ClientConfig::builder() - .with_root_certificates(roots) - .with_no_client_auth(); - let server_name = rustls::pki_types::ServerName::try_from( - host.trim_matches(['[', ']']).to_owned(), - ) - .map_err(|_| policy_error("relay TLS server name is invalid"))?; - let tls = tokio_rustls::TlsConnector::from(Arc::new(tls_config)) - .connect(server_name, tcp) - .await - .map_err(TransportError::transport)?; - MaybeTlsStream::Rustls(tls) - } else { - MaybeTlsStream::Plain(tcp) - }; - let metered = crate::source_wire::MeteredIo::new(plaintext, ingress); - let config = tokio_tungstenite::tungstenite::protocol::WebSocketConfig::default() - .max_message_size(Some(MAX_WIRE_MESSAGE_BYTES)) - .max_frame_size(Some(MAX_WIRE_MESSAGE_BYTES)); - let (stream, _) = tokio_tungstenite::client_async_with_config( - relay.as_str(), - metered, - Some(config), - ) - .await - .map_err(TransportError::transport)?; - let (tx, rx) = stream.split(); - let writer = - crate::socket_write::SocketWriter::new(Box::pin(HardenedTransportSink(tx))); - self.writers.install(relay.as_str(), &writer)?; - let sink: WebSocketSink = - Box::pin(crate::socket_write::SharedSocketSink::new(writer)); - let stream: WebSocketStream = Box::pin(rx.map(|result| { - result - .map_err(TransportError::transport) - .and_then(from_wire) - })); - Ok((sink, stream)) - }; - - tokio::time::timeout(self.connect_timeout, connect) - .await - .map_err(|_| policy_error("relay connection deadline elapsed"))? - }) - } -} - -fn configured_policy_key(url: &Url) -> &str { - if url.path() == "/" && url.query().is_none() && url.fragment().is_none() { - url.as_str().strip_suffix('/').unwrap_or(url.as_str()) - } else { - url.as_str() - } -} - -#[cfg_attr(coverage_nightly, coverage(off))] -async fn resolve_bounded(host: &str, port: u16) -> Result<Vec<SocketAddr>, TransportError> { - let mut addresses = tokio::net::lookup_host((host, port)) - .await - .map_err(|_| policy_error("relay DNS resolution failed"))?; - let mut bounded = Vec::new(); - for address in addresses.by_ref().take(MAX_RESOLVED_ADDRESSES + 1) { - bounded.push(address); - } - if bounded.is_empty() { - return Err(policy_error("relay DNS resolution returned no addresses")); - } - if bounded.len() > MAX_RESOLVED_ADDRESSES { - return Err(policy_error( - "relay DNS resolution exceeded its address limit", - )); - } - Ok(bounded) -} - -#[cfg_attr(coverage_nightly, coverage(off))] -async fn connect_pinned(addresses: &[SocketAddr]) -> Result<TcpStream, TransportError> { - for address in addresses { - if let Ok(stream) = TcpStream::connect(address).await { - return Ok(stream); - } - } - Err(policy_error("relay connection failed")) -} - #[derive(Debug)] struct NetworkPolicyError(&'static str); @@ -275,99 +93,6 @@ pub(crate) fn policy_error(message: &'static str) -> TransportError { TransportError::policy(NetworkPolicyError(message)) } -type MeteredSocket = TokioWebSocketStream<crate::source_wire::MeteredIo<MaybeTlsStream<TcpStream>>>; - -struct HardenedTransportSink(SplitSink<MeteredSocket, WireMessage>); - -fn from_wire(message: WireMessage) -> Result<Message, TransportError> { - Ok(match message { - WireMessage::Text(text) => { - validate_wire_identifiers(&text)?; - Message::Text(text.to_string()) - } - WireMessage::Binary(bytes) => Message::Binary(bytes.to_vec()), - WireMessage::Ping(bytes) => Message::Ping(bytes.to_vec()), - WireMessage::Pong(bytes) => Message::Pong(bytes.to_vec()), - WireMessage::Close(frame) => Message::Close(frame.map(Into::into)), - WireMessage::Frame(_) => return Err(policy_error("unexpected raw WebSocket frame")), - }) -} - -fn validate_wire_identifiers(text: &str) -> Result<(), TransportError> { - if text.len() > MAX_WIRE_MESSAGE_BYTES { - return Err(policy_error("relay message exceeds the wire limit")); - } - // Enforce original wire identities before the upstream fixed-array decoder - // can truncate hex to its expected prefix. Leave other decoding to the SDK. - let Ok(serde_json::Value::Array(fields)) = serde_json::from_str(text) else { - return Ok(()); - }; - let canonical_hex = |value: Option<&serde_json::Value>, length| { - value - .and_then(serde_json::Value::as_str) - .is_some_and(|value| { - value.len() == length - && value - .bytes() - .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f')) - }) - }; - let valid = match fields.first().and_then(serde_json::Value::as_str) { - Some("OK") => canonical_hex(fields.get(1), 64), - Some("EVENT") => fields.get(2).is_some_and(|event| { - canonical_hex(event.get("id"), 64) - && canonical_hex(event.get("pubkey"), 64) - && canonical_hex(event.get("sig"), 128) - }), - _ => true, - }; - if !valid { - return Err(policy_error("relay message has a noncanonical identifier")); - } - Ok(()) -} - -impl Sink<Message> for HardenedTransportSink { - type Error = TransportError; - - #[cfg_attr(coverage_nightly, coverage(off))] - fn poll_ready( - mut self: Pin<&mut Self>, - context: &mut Context<'_>, - ) -> Poll<Result<(), Self::Error>> { - Pin::new(&mut self.0) - .poll_ready_unpin(context) - .map_err(TransportError::transport) - } - - #[cfg_attr(coverage_nightly, coverage(off))] - fn start_send(mut self: Pin<&mut Self>, item: Message) -> Result<(), Self::Error> { - Pin::new(&mut self.0) - .start_send_unpin(item.into()) - .map_err(TransportError::transport) - } - - #[cfg_attr(coverage_nightly, coverage(off))] - fn poll_flush( - mut self: Pin<&mut Self>, - context: &mut Context<'_>, - ) -> Poll<Result<(), Self::Error>> { - Pin::new(&mut self.0) - .poll_flush_unpin(context) - .map_err(TransportError::transport) - } - - #[cfg_attr(coverage_nightly, coverage(off))] - fn poll_close( - mut self: Pin<&mut Self>, - context: &mut Context<'_>, - ) -> Poll<Result<(), Self::Error>> { - Pin::new(&mut self.0) - .poll_close_unpin(context) - .map_err(TransportError::transport) - } -} - /// Destination class authorized for relay connections. #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] #[non_exhaustive] @@ -381,7 +106,7 @@ pub enum RelayUrlPolicy { } impl RelayUrlPolicy { - fn accepts_address(self, address: IpAddr) -> bool { + pub(crate) fn accepts_address(self, address: IpAddr) -> bool { match self { Self::Public => public_address(address), Self::Local => address.is_loopback(), @@ -475,117 +200,6 @@ mod tests { use super::*; #[test] - fn original_wire_identifiers_are_exact_canonical_and_never_rewritten() { - use serde_json::json; - let event = json!({"id": "ab".repeat(32), "pubkey": "cd".repeat(32), - "sig": "ef".repeat(64), "extension": true}); - let text = format!(" \n{} \t", json!(["EVENT", "bounded", event])); - assert_eq!( - from_wire(WireMessage::Text(text.clone().into())).unwrap(), - Message::Text(text) - ); - for field in ["id", "pubkey", "sig"] { - let original = event[field].as_str().unwrap(); - for invalid in [ - json!(format!("{original}00")), - json!(&original[2..]), - json!(original.to_ascii_uppercase()), - json!(format!("g{}", &original[1..])), - json!(null), - json!(32), - ] { - let mut malformed = event.clone(); - malformed[field] = invalid; - let text = json!(["EVENT", "bounded", malformed]).to_string(); - assert!( - from_wire(WireMessage::Text(text.into())).is_err(), - "{field}" - ); - } - } - for id in [json!("aa".repeat(33)), json!("AA".repeat(32)), json!(null)] { - let text = json!(["OK", id, true, ""]).to_string(); - assert!(from_wire(WireMessage::Text(text.into())).is_err()); - } - for control in [ - json!(["OK", "aa".repeat(32), true, ""]), - json!(["AUTH", "arbitrary challenge"]), - json!(["EOSE", "arbitrary subscription"]), - json!(["NOTICE", "arbitrary notice"]), - ] { - let text = control.to_string(); - assert_eq!( - from_wire(WireMessage::Text(text.clone().into())).unwrap(), - Message::Text(text) - ); - } - assert!(validate_wire_identifiers(&" ".repeat(MAX_WIRE_MESSAGE_BYTES + 1)).is_err()); - } - - #[test] - fn metered_socket_conversion_preserves_data_control_and_close_messages() { - for message in [ - WireMessage::Text("text".into()), - WireMessage::Binary(vec![0, 255].into()), - WireMessage::Ping(vec![1, 2].into()), - WireMessage::Pong(vec![3].into()), - WireMessage::Close(None), - WireMessage::Close(Some(tokio_tungstenite::tungstenite::protocol::CloseFrame { - code: tokio_tungstenite::tungstenite::protocol::frame::coding::CloseCode::Normal, - reason: "finished".into(), - })), - ] { - let restored: WireMessage = from_wire(message.clone()).expect("conversion").into(); - assert_eq!(restored, message); - } - } - - #[tokio::test] - async fn secure_relay_requires_tls_before_any_http_upgrade() { - use tokio::io::{AsyncReadExt, AsyncWriteExt}; - let listener = tokio::net::TcpListener::bind("127.0.0.1:0") - .await - .expect("listener"); - let endpoint = format!("wss://{}", listener.local_addr().expect("address")); - let server = tokio::spawn(async move { - let (mut socket, _) = listener.accept().await.expect("accept"); - let mut prefix = [0; 5]; - socket - .read_exact(&mut prefix) - .await - .expect("TLS record prefix"); - socket - .write_all(b"HTTP/1.1 101 Switching Protocols\r\n\r\n") - .await - .expect("plaintext response"); - prefix - }); - let profile = crate::profile::test_profile( - crate::RelayProfileKind::Simulator, - RelayUrlPolicy::Local, - [endpoint.as_str()], - ) - .expect("local TLS profile"); - let transport = - HardenedWebsocketTransport::new(profile.endpoints(), Duration::from_secs(5)); - let url = Url::parse(&endpoint).expect("URL"); - let result = transport.connect(&url, None).await; - assert!( - result.is_err(), - "plaintext peer must not complete a secure relay connection" - ); - let prefix = tokio::time::timeout(Duration::from_secs(5), server) - .await - .expect("server deadline") - .expect("server task"); - assert_eq!( - prefix[0], 0x16, - "client must send a TLS handshake, never an HTTP request" - ); - assert_eq!(prefix[1], 0x03, "TLS record version family"); - } - - #[test] fn policies_classify_literal_and_named_destinations() { assert!(RelayUrl::parse("wss://relay.example.com", RelayUrlPolicy::Public).is_ok()); assert!(RelayUrl::parse("wss://10.0.0.1", RelayUrlPolicy::Public).is_err()); @@ -616,75 +230,7 @@ mod tests { RelayUrl::from_target(&local, RelayUrlPolicy::Public), Err(Error::UnexpectedTransport) )); - let profile = crate::profile::test_profile( - crate::RelayProfileKind::Public, - RelayUrlPolicy::Public, - ["wss://relay.example.com"], - ) - .expect("profile"); - assert!( - HardenedWebsocketTransport::new(profile.endpoints(), Duration::from_secs(5)) - .support_ping() - ); assert!(!policy_error("denied").to_string().is_empty()); - - let root = Url::parse("wss://relay.example/").expect("root URL"); - let path = Url::parse("wss://relay.example/path/").expect("path URL"); - let query = Url::parse("wss://relay.example/?scope=write").expect("query URL"); - let fragment = Url::parse("wss://relay.example/#status").expect("fragment URL"); - assert_eq!(configured_policy_key(&root), "wss://relay.example"); - assert_eq!(configured_policy_key(&path), "wss://relay.example/path/"); - assert_eq!( - configured_policy_key(&query), - "wss://relay.example/?scope=write" - ); - assert_eq!( - configured_policy_key(&fragment), - "wss://relay.example/#status" - ); - } - - #[tokio::test] - async fn proxy_refusal_precedes_socket_effects() { - let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); - let address = listener.local_addr().unwrap(); - let url = format!("ws://{address}"); - let endpoint = - crate::RelayEndpoint::new(&url, RelayUrlPolicy::Local, crate::RelayAccess::ReadOnly) - .unwrap(); - let transport = HardenedWebsocketTransport::new(&[endpoint], Duration::from_secs(1)); - let url = Url::parse(&url).unwrap(); - assert!(transport.connect(&url, Some(address)).await.is_err()); - assert!( - tokio::time::timeout(Duration::from_millis(20), listener.accept()) - .await - .is_err() - ); - } - - #[tokio::test] - async fn configured_connector_timeout_bounds_an_unfinished_websocket_handshake() { - let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); - let url = format!("ws://{}", listener.local_addr().unwrap()); - let endpoint = - crate::RelayEndpoint::new(&url, RelayUrlPolicy::Local, crate::RelayAccess::ReadOnly) - .unwrap(); - let transport = HardenedWebsocketTransport::new(&[endpoint], Duration::from_millis(50)); - let (accepted, observed) = tokio::sync::oneshot::channel(); - let (release, wait) = tokio::sync::oneshot::channel::<()>(); - let peer = tokio::spawn(async move { - let (_socket, _) = listener.accept().await.unwrap(); - accepted.send(()).unwrap(); - wait.await.unwrap(); - }); - let url = Url::parse(&url).unwrap(); - let result = tokio::time::timeout(Duration::from_secs(2), transport.connect(&url, None)) - .await - .expect("the configured connector deadline must expire"); - assert!(result.is_err()); - observed.await.unwrap(); - release.send(()).unwrap(); - peer.await.unwrap(); } #[test] @@ -824,4 +370,32 @@ mod tests { ); } } + + #[test] + fn address_policy_keeps_special_use_range_edges_and_adjacent_global_addresses_distinct() { + for (address, accepted) in [ + ("100.63.255.255", true), + ("100.64.0.0", false), + ("100.127.255.255", false), + ("100.128.0.0", true), + ("192.0.0.0", false), + ("192.0.0.255", false), + ("192.0.1.0", true), + ("192.88.98.255", true), + ("192.88.99.0", false), + ("192.88.99.255", false), + ("192.88.100.0", true), + ("2001:1ff::1", false), + ("2001:200::1", true), + ("2001:db8::1", false), + ("2001:db9::1", true), + ] { + assert_eq!( + RelayUrlPolicy::Public.accepts_address(address.parse().unwrap()), + accepted, + "{address}" + ); + } + assert!(validate_scheme("ftp://relay.example", "ftp", RelayUrlPolicy::Public).is_err()); + } } diff --git a/crates/transport_nostr/src/session_socket.rs b/crates/transport_nostr/src/session_socket.rs @@ -0,0 +1,317 @@ +//! One upstream protocol session over caller-selected byte I/O. + +use crate::{RelayEndpoint, RelayUrl, RelayUrlPolicy, relay::policy_error}; +use async_wsocket::Message; +use futures::{Sink, future::BoxFuture, stream}; +use nostr_sdk::{ + error::Error as TransportError, + transport::websocket::{WebSocketSink, WebSocketStream, WebSocketTransport}, +}; +use radroots_transport::host::websocket::{ + Admission, Connector, Error as HostError, Frame, Socket, +}; +use std::{ + collections::BTreeMap, + fmt, + net::{IpAddr, SocketAddr}, + num::NonZeroUsize, + pin::Pin, + sync::Arc, + task::{Context, Poll}, + time::Duration, +}; +use url::Url; + +pub(crate) const MAX_WIRE_MESSAGE_BYTES: usize = 512 * 1024; + +#[derive(Clone, Debug)] +pub(crate) struct SessionWebsocketTransport { + host: Arc<dyn Connector>, + policies: Arc<BTreeMap<String, RelayUrlPolicy>>, + connect_timeout: Duration, + pub(crate) writers: crate::socket_write::WriterRegistry, + pub(crate) ingress: crate::source_ingress::IngressRegistry, +} + +impl SessionWebsocketTransport { + pub(crate) fn new( + endpoints: &[RelayEndpoint], + connect_timeout: Duration, + host: Arc<dyn Connector>, + ) -> Self { + Self { + host, + connect_timeout, + ingress: crate::source_ingress::IngressRegistry::new( + endpoints + .iter() + .map(|endpoint| endpoint.url().as_str().to_owned()), + ), + writers: crate::socket_write::WriterRegistry::new( + endpoints + .iter() + .map(|endpoint| endpoint.url().as_str().to_owned()), + ), + policies: Arc::new( + endpoints + .iter() + .map(|endpoint| (endpoint.url().as_str().to_owned(), endpoint.policy())) + .collect(), + ), + } + } +} + +impl WebSocketTransport for SessionWebsocketTransport { + fn support_ping(&self) -> bool { + self.host.supports_ping() + } + + fn connect<'a>( + &'a self, + url: &'a Url, + proxy: Option<SocketAddr>, + ) -> BoxFuture<'a, Result<(WebSocketSink, WebSocketStream), TransportError>> { + Box::pin(async move { + if proxy.is_some() { + return Err(policy_error( + "proxy and Tor connection modes are not configured", + )); + } + let policy = self + .policies + .get(configured_policy_key(url)) + .copied() + .ok_or_else(|| policy_error("relay URL is not configured"))?; + let relay = RelayUrl::parse(url.as_str(), policy) + .map_err(|_| policy_error("relay URL is denied by network policy"))?; + let ingress = self + .ingress + .connection(relay.as_str()) + .ok_or_else(|| policy_error("relay ingress unavailable"))?; + let admission = Arc::new(ConnectionAdmission { policy, ingress }); + let limit = NonZeroUsize::new(MAX_WIRE_MESSAGE_BYTES) + .expect("the fixed wire limit is positive"); + let socket = crate::host_time::timeout( + self.connect_timeout, + self.host + .connect(relay.as_str(), self.connect_timeout, limit, admission), + ) + .await + .map_err(|_| policy_error("relay connection deadline elapsed"))? + .map_err(host_error)?; + let writer = + crate::socket_write::SocketWriter::new(Box::pin(HostSink::new(socket.clone()))); + self.writers.install(relay.as_str(), &writer)?; + let sink: WebSocketSink = Box::pin(crate::socket_write::SharedSocketSink::new(writer)); + let receiver = stream::try_unfold(socket, |socket| async move { + let frame = socket.receive().await.map_err(host_error)?; + let message = frame.map(from_host_frame).transpose()?.flatten(); + Ok(message.map(|message| (message, socket))) + }); + Ok((sink, Box::pin(receiver) as WebSocketStream)) + }) + } +} + +struct ConnectionAdmission { + policy: RelayUrlPolicy, + ingress: crate::source_ingress::IngressConnection, +} + +impl Admission for ConnectionAdmission { + fn permits_address(&self, address: IpAddr) -> bool { + self.policy.accepts_address(address) + } + fn admitted_read(&self, context: &Context<'_>) -> bool { + self.ingress.admitted(context) + } + fn admitted_write(&self, context: &Context<'_>) -> bool { + self.ingress.admitted_write(context) + } + fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool { + self.ingress.charge(bytes, frames, data) + } +} + +fn configured_policy_key(url: &Url) -> &str { + if url.path() == "/" && url.query().is_none() && url.fragment().is_none() { + url.as_str().strip_suffix('/').unwrap_or(url.as_str()) + } else { + url.as_str() + } +} + +fn host_error(error: HostError) -> TransportError { + match error { + HostError::Policy => policy_error("relay socket policy rejected"), + HostError::Timeout => TransportError::with_static_message( + nostr_sdk::error::ErrorKind::Timeout, + "relay connection timed out", + ), + other => TransportError::transport(other), + } +} + +fn from_host_frame(frame: Frame) -> Result<Option<Message>, TransportError> { + Ok(Some(match frame { + Frame::Text(text) => { + validate_wire_identifiers(&text)?; + Message::Text(text) + } + Frame::Binary(bytes) => { + if bytes.len() > MAX_WIRE_MESSAGE_BYTES { + return Err(policy_error("relay message exceeds the wire limit")); + } + // Preserve the original host bytes. The upstream Nostr session + // explicitly ignores binary messages; never promote them to text. + Message::Binary(bytes) + } + #[cfg(not(target_arch = "wasm32"))] + Frame::Ping(bytes) => Message::Ping(bytes), + #[cfg(not(target_arch = "wasm32"))] + Frame::Pong(bytes) => Message::Pong(bytes), + #[cfg(not(target_arch = "wasm32"))] + Frame::Close(frame) => { + Message::Close(frame.map(|frame| async_wsocket::message::CloseFrame { + code: frame.code, + reason: frame.reason, + })) + } + #[cfg(target_arch = "wasm32")] + Frame::Close(_) => return Ok(None), + _ => return Err(policy_error("unsupported host frame")), + })) +} + +fn validate_wire_identifiers(text: &str) -> Result<(), TransportError> { + if text.len() > MAX_WIRE_MESSAGE_BYTES { + return Err(policy_error("relay message exceeds the wire limit")); + } + // Inspect original identifiers before the upstream fixed-array decoder. + // Never normalize or reserialize the accepted original message. + let Ok(serde_json::Value::Array(fields)) = serde_json::from_str(text) else { + return Ok(()); + }; + let canonical_hex = |value: Option<&serde_json::Value>, length| { + value + .and_then(serde_json::Value::as_str) + .is_some_and(|value| { + value.len() == length + && value + .bytes() + .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f')) + }) + }; + let valid = match fields.first().and_then(serde_json::Value::as_str) { + Some("OK") => canonical_hex(fields.get(1), 64), + Some("EVENT") => fields.get(2).is_some_and(|event| { + canonical_hex(event.get("id"), 64) + && canonical_hex(event.get("pubkey"), 64) + && canonical_hex(event.get("sig"), 128) + }), + _ => true, + }; + if !valid { + return Err(policy_error("relay message has a noncanonical identifier")); + } + Ok(()) +} + +fn to_host_frame(message: Message) -> Frame { + match message { + Message::Text(text) => Frame::Text(text), + Message::Binary(bytes) => Frame::Binary(bytes), + #[cfg(not(target_arch = "wasm32"))] + Message::Ping(bytes) => Frame::Ping(bytes), + #[cfg(not(target_arch = "wasm32"))] + Message::Pong(bytes) => Frame::Pong(bytes), + #[cfg(not(target_arch = "wasm32"))] + Message::Close(frame) => { + Frame::Close( + frame.map(|frame| radroots_transport::host::websocket::CloseFrame { + code: frame.code, + reason: frame.reason, + }), + ) + } + } +} + +struct HostSink { + socket: Arc<dyn Socket>, + pending: Option<BoxFuture<'static, Result<(), TransportError>>>, + closing: bool, +} + +impl HostSink { + fn new(socket: Arc<dyn Socket>) -> Self { + Self { + socket, + pending: None, + closing: false, + } + } + fn poll_pending(&mut self, context: &mut Context<'_>) -> Poll<Result<(), TransportError>> { + if let Some(pending) = &mut self.pending { + let result = futures::ready!(pending.as_mut().poll(context)); + self.pending = None; + return Poll::Ready(result); + } + Poll::Ready(Ok(())) + } +} + +impl Sink<Message> for HostSink { + type Error = TransportError; + fn poll_ready( + mut self: Pin<&mut Self>, + context: &mut Context<'_>, + ) -> Poll<Result<(), TransportError>> { + if self.closing { + return Poll::Ready(Err(policy_error("host socket is closing"))); + } + self.poll_pending(context) + } + fn start_send(mut self: Pin<&mut Self>, message: Message) -> Result<(), TransportError> { + if self.closing || self.pending.is_some() { + return Err(policy_error("host socket is not ready")); + } + let socket = self.socket.clone(); + let frame = to_host_frame(message); + self.pending = Some(Box::pin(async move { + socket.send(frame).await.map_err(host_error) + })); + Ok(()) + } + fn poll_flush( + mut self: Pin<&mut Self>, + context: &mut Context<'_>, + ) -> Poll<Result<(), TransportError>> { + self.poll_pending(context) + } + fn poll_close( + mut self: Pin<&mut Self>, + context: &mut Context<'_>, + ) -> Poll<Result<(), TransportError>> { + futures::ready!(self.poll_pending(context))?; + if !self.closing { + self.closing = true; + let socket = self.socket.clone(); + self.pending = Some(Box::pin( + async move { socket.close().await.map_err(host_error) }, + )); + } + self.poll_pending(context) + } +} + +impl fmt::Debug for ConnectionAdmission { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("ConnectionAdmission([redacted])") + } +} + +#[cfg(test)] +#[path = "session_socket_tests.rs"] +mod tests; diff --git a/crates/transport_nostr/src/session_socket_tests.rs b/crates/transport_nostr/src/session_socket_tests.rs @@ -0,0 +1,326 @@ +use super::*; +use futures::{SinkExt, StreamExt}; +use radroots_transport::host::websocket::{CloseFrame, Error, IoFuture}; +use std::sync::{ + Mutex, + atomic::{AtomicUsize, Ordering}, +}; + +#[test] +fn host_policy_and_timeout_keep_their_sdk_class_without_misclassifying_authority_as_auth() { + let policy = host_error(Error::Policy); + assert_eq!(policy.kind(), nostr_sdk::error::ErrorKind::Policy); + assert_eq!( + crate::status::delivery_failure(&policy.to_string()), + crate::status::delivery_failure("rejected") + ); + let timeout = host_error(Error::Timeout); + assert_eq!(timeout.kind(), nostr_sdk::error::ErrorKind::Timeout); + assert_eq!( + crate::status::delivery_failure(&timeout.to_string()), + crate::status::delivery_failure("timeout") + ); + for error in [ + Error::Unavailable, + Error::Closed, + Error::Protocol, + Error::Unsupported, + ] { + let mapped = host_error(error); + assert_eq!(mapped.kind(), nostr_sdk::error::ErrorKind::Transport); + assert!(mapped.to_string().len() < 128); + } +} + +#[test] +fn original_text_identifiers_are_exact_and_binary_is_never_promoted_or_reencoded() { + use serde_json::json; + let event = json!({"id": "ab".repeat(32), "pubkey": "cd".repeat(32), + "sig": "ef".repeat(64), "extension": true}); + let check = |text: String, valid| { + for frame in [ + Frame::Text(text.clone()), + Frame::Binary(text.clone().into_bytes()), + ] { + let result = from_host_frame(frame.clone()); + let accepted = valid || matches!(frame, Frame::Binary(_)); + assert_eq!(result.is_ok(), accepted); + if accepted { + assert_eq!(to_host_frame(result.unwrap().unwrap()), frame); + } + } + }; + check( + format!(" \n{} \t", json!(["EVENT", "bounded", event])), + true, + ); + for field in ["id", "pubkey", "sig"] { + let original = event[field].as_str().unwrap(); + for invalid in [ + json!(format!("{original}00")), + json!(&original[2..]), + json!(original.to_ascii_uppercase()), + json!(format!("g{}", &original[1..])), + json!(null), + json!(32), + ] { + let mut malformed = event.clone(); + malformed[field] = invalid; + check(json!(["EVENT", "bounded", malformed]).to_string(), false); + } + } + for id in [json!("aa".repeat(33)), json!("AA".repeat(32)), json!(null)] { + check(json!(["OK", id, true, ""]).to_string(), false); + } + for text in [ + "not-json".to_owned(), + "[]".to_owned(), + "[\"EVENT\"]".to_owned(), + "[\"NOTICE\",\"retained\"]".to_owned(), + json!(["OK", "aa".repeat(32), true, ""]).to_string(), + ] { + let valid = text != "[\"EVENT\"]"; + check(text, valid); + } + for frame in [ + Frame::Text("x".repeat(MAX_WIRE_MESSAGE_BYTES + 1)), + Frame::Binary(vec![0; MAX_WIRE_MESSAGE_BYTES + 1]), + ] { + assert!(from_host_frame(frame).is_err()); + } + let non_utf8 = Frame::Binary(vec![0xff, 0]); + assert_eq!( + to_host_frame(from_host_frame(non_utf8.clone()).unwrap().unwrap()), + non_utf8 + ); +} + +#[test] +fn owned_data_control_and_close_information_round_trip_at_the_shared_sdk_boundary() { + for frame in [ + Frame::Text("text".into()), + Frame::Binary(vec![0, 255]), + Frame::Ping(vec![1, 2]), + Frame::Pong(vec![3]), + Frame::Close(None), + Frame::Close(Some(CloseFrame { + code: 1000, + reason: "finished".into(), + })), + ] { + assert_eq!( + to_host_frame(from_host_frame(frame.clone()).unwrap().unwrap()), + frame + ); + } +} + +#[derive(Default)] +struct FakeSocket { + sent: Mutex<Vec<Frame>>, + received: Mutex<std::collections::VecDeque<Result<Option<Frame>, Error>>>, + closes: AtomicUsize, +} +impl Socket for FakeSocket { + fn send(&self, frame: Frame) -> IoFuture<'_, Result<(), Error>> { + Box::pin(async move { + self.sent.lock().unwrap().push(frame); + Ok(()) + }) + } + fn receive(&self) -> IoFuture<'_, Result<Option<Frame>, Error>> { + Box::pin(async move { + self.received + .lock() + .unwrap() + .pop_front() + .unwrap_or(Ok(None)) + }) + } + fn close(&self) -> IoFuture<'_, Result<(), Error>> { + Box::pin(async move { + self.closes.fetch_add(1, Ordering::SeqCst); + Ok(()) + }) + } +} + +#[derive(Debug, Default)] +struct Calls(AtomicUsize); +#[derive(Default)] +struct Host { + calls: Arc<Calls>, + socket: Arc<FakeSocket>, +} +impl fmt::Debug for Host { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("Host") + } +} +impl Connector for Host { + fn supports_ping(&self) -> bool { + false + } + fn connect<'a>( + &'a self, + _: &'a str, + _: Duration, + _: NonZeroUsize, + _: Arc<dyn Admission>, + ) -> IoFuture<'a, Result<Arc<dyn Socket>, Error>> { + Box::pin(async move { + self.calls.0.fetch_add(1, Ordering::SeqCst); + Ok(self.socket.clone() as Arc<dyn Socket>) + }) + } +} + +#[tokio::test] +async fn exact_writer_and_sdk_messages_use_one_host_socket_and_close_it_once() { + let host = Arc::new(Host::default()); + host.socket.received.lock().unwrap().extend([ + Ok(Some(Frame::Text("[\"NOTICE\",\"first\"]".into()))), + Err(Error::Closed), + ]); + let endpoint = crate::RelayEndpoint::new( + "ws://127.0.0.1:1234", + RelayUrlPolicy::Local, + crate::RelayAccess::ReadWrite, + ) + .unwrap(); + let bridge = SessionWebsocketTransport::new(&[endpoint], Duration::from_secs(1), host.clone()); + assert!(!bridge.support_ping()); + let url = Url::parse("ws://127.0.0.1:1234").unwrap(); + let pending = bridge.connect(&url, None); + drop(pending); + assert_eq!(host.calls.0.load(Ordering::SeqCst), 0); + let (mut sink, mut receiver) = bridge.connect(&url, None).await.unwrap(); + let writer = bridge.writers.get("ws://127.0.0.1:1234").unwrap(); + let original = " \n[\"EVENT\", { \"z\":1, \"a\":2 }] \t"; + writer.send(Message::Text(original.into())).await.unwrap(); + sink.send(Message::Text("[\"REQ\",\"read\",{}]".into())) + .await + .unwrap(); + assert_eq!( + *host.socket.sent.lock().unwrap(), + vec![ + Frame::Text(original.into()), + Frame::Text("[\"REQ\",\"read\",{}]".into()) + ] + ); + assert_eq!( + receiver.next().await.unwrap().unwrap(), + Message::Text("[\"NOTICE\",\"first\"]".into()) + ); + assert!(receiver.next().await.unwrap().is_err()); + assert!(receiver.next().await.is_none()); + sink.close().await.unwrap(); + sink.close().await.unwrap(); + assert_eq!(host.socket.closes.load(Ordering::SeqCst), 1); + assert!(writer.send(Message::Text("denied".into())).await.is_err()); + assert_eq!(host.calls.0.load(Ordering::SeqCst), 1); +} + +#[test] +fn host_sink_enforces_pending_ready_and_closed_states_without_discarding_close() { + let socket = Arc::new(FakeSocket::default()); + let mut sink = HostSink::new(socket.clone()); + let mut context = Context::from_waker(futures::task::noop_waker_ref()); + Pin::new(&mut sink) + .start_send(Message::Text("first".into())) + .unwrap(); + assert!( + Pin::new(&mut sink) + .start_send(Message::Text("second".into())) + .is_err() + ); + assert!(matches!( + Pin::new(&mut sink).poll_ready(&mut context), + Poll::Ready(Ok(())) + )); + assert!(matches!( + Pin::new(&mut sink).poll_close(&mut context), + Poll::Ready(Ok(())) + )); + assert!(matches!( + Pin::new(&mut sink).poll_ready(&mut context), + Poll::Ready(Err(_)) + )); + assert!( + Pin::new(&mut sink) + .start_send(Message::Text("denied".into())) + .is_err() + ); + assert!(matches!( + Pin::new(&mut sink).poll_close(&mut context), + Poll::Ready(Ok(())) + )); + assert_eq!(socket.closes.load(Ordering::SeqCst), 1); + assert_eq!( + *socket.sent.lock().unwrap(), + vec![Frame::Text("first".into())] + ); +} + +#[tokio::test] +async fn proxy_or_unconfigured_endpoint_never_calls_the_host() { + let host = Arc::new(Host::default()); + let endpoint = crate::RelayEndpoint::new( + "ws://127.0.0.1:1234", + RelayUrlPolicy::Local, + crate::RelayAccess::ReadOnly, + ) + .unwrap(); + let bridge = SessionWebsocketTransport::new(&[endpoint], Duration::from_secs(1), host.clone()); + let url = Url::parse("ws://127.0.0.1:1234").unwrap(); + assert!( + bridge + .connect(&url, Some("127.0.0.1:9000".parse().unwrap())) + .await + .is_err() + ); + assert!( + bridge + .connect(&Url::parse("ws://127.0.0.1:1235").unwrap(), None) + .await + .is_err() + ); + assert_eq!(host.calls.0.load(Ordering::SeqCst), 0); + for (url, expected) in [ + ("wss://relay.example/", "wss://relay.example"), + ("wss://relay.example/path/", "wss://relay.example/path/"), + ( + "wss://relay.example/?scope=write", + "wss://relay.example/?scope=write", + ), + ("wss://relay.example/#status", "wss://relay.example/#status"), + ] { + assert_eq!(configured_policy_key(&Url::parse(url).unwrap()), expected); + } +} + +#[test] +fn connection_admission_preserves_policy_original_budget_and_generation() { + let key = "ws://127.0.0.1:1234"; + let registry = crate::source_ingress::IngressRegistry::new([key.to_owned()].into_iter()); + let budget = Arc::new(crate::source::budget::FetchBudget::default()); + let registration = registry + .register([key.to_owned()].into_iter(), budget.clone()) + .unwrap(); + let admission = ConnectionAdmission { + policy: RelayUrlPolicy::Local, + ingress: registry.connection(key).unwrap(), + }; + assert!(admission.permits_address("127.0.0.1".parse().unwrap())); + assert!(!admission.permits_address("8.8.8.8".parse().unwrap())); + let context = Context::from_waker(futures::task::noop_waker_ref()); + assert!(admission.admitted_read(&context) && admission.admitted_write(&context)); + assert!(admission.charge(crate::source::budget::MAX_FETCH_BYTES, 0, 0)); + assert!(!admission.charge(1, 0, 0)); + assert!(budget.exhausted()); + assert!(!admission.admitted_read(&context)); + drop(registration); + assert!(!admission.admitted_write(&context)); + assert!(!admission.charge(0, 0, 0)); + assert_eq!(format!("{admission:?}"), "ConnectionAdmission([redacted])"); +} diff --git a/crates/transport_nostr/src/socket_write.rs b/crates/transport_nostr/src/socket_write.rs @@ -6,9 +6,9 @@ use core::{ pin::Pin, task::{Context, Poll}, }; +use futures::future::BoxFuture; use futures::{Sink, SinkExt, lock::Mutex}; use nostr_sdk::{error::Error as TransportError, transport::websocket::WebSocketSink}; -use radroots_transport::BoxFuture; use std::{ collections::BTreeMap, sync::{ diff --git a/crates/transport_nostr/src/source.rs b/crates/transport_nostr/src/source.rs @@ -1436,8 +1436,11 @@ mod tests { .unwrap() }) .collect::<Vec<_>>(); - let connector = - crate::relay::HardenedWebsocketTransport::new(&endpoints, Duration::from_secs(1)); + let connector = crate::session_socket::SessionWebsocketTransport::new( + &endpoints, + Duration::from_secs(1), + std::sync::Arc::new(crate::test_host::LoopbackConnector), + ); let ingress = connector.ingress.clone(); let client = nostr_sdk::client::Client::builder() .websocket_transport(connector) diff --git a/crates/transport_nostr/src/source_budget.rs b/crates/transport_nostr/src/source_budget.rs @@ -166,4 +166,19 @@ mod tests { assert!(futures::poll!(&mut first).is_ready()); assert!(futures::poll!(&mut second).is_ready()); } + + #[test] + fn poisoned_budget_refuses_every_inventory_entry_without_resetting_authority() { + let budget = FetchBudget::default(); + assert!(budget.wire(1, 1, 1)); + let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _guard = budget.0.lock().unwrap(); + panic!("injected budget lock failure"); + })); + assert!(budget.exhausted()); + assert!(!budget.wire(0, 0, 0)); + assert!(!budget.notification()); + assert!(!budget.event(0)); + futures::executor::block_on(budget.wait_exhausted()); + } } diff --git a/crates/transport_nostr/src/source_ingress.rs b/crates/transport_nostr/src/source_ingress.rs @@ -436,4 +436,36 @@ mod tests { })); assert!(!poisoned.finish()); } + + #[test] + fn missing_or_poisoned_connection_state_refuses_both_io_directions_and_charging() { + let registry = registry(); + let missing = IngressConnection { + registry: registry.clone(), + relay: "missing".into(), + generation: 1, + }; + let context = Context::from_waker(futures::task::noop_waker_ref()); + assert!(!missing.admitted(&context)); + assert!(!missing.admitted_write(&context)); + assert!(!missing.charge(0, 0, 0)); + let current = registry.connection("one").unwrap(); + assert!(current.admitted(&context)); + let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _guard = registry.0.lock().unwrap(); + panic!("injected connection registry failure"); + })); + assert!(!current.admitted(&context)); + assert!(!current.admitted_write(&context)); + assert!(!current.charge(1, 1, 1)); + assert!(registry.connection("one").is_none()); + assert!( + registry + .register( + ["one".to_owned()].into_iter(), + Arc::new(FetchBudget::default()) + ) + .is_none() + ); + } } diff --git a/crates/transport_nostr/src/source_wire.rs b/crates/transport_nostr/src/source_wire.rs @@ -1,231 +0,0 @@ -//! Fixed-memory admission of decrypted ingress before WebSocket decoding. - -use crate::source_ingress::IngressConnection; -use std::io; -use std::pin::Pin; -use std::task::{Context, Poll}; -use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; - -const MAX_UPGRADE_BYTES: usize = 16 * 1024; -const READ_CHUNK_BYTES: usize = 4096; - -/// Counts HTTP response and frame overhead conservatively in the same raw-byte -/// allowance as payloads. No message or payload is retained by this layer. -pub(crate) struct MeteredIo<S> { - inner: S, - ingress: IngressConnection, - parser: WireParser, - failed: bool, -} - -impl<S> MeteredIo<S> { - pub(crate) fn new(inner: S, ingress: IngressConnection) -> Self { - Self { - inner, - ingress, - parser: WireParser::default(), - failed: false, - } - } - - fn admitted(&self, context: &Context<'_>) -> io::Result<()> { - if self.failed || !self.ingress.admitted(context) { - Err(denied()) - } else { - Ok(()) - } - } -} - -impl<S: AsyncRead + Unpin> AsyncRead for MeteredIo<S> { - fn poll_read( - self: Pin<&mut Self>, - context: &mut Context<'_>, - output: &mut ReadBuf<'_>, - ) -> Poll<io::Result<()>> { - let this = self.get_mut(); - if let Err(error) = this.admitted(context) { - return Poll::Ready(Err(error)); - } - if output.remaining() == 0 { - return Poll::Ready(Ok(())); - } - let mut scratch = [0; READ_CHUNK_BYTES]; - let length = output.remaining().min(scratch.len()); - let mut input = ReadBuf::new(&mut scratch[..length]); - match Pin::new(&mut this.inner).poll_read(context, &mut input) { - Poll::Pending => Poll::Pending, - Poll::Ready(Err(error)) => { - this.failed = true; - Poll::Ready(Err(error)) - } - Poll::Ready(Ok(())) => { - let bytes = input.filled(); - let result = if !this.ingress.charge(bytes.len(), 0, 0) { - Err(denied()) - } else if bytes.is_empty() { - this.parser.eof() - } else { - this.parser - .consume(bytes, |data| this.ingress.charge(0, 1, usize::from(data))) - }; - if let Err(error) = result { - this.failed = true; - return Poll::Ready(Err(error)); - } - // Cancellation may race a ready read. Revalidate before any - // plaintext becomes visible to the WebSocket implementation. - if let Err(error) = this.admitted(context) { - this.failed = true; - return Poll::Ready(Err(error)); - } - output.put_slice(bytes); - Poll::Ready(Ok(())) - } - } - } -} - -impl<S: AsyncWrite + Unpin> AsyncWrite for MeteredIo<S> { - fn poll_write( - self: Pin<&mut Self>, - context: &mut Context<'_>, - bytes: &[u8], - ) -> Poll<io::Result<usize>> { - let this = self.get_mut(); - if this.failed || !this.ingress.admitted_write(context) { - return Poll::Ready(Err(denied())); - } - Pin::new(&mut this.inner).poll_write(context, bytes) - } - - fn poll_flush(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<io::Result<()>> { - let this = self.get_mut(); - if this.failed || !this.ingress.admitted_write(context) { - return Poll::Ready(Err(denied())); - } - Pin::new(&mut this.inner).poll_flush(context) - } - - fn poll_shutdown(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<io::Result<()>> { - // Closing the underlying transport remains possible after revocation. - Pin::new(&mut self.get_mut().inner).poll_shutdown(context) - } -} - -#[derive(Default)] -struct WireParser { - upgrade_bytes: usize, - delimiter: u32, - upgraded: bool, - header: [u8; 10], - header_len: usize, - header_needed: usize, - payload_remaining: usize, -} - -impl WireParser { - fn consume( - &mut self, - mut bytes: &[u8], - mut admit_frame: impl FnMut(bool) -> bool, - ) -> io::Result<()> { - while let Some((&byte, rest)) = bytes.split_first() { - if !self.upgraded { - self.upgrade_bytes += 1; - if self.upgrade_bytes > MAX_UPGRADE_BYTES { - return Err(invalid("WebSocket upgrade response exceeds its limit")); - } - self.delimiter = (self.delimiter << 8) | u32::from(byte); - self.upgraded = self.delimiter == u32::from_be_bytes(*b"\r\n\r\n"); - bytes = rest; - } else if self.payload_remaining != 0 { - let consumed = self.payload_remaining.min(bytes.len()); - self.payload_remaining -= consumed; - bytes = &bytes[consumed..]; - } else { - if self.header_len == 0 { - let opcode = byte & 0x0f; - if !admit_frame(matches!(opcode, 1 | 2)) { - return Err(denied()); - } - if byte & 0x70 != 0 || !matches!(opcode, 0 | 1 | 2 | 8 | 9 | 10) { - return Err(invalid("unsupported WebSocket frame flags or opcode")); - } - if opcode >= 8 && byte & 0x80 == 0 { - return Err(invalid("fragmented WebSocket control frame")); - } - self.header_needed = 2; - } - self.header[self.header_len] = byte; - self.header_len += 1; - bytes = rest; - if self.header_len == 2 { - if byte & 0x80 != 0 { - return Err(invalid("masked server WebSocket frame")); - } - self.header_needed = match byte { - 126 => 4, - 127 => 10, - _ => 2, - }; - } - if self.header_len == self.header_needed { - self.payload_remaining = self.payload_length()?; - self.header_len = 0; - } - } - } - Ok(()) - } - - fn payload_length(&self) -> io::Result<usize> { - let (length, minimum) = match self.header[1] { - 126 => ( - u64::from(u16::from_be_bytes([self.header[2], self.header[3]])), - 126, - ), - 127 => { - let mut extended = [0; 8]; - extended.copy_from_slice(&self.header[2..10]); - (u64::from_be_bytes(extended), 65536) - } - length => (u64::from(length), 0), - }; - if length < minimum || length > crate::relay::MAX_WIRE_MESSAGE_BYTES as u64 { - return Err(invalid( - "WebSocket frame length is noncanonical or exceeds its limit", - )); - } - if self.header[0] & 0x0f >= 8 && length > 125 { - return Err(invalid("WebSocket control frame exceeds its limit")); - } - usize::try_from(length).map_err(|_| invalid("WebSocket frame length cannot be represented")) - } - - fn eof(&self) -> io::Result<()> { - if !self.upgraded || self.header_len != 0 || self.payload_remaining != 0 { - Err(io::Error::new( - io::ErrorKind::UnexpectedEof, - "truncated WebSocket ingress", - )) - } else { - Ok(()) - } - } -} - -fn invalid(message: &'static str) -> io::Error { - io::Error::new(io::ErrorKind::InvalidData, message) -} - -fn denied() -> io::Error { - io::Error::new( - io::ErrorKind::ConnectionAborted, - "relay ingress budget or generation revoked", - ) -} - -#[cfg(test)] -#[path = "source_wire_tests.rs"] -mod tests; diff --git a/crates/transport_nostr/src/source_wire_tests.rs b/crates/transport_nostr/src/source_wire_tests.rs @@ -1,334 +0,0 @@ -use super::*; -use crate::source::budget::{FetchBudget, MAX_FETCH_BYTES}; -use crate::source_ingress::{FetchRegistration, IngressRegistry}; -use futures::task::{ArcWake, waker}; -use std::sync::{ - Arc, - atomic::{AtomicUsize, Ordering}, -}; - -const UPGRADE: &[u8] = b"HTTP/1.1 101 Switching Protocols\r\n\r\n"; -const RELAY: &str = "ws://127.0.0.1:1234"; - -fn upgraded() -> WireParser { - let mut parser = WireParser::default(); - parser - .consume(UPGRADE, |_| panic!("HTTP is not a frame")) - .expect("upgrade"); - parser -} - -fn header(length: u64) -> Vec<u8> { - let mut bytes = vec![0x82, 127]; - bytes.extend(length.to_be_bytes()); - bytes -} - -#[test] -fn maximum_frame_length_is_admitted_and_next_byte_or_overflow_is_denied() { - let maximum = crate::relay::MAX_WIRE_MESSAGE_BYTES as u64; - let mut parser = upgraded(); - parser - .consume(&header(maximum), |_| true) - .expect("exact limit"); - assert_eq!(parser.payload_remaining, maximum as usize); - for length in [maximum + 1, 1 << 63, u64::MAX] { - assert!(upgraded().consume(&header(length), |_| true).is_err()); - } -} - -#[test] -fn headers_payloads_and_upgrade_can_arrive_one_byte_at_a_time() { - let mut parser = WireParser::default(); - let mut bytes = UPGRADE.to_vec(); - bytes.extend([0x01, 126, 0, 126]); - bytes.extend([b'x'; 126]); - bytes.extend([0x89, 0, 0x80, 2, b'y', b'z', 0x82, 0]); - let mut frames = 0; - let mut data = 0; - for byte in bytes { - parser - .consume(&[byte], |is_data| { - frames += 1; - data += usize::from(is_data); - true - }) - .expect("chopped ingress"); - } - assert_eq!((frames, data), (4, 2)); - parser.eof().expect("complete frames"); -} - -#[test] -fn zero_length_continuations_and_controls_each_require_admission() { - let mut parser = upgraded(); - let mut admissions = 0; - let error = parser - .consume(&[0x01, 0, 0x00, 0, 0x89, 0, 0x80, 0], |is_data| { - admissions += 1; - assert_eq!(is_data, admissions == 1); - admissions <= 3 - }) - .expect_err("fourth frame is denied"); - assert_eq!(error.kind(), io::ErrorKind::ConnectionAborted); - assert_eq!(admissions, 4); -} - -#[test] -fn invalid_flags_masks_lengths_and_controls_fail_closed() { - for bytes in [ - vec![0xc1, 0], - vec![0x83, 0], - vec![0x09, 0], - vec![0x81, 0x80], - vec![0x82, 126, 0, 125], - header(65535), - vec![0x89, 126, 0, 126], - ] { - assert!( - upgraded().consume(&bytes, |_| true).is_err(), - "accepted {bytes:?}" - ); - } -} - -#[test] -fn upgrade_prefix_has_an_exact_fixed_bound() { - let mut exact = vec![b'x'; MAX_UPGRADE_BYTES - 4]; - exact.extend(b"\r\n\r\n"); - let mut parser = WireParser::default(); - parser.consume(&exact, |_| true).expect("exact maximum"); - parser.eof().expect("upgrade boundary"); - let mut excessive = vec![b'x']; - excessive.extend(exact); - assert!(WireParser::default().consume(&excessive, |_| true).is_err()); -} - -#[test] -fn eof_rejects_partial_upgrade_header_and_payload() { - assert!(WireParser::default().eof().is_err()); - for bytes in [vec![0x81], vec![0x82, 126, 0], vec![0x81, 2, b'x']] { - let mut parser = upgraded(); - parser.consume(&bytes, |_| true).expect("partial input"); - assert_eq!( - parser.eof().expect_err("truncation").kind(), - io::ErrorKind::UnexpectedEof - ); - } - upgraded().eof().expect("frame boundary"); -} - -#[derive(Default)] -struct Calls { - reads: AtomicUsize, - writes: AtomicUsize, - wakes: AtomicUsize, -} - -impl ArcWake for Calls { - fn wake_by_ref(arc_self: &Arc<Self>) { - arc_self.wakes.fetch_add(1, Ordering::SeqCst); - } -} - -struct TestIo { - bytes: Vec<u8>, - offset: usize, - chunk: usize, - pending: bool, - calls: Arc<Calls>, -} - -impl AsyncRead for TestIo { - fn poll_read( - mut self: Pin<&mut Self>, - _: &mut Context<'_>, - output: &mut ReadBuf<'_>, - ) -> Poll<io::Result<()>> { - self.calls.reads.fetch_add(1, Ordering::SeqCst); - if self.pending { - return Poll::Pending; - } - let count = (self.bytes.len() - self.offset) - .min(output.remaining()) - .min(self.chunk); - output.put_slice(&self.bytes[self.offset..self.offset + count]); - self.offset += count; - Poll::Ready(Ok(())) - } -} - -impl AsyncWrite for TestIo { - fn poll_write( - self: Pin<&mut Self>, - _: &mut Context<'_>, - bytes: &[u8], - ) -> Poll<io::Result<usize>> { - self.calls.writes.fetch_add(1, Ordering::SeqCst); - Poll::Ready(Ok(bytes.len())) - } - fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> { - self.calls.writes.fetch_add(1, Ordering::SeqCst); - Poll::Ready(Ok(())) - } - fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<()>> { - Poll::Ready(Ok(())) - } -} - -fn fixture( - bytes: Vec<u8>, -) -> ( - MeteredIo<TestIo>, - Arc<FetchBudget>, - FetchRegistration, - Arc<Calls>, -) { - let registry = IngressRegistry::new([RELAY.to_owned()].into_iter()); - let budget = Arc::new(FetchBudget::default()); - let registration = registry - .register([RELAY.to_owned()].into_iter(), budget.clone()) - .expect("registration"); - let connection = registry.connection(RELAY).expect("connection"); - let calls = Arc::new(Calls::default()); - let inner = TestIo { - bytes, - offset: 0, - chunk: READ_CHUNK_BYTES, - pending: false, - calls: calls.clone(), - }; - ( - MeteredIo::new(inner, connection), - budget, - registration, - calls, - ) -} - -fn read(meter: &mut MeteredIo<TestIo>, calls: &Arc<Calls>) -> (Poll<io::Result<()>>, usize) { - let waker = waker(calls.clone()); - let mut context = Context::from_waker(&waker); - let mut output = [0; READ_CHUNK_BYTES]; - let mut buffer = ReadBuf::new(&mut output); - let result = Pin::new(meter).poll_read(&mut context, &mut buffer); - (result, buffer.filled().len()) -} - -#[test] -fn raw_upgrade_and_frame_overhead_count_before_decode() { - let mut bytes = UPGRADE.to_vec(); - bytes.extend([0x81, 0]); - let length = bytes.len(); - let (mut meter, budget, _registration, calls) = fixture(bytes); - assert!(budget.wire(MAX_FETCH_BYTES - length, 0, 0)); - assert!(matches!(read(&mut meter, &calls), (Poll::Ready(Ok(())), count) if count == length)); - assert!(!budget.wire(1, 0, 0)); -} - -#[test] -fn excessive_read_is_not_exposed_and_subsequent_io_is_rejected() { - let (mut meter, budget, _registration, calls) = fixture(UPGRADE.to_vec()); - assert!(budget.wire(MAX_FETCH_BYTES, 0, 0)); - assert!(matches!(read(&mut meter, &calls), (Poll::Ready(Err(_)), 0))); - assert!(budget.exhausted()); - let reads = calls.reads.load(Ordering::SeqCst); - assert!(matches!(read(&mut meter, &calls), (Poll::Ready(Err(_)), 0))); - assert_eq!(calls.reads.load(Ordering::SeqCst), reads); - let waker = waker(calls.clone()); - let mut context = Context::from_waker(&waker); - assert!(matches!( - Pin::new(&mut meter).poll_write(&mut context, b"REQ"), - Poll::Ready(Err(_)) - )); - assert!(matches!( - Pin::new(&mut meter).poll_flush(&mut context), - Poll::Ready(Err(_)) - )); - assert_eq!(calls.writes.load(Ordering::SeqCst), 0); -} - -#[test] -fn cancellation_wakes_pending_read_and_revokes_both_io_directions() { - let (mut meter, _budget, registration, calls) = fixture(Vec::new()); - meter.inner.pending = true; - assert!(matches!(read(&mut meter, &calls), (Poll::Pending, 0))); - let writer_calls = Arc::new(Calls::default()); - let writer_waker = waker(writer_calls.clone()); - let mut writer_context = Context::from_waker(&writer_waker); - assert!(matches!( - Pin::new(&mut meter).poll_write(&mut writer_context, b"REQ"), - Poll::Ready(Ok(3)) - )); - assert!(matches!( - Pin::new(&mut meter).poll_flush(&mut writer_context), - Poll::Ready(Ok(())) - )); - drop(registration); - assert!(calls.wakes.load(Ordering::SeqCst) > 0); - assert!(writer_calls.wakes.load(Ordering::SeqCst) > 0); - assert!(matches!(read(&mut meter, &calls), (Poll::Ready(Err(_)), 0))); - let waker = waker(calls.clone()); - let mut context = Context::from_waker(&waker); - assert!(matches!( - Pin::new(&mut meter).poll_write(&mut context, b"REQ"), - Poll::Ready(Err(_)) - )); - assert!(matches!( - Pin::new(&mut meter).poll_shutdown(&mut context), - Poll::Ready(Ok(())) - )); - assert_eq!(calls.reads.load(Ordering::SeqCst), 1); - assert_eq!(calls.writes.load(Ordering::SeqCst), 2); -} - -#[test] -fn continuation_flood_exhausts_frame_budget_without_assembled_message() { - let mut bytes = UPGRADE.to_vec(); - bytes.extend([0x01, 0]); - for _ in 0..8192 { - bytes.extend([0x00, 0]); - } - let (mut meter, budget, _registration, calls) = fixture(bytes); - loop { - match read(&mut meter, &calls) { - (Poll::Ready(Ok(())), count) => assert!(count > 0, "unexpected EOF"), - (Poll::Ready(Err(_)), 0) => break, - other => panic!("unexpected result {other:?}"), - } - } - assert!(budget.exhausted()); -} - -#[test] -fn empty_data_frames_exhaust_attempt_budget() { - let mut bytes = UPGRADE.to_vec(); - for _ in 0..4097 { - bytes.extend([0x81, 0]); - } - let (mut meter, budget, _registration, calls) = fixture(bytes); - loop { - match read(&mut meter, &calls) { - (Poll::Ready(Ok(())), count) => assert!(count > 0, "unexpected EOF"), - (Poll::Ready(Err(_)), 0) => break, - other => panic!("unexpected result {other:?}"), - } - } - assert!(budget.exhausted()); -} - -#[test] -fn read_chunks_remain_bounded_and_truncation_is_terminal() { - let mut bytes = UPGRADE.to_vec(); - bytes.extend([0x81, 126, 0x20, 0]); - bytes.extend([b'x'; 5000]); - let (mut meter, _budget, _registration, calls) = fixture(bytes); - assert!(matches!( - read(&mut meter, &calls), - (Poll::Ready(Ok(())), READ_CHUNK_BYTES) - )); - assert!(matches!(read(&mut meter, &calls), (Poll::Ready(Ok(())), count) if count > 0)); - assert!( - matches!(read(&mut meter, &calls), (Poll::Ready(Err(error)), 0) if error.kind() == io::ErrorKind::UnexpectedEof) - ); -} diff --git a/crates/transport_nostr/src/subscription.rs b/crates/transport_nostr/src/subscription.rs @@ -1348,4 +1348,21 @@ mod tests { Err(radroots_transport::Error::UnexpectedSubscriptionEvent) ); } + + #[test] + fn empty_and_unrepresentable_selectors_never_gain_implicit_wire_filters() { + assert_eq!( + subscription_filter(&FetchSelector::all(), None).unwrap(), + Filter::new() + ); + let unsupported = FetchSelector::all().with_kinds(vec![u32::MAX]).unwrap(); + assert!(!selector_is_representable(&unsupported)); + assert!(subscription_filter(&unsupported, None).is_err()); + let partial = FetchSelector::all().with_kinds(vec![1, u32::MAX]).unwrap(); + assert!(selector_is_representable(&partial)); + assert_eq!( + subscription_filter(&partial, None).unwrap(), + Filter::new().kind(Kind::TextNote) + ); + } } diff --git a/crates/transport_nostr/src/test_host.rs b/crates/transport_nostr/src/test_host.rs @@ -0,0 +1,133 @@ +//! Test-only loopback I/O for private shared-session lifecycle witnesses. +//! Charges complete frames for shared cleanup tests. Actual native policy, TLS +//! and predecode byte/frame budgets run in the native provider suite. + +use futures::{ + SinkExt, StreamExt, + lock::Mutex, + stream::{SplitSink, SplitStream}, +}; +use radroots_transport::host::websocket::{Admission, Connector, Error, Frame, IoFuture, Socket}; +use std::{num::NonZeroUsize, sync::Arc, time::Duration}; +use tokio::net::TcpStream; +use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, tungstenite::Message}; + +#[derive(Debug)] +pub(crate) struct LoopbackConnector; + +pub(crate) fn transport(config: crate::Config) -> crate::NostrTransport { + crate::NostrTransport::new(config, Arc::new(LoopbackConnector)) +} + +impl Connector for LoopbackConnector { + fn supports_ping(&self) -> bool { + true + } + fn connect<'a>( + &'a self, + endpoint: &'a str, + timeout: Duration, + _: NonZeroUsize, + admission: Arc<dyn Admission>, + ) -> IoFuture<'a, Result<Arc<dyn Socket>, Error>> { + Box::pin(async move { + let url = url::Url::parse(endpoint).map_err(|_| Error::Policy)?; + let ip = url + .host_str() + .and_then(|host| host.parse::<std::net::IpAddr>().ok()) + .ok_or(Error::Policy)?; + if url.scheme() != "ws" || !ip.is_loopback() || !admission.permits_address(ip) { + return Err(Error::Policy); + } + let (socket, _) = + tokio::time::timeout(timeout, tokio_tungstenite::connect_async(endpoint)) + .await + .map_err(|_| Error::Timeout)? + .map_err(|_| Error::Unavailable)?; + let (sink, stream) = socket.split(); + Ok(Arc::new(LoopbackSocket { + sink: Mutex::new(sink), + stream: Mutex::new(stream), + admission, + }) as Arc<dyn Socket>) + }) + } +} + +type Wire = WebSocketStream<MaybeTlsStream<TcpStream>>; +struct LoopbackSocket { + sink: Mutex<SplitSink<Wire, Message>>, + stream: Mutex<SplitStream<Wire>>, + admission: Arc<dyn Admission>, +} + +impl Socket for LoopbackSocket { + fn send(&self, frame: Frame) -> IoFuture<'_, Result<(), Error>> { + Box::pin(async move { + futures::future::poll_fn(|context| { + std::task::Poll::Ready(if self.admission.admitted_write(context) { + Ok(()) + } else { + Err(Error::Closed) + }) + }) + .await?; + let message = match frame { + Frame::Text(text) => Message::Text(text.into()), + Frame::Binary(bytes) => Message::Binary(bytes.into()), + Frame::Ping(bytes) => Message::Ping(bytes.into()), + Frame::Pong(bytes) => Message::Pong(bytes.into()), + Frame::Close(None) => Message::Close(None), + _ => return Err(Error::Unsupported), + }; + self.sink + .lock() + .await + .send(message) + .await + .map_err(|_| Error::Unavailable) + }) + } + fn receive(&self) -> IoFuture<'_, Result<Option<Frame>, Error>> { + Box::pin(async move { + let mut stream = self.stream.lock().await; + let message = futures::future::poll_fn(|context| { + if !self.admission.admitted_read(context) { + return std::task::Poll::Ready(Some(Err( + tokio_tungstenite::tungstenite::Error::ConnectionClosed, + ))); + } + stream.poll_next_unpin(context) + }) + .await + .transpose() + .map_err(|_| Error::Unavailable)?; + message + .map(|message| { + let data = matches!(message, Message::Text(_) | Message::Binary(_)); + if !self.admission.charge(message.len(), 1, usize::from(data)) { + return Err(Error::Closed); + } + Ok(match message { + Message::Text(text) => Frame::Text(text.to_string()), + Message::Binary(bytes) => Frame::Binary(bytes.to_vec()), + Message::Ping(bytes) => Frame::Ping(bytes.to_vec()), + Message::Pong(bytes) => Frame::Pong(bytes.to_vec()), + Message::Close(_) => Frame::Close(None), + Message::Frame(_) => return Err(Error::Protocol), + }) + }) + .transpose() + }) + } + fn close(&self) -> IoFuture<'_, Result<(), Error>> { + Box::pin(async move { + self.sink + .lock() + .await + .close() + .await + .map_err(|_| Error::Unavailable) + }) + } +} diff --git a/crates/transport_nostr/tests/browser_time/run.mjs b/crates/transport_nostr/tests/browser_time/run.mjs @@ -67,7 +67,7 @@ try { }; worker.postMessage('run'); })); - assert.equal(main.length, 12); + assert.equal(main.length, 13); assert.deepEqual(dedicated, main); assert.deepEqual(errors, []); console.log(JSON.stringify({engine, version: browser.version(), main, dedicated, pageErrors: errors})); diff --git a/crates/transport_nostr/tests/browser_time/src/lib.rs b/crates/transport_nostr/tests/browser_time/src/lib.rs @@ -116,6 +116,24 @@ pub async fn verify_host_time() -> Result<js_sys::Array, JsValue> { "expired ready local future", )?; passed.push(&"expired ready local future".into()); + + struct DeferredReady(Rc<Cell<bool>>); + impl core::future::IntoFuture for DeferredReady { + type Output = u32; + type IntoFuture = futures::future::Ready<u32>; + fn into_future(self) -> Self::IntoFuture { + self.0.set(true); + futures::future::ready(7) + } + } + let converted = Rc::new(Cell::new(false)); + let builder = timeout_at(expired, DeferredReady(Rc::clone(&converted))); + require(!converted.get(), "unpolled IntoFuture builder is inert")?; + require( + builder.await.ok() == Some(7) && converted.get(), + "IntoFuture builder timeout", + )?; + passed.push(&"local IntoFuture builder".into()); require( timeout_at(expired, pending::<()>()).await.is_err(), "expired pending future", diff --git a/crates/transport_nostr/tests/exact_delivery.rs b/crates/transport_nostr/tests/exact_delivery.rs @@ -1,505 +0,0 @@ -use futures::{FutureExt, SinkExt, StreamExt}; -use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Tag, Timestamp}; -use radroots_transport::{ - DeliveryRequest, EventSink, EventSource, FetchRequest, TargetSet, - policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, - sink::DeliveryPayload, - source::FetchBounds, -}; -use radroots_transport_nostr::{ - Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, - RelayUrlPolicy, -}; -use serde_json::{Value, json}; -use std::time::{Duration, SystemTime, UNIX_EPOCH}; -use tokio::net::{TcpListener, TcpStream}; -use tokio_tungstenite::{WebSocketStream, accept_async, tungstenite::Message}; - -const KEY: &str = "0000000000000000000000000000000000000000000000000000000000000001"; - -fn now() -> u64 { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_millis() - .try_into() - .unwrap() -} - -fn raw_event() -> String { - let event = EventBuilder::new(Kind::TextNote, "harvest café\n🌱") - .custom_created_at(Timestamp::from_secs(1_800_000_000)) - .finalize(&Keys::parse(KEY).unwrap()) - .unwrap(); - let mut value: Value = serde_json::from_str(&event.as_json()).unwrap(); - value["extension"] = json!({"retained": true}); - format!(" \n{} \t", serde_json::to_string_pretty(&value).unwrap()) -} - -fn config(url: &str, timeout: u64) -> Config { - Config::from_profile( - RelayProfile::explicit( - RelayProfileKind::Simulator, - [RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap()], - ) - .unwrap(), - ) - .with_timeouts(1_000, timeout, 500) - .unwrap() -} - -fn targets(config: &Config) -> TargetSet { - TargetSet::new( - config - .relays() - .iter() - .map(|relay| relay.to_target().unwrap()) - .collect(), - ) - .unwrap() -} - -fn request(config: &Config, raw: &str) -> DeliveryRequest { - DeliveryRequest::new( - "exact-wire", - DeliveryPayload::new(radroots_event_codec::decode::signed_event(raw).unwrap()), - targets(config), - SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), - now() + 5_000, - ) - .unwrap() -} - -async fn text(socket: &mut WebSocketStream<TcpStream>) -> String { - tokio::time::timeout(Duration::from_secs(5), async { - loop { - if let Message::Text(text) = socket.next().await.unwrap().unwrap() { - return text.to_string(); - } - } - }) - .await - .unwrap() -} - -async fn reply(socket: &mut WebSocketStream<TcpStream>, value: Value) { - socket - .send(Message::Text(value.to_string().into())) - .await - .unwrap(); -} - -#[tokio::test] -async fn selected_delivery_never_connects_to_held_target_and_preserves_full_request() { - let a = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let b = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let config = Config::from_profile( - RelayProfile::explicit( - RelayProfileKind::Simulator, - [a.local_addr().unwrap(), b.local_addr().unwrap()].map(|address| { - RelayEndpoint::new( - format!("ws://{address}"), - RelayUrlPolicy::Local, - RelayAccess::ReadWrite, - ) - .unwrap() - }), - ) - .unwrap(), - ) - .with_timeouts(1_000, 2_000, 500) - .unwrap(); - let raw = raw_event(); - let expected = format!("[\"EVENT\",{raw}]"); - let server = tokio::spawn(async move { - let (tcp, _) = a.accept().await.unwrap(); - let mut socket = accept_async(tcp).await.unwrap(); - let wire = text(&mut socket).await; - assert_eq!(wire, expected); - let event: Value = serde_json::from_str(&wire).unwrap(); - reply(&mut socket, json!(["OK", event[1]["id"], true, ""])).await; - }); - let transport = NostrTransport::new(config.clone()); - let request = request(&config, &raw); - let selected = TargetSet::new(vec![request.target_set().targets()[0].clone()]).unwrap(); - let result = transport - .deliver_selected(request.clone(), selected) - .await - .unwrap(); - result.validate_for_request(&request).unwrap(); - assert!(result.target_receipts()[0].was_attempted()); - assert!( - result.target_receipts()[0] - .outcome() - .satisfies(SatisfactionClass::Accepted) - ); - assert!(!result.target_receipts()[1].was_attempted()); - assert_eq!( - result.target_receipts()[1].outcome().code(), - Some("target_not_selected") - ); - assert!(!result.is_satisfied(&request).unwrap()); - server.await.unwrap(); - assert!( - tokio::time::timeout(Duration::from_millis(150), b.accept()) - .await - .is_err() - ); -} - -#[tokio::test] -async fn exact_signed_bytes_read_requests_and_auth_use_the_same_connection() { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); - let raw = raw_event(); - let expected = format!("[\"EVENT\",{raw}]"); - let (auth_sent, auth_seen) = tokio::sync::oneshot::channel(); - let server = tokio::spawn(async move { - let (tcp, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(tcp).await.unwrap(); - let req: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); - assert_eq!(req[0], "REQ"); - reply(&mut socket, json!(["EOSE", req[1]])).await; - loop { - let message: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); - if message[0] == "AUTH" { - assert_eq!(message[1]["kind"], 22242); - auth_sent.send(()).unwrap(); - break; - } - assert_eq!(message[0], "CLOSE"); - } - let wire = text(&mut socket).await; - assert_eq!(wire, expected); - let event: Value = serde_json::from_str(&wire).unwrap(); - reply( - &mut socket, - json!(["OK", "11".repeat(32), true, "unrelated event"]), - ) - .await; - reply(&mut socket, json!(["OK", event[1]["id"], true, ""])).await; - }); - let transport = NostrTransport::new(config.clone()); - let page = transport - .fetch( - FetchRequest::new( - "same-socket-read", - targets(&config), - FetchBounds::new(1, now() + 5_000).unwrap(), - ) - .unwrap(), - ) - .await - .unwrap(); - assert!(page.events().is_empty()); - let relay = &config.relays()[0]; - let at = now() / 1_000 * 1_000; - transport - .begin_authentication(relay, "challenge", at, at + 5_000) - .unwrap(); - let auth = EventBuilder::new(Kind::Authentication, "") - .tags([ - Tag::parse(["relay", relay.as_str()]).unwrap(), - Tag::parse(["challenge", "challenge"]).unwrap(), - ]) - .custom_created_at(Timestamp::from_secs(at / 1_000)) - .finalize(&Keys::parse(KEY).unwrap()) - .unwrap(); - transport - .complete_authentication(relay, "challenge", Some(&auth.as_json()), at) - .await - .unwrap(); - tokio::time::timeout(Duration::from_secs(5), auth_seen) - .await - .unwrap() - .unwrap(); - let receipt = transport.deliver(request(&config, &raw)).await.unwrap(); - assert!( - receipt.target_receipts()[0] - .outcome() - .satisfies(SatisfactionClass::Accepted) - ); - server.await.unwrap(); -} - -#[tokio::test] -async fn an_overlong_ack_identifier_never_accepts_the_matching_prefix() { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 250); - let raw = raw_event(); - let (done, wait) = tokio::sync::oneshot::channel(); - let server = tokio::spawn(async move { - let (tcp, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(tcp).await.unwrap(); - let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); - let overlong = format!("{}00", event[1]["id"].as_str().unwrap()); - reply(&mut socket, json!(["OK", overlong, true, ""])).await; - wait.await.unwrap(); - }); - let request = request(&config, &raw); - let receipt = tokio::time::timeout( - Duration::from_secs(5), - NostrTransport::new(config).deliver(request.clone()), - ) - .await - .unwrap() - .unwrap(); - done.send(()).unwrap(); - server.await.unwrap(); - assert!(!receipt.is_satisfied(&request).unwrap()); -} - -#[tokio::test] -async fn relay_challenge_never_creates_an_implicit_authentication_response() { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); - let raw = raw_event(); - let expected = format!("[\"EVENT\",{raw}]"); - let server = tokio::spawn(async move { - let (tcp, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(tcp).await.unwrap(); - let wire = text(&mut socket).await; - assert_eq!(wire, expected); - let event: Value = serde_json::from_str(&wire).unwrap(); - reply(&mut socket, json!(["AUTH", "explicit-signer-required"])).await; - assert!( - tokio::time::timeout(Duration::from_millis(100), text(&mut socket)) - .await - .is_err() - ); - reply(&mut socket, json!(["OK", event[1]["id"], true, ""])).await; - }); - let transport = NostrTransport::new(config.clone()); - let request = request(&config, &raw); - let receipt = tokio::time::timeout(Duration::from_secs(5), transport.deliver(request.clone())) - .await - .unwrap() - .unwrap(); - server.await.unwrap(); - assert!(receipt.is_satisfied(&request).unwrap()); -} - -#[tokio::test] -async fn rejection_lost_ack_and_disconnect_never_invent_acceptance() { - for mode in ["reject", "lost", "disconnect"] { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 250); - let raw = raw_event(); - let expected = format!("[\"EVENT\",{raw}]"); - let server = tokio::spawn(async move { - let (tcp, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(tcp).await.unwrap(); - let wire = text(&mut socket).await; - assert_eq!(wire, expected); - let event: Value = serde_json::from_str(&wire).unwrap(); - match mode { - "reject" => { - reply( - &mut socket, - json!(["OK", event[1]["id"], false, "blocked: fixture"]), - ) - .await - } - "lost" => { - reply( - &mut socket, - json!(["OK", "22".repeat(32), true, "wrong ID"]), - ) - .await; - tokio::time::sleep(Duration::from_millis(500)).await; - } - "disconnect" => socket.close(None).await.unwrap(), - _ => unreachable!(), - } - }); - let receipt = NostrTransport::new(config.clone()) - .deliver(request(&config, &raw)) - .await - .unwrap(); - assert!( - !receipt.target_receipts()[0] - .outcome() - .satisfies(SatisfactionClass::Accepted), - "{mode}" - ); - assert!(receipt.target_receipts()[0].was_attempted()); - server.await.unwrap(); - } -} - -#[tokio::test] -async fn matching_negative_ack_never_accepts_duplicate_text() { - for message in [ - "blocked: not a duplicate; event was rejected", - "duplicate: already have this event", - "already have this event", - "error: duplicate detector unavailable", - "auth-required: duplicate path requires login", - "rate-limited: duplicate retries", - "invalid: duplicate event format", - ] { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); - let raw = raw_event(); - let expected = format!("[\"EVENT\",{raw}]"); - let (done, wait) = tokio::sync::oneshot::channel(); - let server = tokio::spawn(async move { - let (tcp, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(tcp).await.unwrap(); - let wire = text(&mut socket).await; - assert_eq!(wire, expected); - let event: Value = serde_json::from_str(&wire).unwrap(); - reply(&mut socket, json!(["OK", event[1]["id"], false, message])).await; - tokio::time::timeout(Duration::from_secs(5), wait) - .await - .unwrap() - .unwrap(); - }); - let transport = NostrTransport::new(config.clone()); - let request = request(&config, &raw); - let receipt = - tokio::time::timeout(Duration::from_secs(5), transport.deliver(request.clone())) - .await - .unwrap() - .unwrap(); - done.send(()).unwrap(); - server.await.unwrap(); - receipt.validate_for_request(&request).unwrap(); - assert!(receipt.target_receipts()[0].was_attempted()); - assert!(!receipt.is_satisfied(&request).unwrap(), "{message}"); - assert!( - !receipt.target_receipts()[0] - .outcome() - .satisfies(SatisfactionClass::Accepted), - "{message}" - ); - } -} - -#[tokio::test] -async fn matching_positive_ack_accepts_existing_duplicate_and_empty_messages() { - for message in ["", "duplicate: already have this event"] { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); - let raw = raw_event(); - let (done, wait) = tokio::sync::oneshot::channel(); - let server = tokio::spawn(async move { - let (tcp, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(tcp).await.unwrap(); - let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); - assert_eq!(event[0], "EVENT"); - reply(&mut socket, json!(["OK", event[1]["id"], true, message])).await; - tokio::time::timeout(Duration::from_secs(5), wait) - .await - .unwrap() - .unwrap(); - }); - let request = request(&config, &raw); - let receipt = tokio::time::timeout( - Duration::from_secs(5), - NostrTransport::new(config).deliver(request.clone()), - ) - .await - .unwrap() - .unwrap(); - done.send(()).unwrap(); - server.await.unwrap(); - receipt.validate_for_request(&request).unwrap(); - assert!(receipt.is_satisfied(&request).unwrap(), "{message}"); - } -} - -#[tokio::test] -async fn quota_refusal_is_terminal_and_redacted_at_the_receipt_boundary() { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); - let server = tokio::spawn(async move { - let (tcp, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(tcp).await.unwrap(); - let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); - reply( - &mut socket, - json!([ - "OK", - event[1]["id"], - false, - "quota exceeded: private-account-detail" - ]), - ) - .await; - }); - let transport = NostrTransport::new(config.clone()); - let receipt = transport - .deliver(request(&config, &raw_event())) - .await - .unwrap(); - let target = &receipt.target_receipts()[0]; - assert!(target.was_attempted()); - assert_eq!(target.outcome().code(), Some("quota_exceeded")); - assert_eq!( - target.outcome().retryability(), - radroots_transport::outcome::Retryability::Terminal - ); - assert_eq!( - target.outcome().kind(), - radroots_transport::outcome::DeliveryOutcomeKind::Rejected - ); - assert_eq!( - target.outcome().message(), - Some("relay quota was exhausted") - ); - assert_eq!( - transport.relay_status().relays()[0] - .write() - .last_failure_retryable(), - Some(false) - ); - server.await.unwrap(); -} - -#[tokio::test] -async fn queued_delivery_targets_cannot_start_after_the_shared_deadline() { - let first = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let second = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let endpoints = [&first, &second].map(|listener| { - RelayEndpoint::new( - format!("ws://{}", listener.local_addr().unwrap()), - RelayUrlPolicy::Local, - RelayAccess::ReadWrite, - ) - .unwrap() - }); - let config = Config::from_profile( - RelayProfile::explicit(RelayProfileKind::Simulator, endpoints).unwrap(), - ) - .with_timeouts(1_000, 250, 500) - .unwrap() - .with_max_connections(1) - .unwrap(); - let server = tokio::spawn(async move { - let (tcp, _) = first.accept().await.unwrap(); - let mut socket = accept_async(tcp).await.unwrap(); - let _published = text(&mut socket).await; - futures::future::pending::<()>().await; - }); - let transport = NostrTransport::new(config.clone()); - let receipt = transport - .deliver(request(&config, &raw_event())) - .await - .unwrap(); - assert_eq!(receipt.target_receipts().len(), 2); - assert!( - receipt - .target_receipts() - .iter() - .all(|target| !target.outcome().satisfies(SatisfactionClass::Accepted)) - ); - assert!(second.accept().now_or_never().is_none()); - assert!(receipt.target_receipts()[0].was_attempted()); - assert!( - !receipt.target_receipts()[1].was_attempted(), - "a target expired while queued never entered remote publication" - ); - server.abort(); - assert!(server.await.unwrap_err().is_cancelled()); -} diff --git a/crates/transport_nostr/tests/fetch_bounds.rs b/crates/transport_nostr/tests/fetch_bounds.rs @@ -1,345 +0,0 @@ -use futures::{SinkExt, StreamExt}; -use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind}; -use radroots_transport::{ - EventSource, FetchRequest, TargetSet, outcome::FetchTargetState, source::FetchBounds, -}; -use radroots_transport_nostr::{ - Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, - RelayUrlPolicy, -}; -use serde_json::Value; -use std::{ - sync::{ - Arc, - atomic::{AtomicUsize, Ordering}, - }, - time::{Duration, SystemTime, UNIX_EPOCH}, -}; -use tokio::{net::TcpListener, sync::oneshot}; -use tokio_tungstenite::{accept_async, tungstenite::Message}; - -fn transport(urls: &[String], connections: usize) -> (NostrTransport, FetchRequest) { - let endpoints = urls - .iter() - .map(|url| RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap()); - let profile = RelayProfile::explicit(RelayProfileKind::Simulator, endpoints).unwrap(); - let config = Config::from_profile(profile) - .with_timeouts(1000, 1000, 500) - .unwrap() - .with_max_connections(connections) - .unwrap(); - let targets = TargetSet::new( - config - .read_relays() - .map(|relay| relay.to_target().unwrap()) - .collect(), - ) - .unwrap(); - let now = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_millis() as u64; - let request = FetchRequest::new( - "bounded-loopback", - targets, - FetchBounds::new(10, now + 5000).unwrap(), - ) - .unwrap(); - (NostrTransport::new(config), request) -} - -async fn listener() -> (TcpListener, String) { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let url = format!("ws://{}", listener.local_addr().unwrap()); - (listener, url) -} - -fn event(content: &str) -> Value { - let keys = - Keys::parse("0000000000000000000000000000000000000000000000000000000000000001").unwrap(); - let event = EventBuilder::new(Kind::TextNote, content) - .finalize(&keys) - .unwrap(); - serde_json::from_str(&event.as_json()).unwrap() -} - -async fn serve( - listener: TcpListener, - payload: Option<Value>, - eose: bool, - requests: Arc<AtomicUsize>, -) { - let (stream, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(stream).await.unwrap(); - while let Some(message) = socket.next().await { - let Ok(Message::Text(message)) = message else { - continue; - }; - let values: Value = serde_json::from_str(&message).unwrap(); - if values[0] != "REQ" { - continue; - } - requests.fetch_add(1, Ordering::SeqCst); - if let Some(payload) = &payload { - socket - .send(Message::Text( - serde_json::to_string(&("EVENT", &values[1], payload)) - .unwrap() - .into(), - )) - .await - .unwrap(); - } - if eose { - socket - .send(Message::Text( - serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), - )) - .await - .unwrap(); - } - std::future::pending::<()>().await; - } -} - -#[tokio::test(flavor = "multi_thread")] -async fn a_cached_event_id_never_admits_a_changed_signature() { - let (listener, url) = listener().await; - let valid = event("cached signature admission"); - let mut changed = valid.clone(); - changed["sig"] = Value::String("0".repeat(128)); - let (release, released) = oneshot::channel(); - let server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(stream).await.unwrap(); - for payload in [valid, changed, event("valid continuation after rejection")] { - loop { - let message = socket.next().await.unwrap().unwrap(); - let Message::Text(text) = message else { - socket.flush().await.unwrap(); - continue; - }; - let values: Value = serde_json::from_str(&text).unwrap(); - if values[0] != "REQ" { - continue; - } - socket - .send(Message::Text( - serde_json::to_string(&("EVENT", &values[1], &payload)) - .unwrap() - .into(), - )) - .await - .unwrap(); - socket - .send(Message::Text( - serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), - )) - .await - .unwrap(); - break; - } - } - released.await.unwrap(); - }); - let (transport, request) = transport(&[url], 1); - let pages = tokio::time::timeout(Duration::from_secs(5), async { - let first = transport.fetch(request.clone()).await.unwrap(); - let repeated = transport.fetch(request.clone()).await.unwrap(); - let continuation = transport.fetch(request).await.unwrap(); - (first, repeated, continuation) - }) - .await - .unwrap(); - release.send(()).unwrap(); - server.await.unwrap(); - assert_eq!(pages.0.events().len(), 1); - assert!( - pages.1.events().is_empty(), - "changed signature reached fetch output" - ); - assert_eq!(pages.2.events().len(), 1); - assert!( - [&pages.0, &pages.1, &pages.2] - .into_iter() - .all(|page| page.target_outcomes()[0].state() == FetchTargetState::Complete) - ); -} - -#[tokio::test(flavor = "multi_thread")] -async fn overlong_event_identifiers_never_become_normalized_fetch_results() { - for field in ["id", "pubkey", "sig"] { - let (listener, url) = listener().await; - let mut payload = event("strict wire identifiers"); - payload[field] = Value::String(format!("{}00", payload[field].as_str().unwrap())); - let calls = Arc::new(AtomicUsize::new(0)); - let server = tokio::spawn(serve(listener, Some(payload), true, Arc::clone(&calls))); - let (transport, request) = transport(&[url], 1); - let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) - .await - .unwrap() - .unwrap(); - server.abort(); - assert_eq!(calls.load(Ordering::SeqCst), 1); - assert!(page.events().is_empty(), "{field}"); - assert_ne!( - page.target_outcomes()[0].state(), - FetchTargetState::Complete, - "{field}" - ); - } -} - -#[tokio::test(flavor = "multi_thread")] -async fn queued_relays_do_not_receive_a_fresh_timeout_after_a_stalled_relay() { - let (first, first_url) = listener().await; - let (second, second_url) = listener().await; - // Adapter scheduling is canonical URL order, independent of profile order. - let mut relays = [(first_url, first), (second_url, second)]; - relays.sort_by(|left, right| left.0.cmp(&right.0)); - let [(first_url, first), (second_url, second)] = relays; - let first_requests = Arc::new(AtomicUsize::new(0)); - let second_requests = Arc::new(AtomicUsize::new(0)); - let first_task = tokio::spawn(serve(first, None, false, Arc::clone(&first_requests))); - let second_task = tokio::spawn(serve(second, None, true, Arc::clone(&second_requests))); - let (transport, request) = transport(&[first_url, second_url], 1); - let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) - .await - .unwrap() - .unwrap(); - first_task.abort(); - second_task.abort(); - assert_eq!(first_requests.load(Ordering::SeqCst), 1); - assert_eq!(second_requests.load(Ordering::SeqCst), 0); - assert_eq!(page.target_outcomes().len(), 2); - assert!( - page.target_outcomes() - .iter() - .all(|outcome| outcome.state() == FetchTargetState::Cancelled) - ); -} - -#[tokio::test(flavor = "multi_thread")] -async fn a_slow_relay_preserves_the_other_relays_completed_evidence_and_collected_events() { - let (good, good_url) = listener().await; - let (slow, slow_url) = listener().await; - let good_event = event("complete relay"); - let slow_event = event("partial relay"); - let expected = [ - good_event["id"].as_str().unwrap().to_owned(), - slow_event["id"].as_str().unwrap().to_owned(), - ]; - let calls = Arc::new(AtomicUsize::new(0)); - let good_task = tokio::spawn(serve(good, Some(good_event), true, Arc::clone(&calls))); - let slow_task = tokio::spawn(serve(slow, Some(slow_event), false, Arc::clone(&calls))); - let (transport, request) = transport(&[good_url, slow_url], 2); - let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) - .await - .unwrap() - .unwrap(); - good_task.abort(); - slow_task.abort(); - assert_eq!(calls.load(Ordering::SeqCst), 2); - assert_eq!(page.events().len(), 2); - for id in expected { - assert!( - page.events() - .iter() - .any(|event| event.event().id_str() == id) - ); - } - assert_eq!( - page.target_outcomes() - .iter() - .filter(|outcome| outcome.state() == FetchTargetState::Complete) - .count(), - 1 - ); - assert_eq!( - page.target_outcomes() - .iter() - .filter(|outcome| outcome.state() == FetchTargetState::Cancelled) - .count(), - 1 - ); -} - -#[tokio::test(flavor = "multi_thread")] -async fn oversized_wire_messages_never_become_completed_fetch_evidence() { - let (listener, url) = listener().await; - let server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(stream).await.unwrap(); - while let Some(message) = socket.next().await { - let message = match message { - Ok(Message::Text(message)) => message, - Ok(Message::Close(_)) | Err(_) => return, - _ => continue, - }; - let values: Value = serde_json::from_str(&message).unwrap(); - if values[0] == "REQ" { - let _ = socket - .send(Message::Text( - serde_json::to_string(&("NOTICE", "x".repeat(512 * 1024))) - .unwrap() - .into(), - )) - .await; - } - } - }); - let (transport, request) = transport(&[url], 1); - let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) - .await - .unwrap() - .unwrap(); - tokio::time::timeout(Duration::from_secs(5), server) - .await - .unwrap() - .unwrap(); - assert!(page.events().is_empty()); - assert_eq!(page.target_outcomes().len(), 1); - assert_ne!( - page.target_outcomes()[0].state(), - FetchTargetState::Complete - ); -} - -#[tokio::test(flavor = "multi_thread")] -async fn dropping_a_polled_fetch_closes_the_subscription_or_connection() { - let (listener, url) = listener().await; - let (started, observed) = oneshot::channel(); - let server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(stream).await.unwrap(); - let mut started = Some(started); - while let Some(message) = socket.next().await { - let message = match message { - Ok(Message::Text(message)) => message, - Ok(Message::Close(_)) | Err(_) => return, - _ => continue, - }; - let values: Value = serde_json::from_str(&message).unwrap(); - if values[0] == "REQ" { - started.take().unwrap().send(()).unwrap(); - } else if values[0] == "CLOSE" { - return; - } - } - }); - let (transport, request) = transport(&[url], 1); - let mut fetch = Box::pin(transport.fetch(request)); - tokio::time::timeout(Duration::from_secs(5), async { - tokio::select! { - _ = &mut fetch => panic!("fetch completed before its relay response"), - result = observed => { result.unwrap(); } - } - }) - .await - .unwrap(); - drop(fetch); - tokio::time::timeout(Duration::from_secs(5), server) - .await - .unwrap() - .unwrap(); -} diff --git a/crates/transport_nostr/tests/fetch_raw_budget.rs b/crates/transport_nostr/tests/fetch_raw_budget.rs @@ -1,299 +0,0 @@ -use futures::{SinkExt, StreamExt}; -use radroots_transport::{ - EventSource, FetchRequest, TargetSet, outcome::FetchTargetState, source::FetchBounds, -}; -use radroots_transport_nostr::{ - Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, - RelayUrlPolicy, -}; -use serde_json::Value; -use std::time::{Duration, SystemTime, UNIX_EPOCH}; -use tokio::net::{TcpListener, TcpStream}; -use tokio_tungstenite::{WebSocketStream, accept_async, tungstenite::Message}; - -const WATCHDOG: Duration = Duration::from_secs(10); - -fn transport(urls: &[String]) -> (NostrTransport, FetchRequest) { - let profile = RelayProfile::explicit( - RelayProfileKind::Simulator, - urls.iter().map(|url| { - RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap() - }), - ) - .unwrap(); - let config = Config::from_profile(profile) - .with_timeouts(1000, 5000, 500) - .unwrap() - .with_max_connections(1) - .unwrap(); - let targets = TargetSet::new( - config - .read_relays() - .map(|relay| relay.to_target().unwrap()) - .collect(), - ) - .unwrap(); - let now = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_millis() as u64; - let request = FetchRequest::new( - "raw-budget-loopback", - targets, - FetchBounds::new(10, now + 5000).unwrap(), - ) - .unwrap(); - (NostrTransport::new(config), request) -} - -async fn listener() -> (TcpListener, String) { - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let url = format!("ws://{}", listener.local_addr().unwrap()); - (listener, url) -} - -fn malformed_event() -> Value { - // Canonical primitive fields pass wire admission, while absent event - // fields still exercise malformed traffic in the aggregate ingress budget. - let value = serde_json::json!({ - "id": "00".repeat(32), - "pubkey": "11".repeat(32), - "sig": "22".repeat(64), - "invalid_event": "x".repeat(384 * 1024), - }); - assert!(serde_json::from_value::<nostr_sdk::prelude::Event>(value.clone()).is_err()); - value -} - -// A WebSocket pong is produced only after the client's receive stream has -// consumed all preceding messages. No scheduling sleep is an admission barrier. -async fn barrier(socket: &mut WebSocketStream<TcpStream>, sequence: usize) -> bool { - let marker = sequence.to_be_bytes().to_vec(); - if socket - .send(Message::Ping(marker.clone().into())) - .await - .is_err() - { - return false; - } - while let Some(message) = socket.next().await { - match message { - Ok(Message::Pong(value)) if value.as_ref() == marker.as_slice() => return true, - Ok(Message::Close(_)) | Err(_) => return false, - _ => { - if socket.flush().await.is_err() { - return false; - } - } - } - } - false -} - -async fn serve_malformed(listener: TcpListener, frames: usize) { - let (stream, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(stream).await.unwrap(); - while let Some(message) = socket.next().await { - let text = match message { - Ok(Message::Text(text)) => text, - Ok(Message::Close(_)) | Err(_) => return, - _ => { - let _ = socket.flush().await; - continue; - } - }; - let values: Value = serde_json::from_str(&text).unwrap(); - if values[0] != "REQ" { - continue; - } - let malformed = serde_json::to_string(&("EVENT", &values[1], malformed_event())).unwrap(); - assert!(malformed.len() < 512 * 1024); - for sequence in 0..frames { - if socket - .send(Message::Text(malformed.clone().into())) - .await - .is_err() - || !barrier(&mut socket, sequence).await - { - return; - } - } - if socket - .send(Message::Text( - serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), - )) - .await - .is_err() - { - return; - } - } -} - -async fn fetch_malformed(frames: usize) -> FetchTargetState { - let (listener, url) = listener().await; - let server = tokio::spawn(serve_malformed(listener, frames)); - let (transport, request) = transport(&[url]); - let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; - server.abort(); - let joined = server.await; - assert!(joined.is_ok() || joined.unwrap_err().is_cancelled()); - let page = result.unwrap().unwrap(); - assert!(page.events().is_empty()); - assert_eq!(page.target_outcomes().len(), 1); - page.target_outcomes()[0].state() -} - -#[tokio::test(flavor = "multi_thread")] -async fn empty_eose_remains_complete_with_raw_ingress_accounting() { - assert_eq!(fetch_malformed(0).await, FetchTargetState::Complete); -} - -#[tokio::test(flavor = "multi_thread")] -async fn malformed_event_traffic_exhausts_raw_budget_before_eose() { - assert_eq!(fetch_malformed(24).await, FetchTargetState::Partial); -} - -async fn finish_server(mut server: tokio::task::JoinHandle<()>) { - let result = tokio::time::timeout(WATCHDOG, &mut server).await; - if result.is_err() { - server.abort(); - let _ = server.await; - } - result - .expect("client must close the bounded relay connection") - .unwrap(); -} - -#[tokio::test(flavor = "multi_thread")] -async fn completed_batches_do_not_refund_raw_bytes_for_later_relays() { - let (one, one_url) = listener().await; - let (two, two_url) = listener().await; - let servers = [ - tokio::spawn(serve_malformed(one, 12)), - tokio::spawn(serve_malformed(two, 12)), - ]; - let (transport, request) = transport(&[one_url, two_url]); - let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; - for server in servers { - finish_server(server).await; - } - let page = result.unwrap().unwrap(); - assert!(page.events().is_empty()); - assert_eq!( - page.target_outcomes() - .iter() - .filter(|outcome| outcome.state() == FetchTargetState::Complete) - .count(), - 1 - ); - assert_eq!( - page.target_outcomes() - .iter() - .filter(|outcome| outcome.state() == FetchTargetState::Partial) - .count(), - 1 - ); -} - -#[tokio::test(flavor = "multi_thread")] -async fn unsolicited_malformed_traffic_is_bounded_before_the_request() { - let (listener, url) = listener().await; - let server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(stream).await.unwrap(); - let malformed = - serde_json::to_string(&("EVENT", "unsolicited", malformed_event())).unwrap(); - for sequence in 0..24 { - if socket - .send(Message::Text(malformed.clone().into())) - .await - .is_err() - || !barrier(&mut socket, sequence).await - { - return; - } - } - panic!("oversized unsolicited inventory must close before admission"); - }); - let (transport, request) = transport(&[url]); - let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; - finish_server(server).await; - assert_eq!( - result.unwrap().unwrap().target_outcomes()[0].state(), - FetchTargetState::Partial - ); -} - -#[tokio::test(flavor = "multi_thread")] -async fn zero_payload_continuation_frames_consume_work_before_message_decoding() { - use tokio_tungstenite::tungstenite::protocol::frame::{ - Frame, - coding::{Data, OpCode}, - }; - let (listener, url) = listener().await; - let server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(stream).await.unwrap(); - while let Some(message) = socket.next().await { - let text = match message { - Ok(Message::Text(text)) => text, - Ok(Message::Close(_)) | Err(_) => return, - _ => { - let _ = socket.flush().await; - continue; - } - }; - let values: Value = serde_json::from_str(&text).unwrap(); - if values[0] != "REQ" { - continue; - } - socket - .send(Message::Frame(Frame::message( - Vec::new(), - OpCode::Data(Data::Text), - false, - ))) - .await - .unwrap(); - for sequence in 0..8193 { - if socket - .send(Message::Frame(Frame::message( - Vec::new(), - OpCode::Data(Data::Continue), - false, - ))) - .await - .is_err() - { - return; - } - if sequence % 128 == 0 && !barrier(&mut socket, sequence).await { - return; - } - } - if socket - .send(Message::Frame(Frame::message( - b"[]".to_vec(), - OpCode::Data(Data::Continue), - true, - ))) - .await - .is_err() - { - return; - } - let _ = socket - .send(Message::Text( - serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), - )) - .await; - } - }); - let (transport, request) = transport(&[url]); - let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; - finish_server(server).await; - let page = result.unwrap().unwrap(); - assert!(page.events().is_empty()); - assert_eq!(page.target_outcomes()[0].state(), FetchTargetState::Partial); -} diff --git a/crates/transport_nostr/tests/fetch_windows.rs b/crates/transport_nostr/tests/fetch_windows.rs @@ -1,161 +0,0 @@ -use futures::{SinkExt, StreamExt}; -use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Timestamp}; -use radroots_transport::{ - EventSource, FetchRequest, TargetSet, - outcome::FetchTargetState, - source::{FetchBounds, NextPage}, -}; -use radroots_transport_nostr::{ - Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, - RelayUrlPolicy, -}; -use serde_json::Value; -use std::{ - collections::BTreeSet, - sync::{ - Arc, - atomic::{AtomicUsize, Ordering}, - }, - time::{Duration, SystemTime, UNIX_EPOCH}, -}; -use tokio::net::TcpListener; -use tokio_tungstenite::{accept_async, tungstenite::Message}; - -#[tokio::test(flavor = "multi_thread")] -async fn real_capped_eose_preserves_received_ties_and_yields_explicit_older_history() { - let keys = - Keys::parse("0000000000000000000000000000000000000000000000000000000000000001").unwrap(); - let mut history = (0..1001) - .map(|index| { - let event = EventBuilder::new(Kind::TextNote, format!("equal-time {index}")) - .custom_created_at(Timestamp::from_secs(100)) - .finalize(&keys) - .unwrap(); - serde_json::from_str::<Value>(&event.as_json()).unwrap() - }) - .collect::<Vec<_>>(); - history.sort_by(|left, right| right["id"].as_str().cmp(&left["id"].as_str())); - let expected = history[..1000] - .iter() - .map(|event| event["id"].as_str().unwrap().to_owned()) - .collect::<BTreeSet<_>>(); - let older = EventBuilder::new(Kind::TextNote, "older") - .custom_created_at(Timestamp::from_secs(99)) - .finalize(&keys) - .unwrap(); - history.push(serde_json::from_str(&older.as_json()).unwrap()); - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let url = format!("ws://{}", listener.local_addr().unwrap()); - let calls = Arc::new(AtomicUsize::new(0)); - let server_calls = calls.clone(); - let server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(stream).await.unwrap(); - while let Some(Ok(message)) = socket.next().await { - let Message::Text(message) = message else { - continue; - }; - let request: Value = serde_json::from_str(&message).unwrap(); - if request[0] != "REQ" { - continue; - } - server_calls.fetch_add(1, Ordering::SeqCst); - assert_eq!(request[2]["limit"], 1000); - let until = request[2]["until"].as_u64().unwrap_or(u64::MAX); - for event in history - .iter() - .filter(|event| event["created_at"].as_u64().unwrap() <= until) - .take(1000) - { - socket - .send(Message::Text( - serde_json::to_string(&("EVENT", &request[1], event)) - .unwrap() - .into(), - )) - .await - .unwrap(); - } - socket - .send(Message::Text( - serde_json::to_string(&("EOSE", &request[1])) - .unwrap() - .into(), - )) - .await - .unwrap(); - } - }); - let profile = RelayProfile::explicit( - RelayProfileKind::Simulator, - [RelayEndpoint::new(&url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap()], - ) - .unwrap(); - let config = Config::from_profile(profile) - .with_timeouts(5000, 5000, 500) - .unwrap(); - let targets = TargetSet::new( - config - .read_relays() - .map(|relay| relay.to_target().unwrap()) - .collect(), - ) - .unwrap(); - let transport = NostrTransport::new(config); - let deadline = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_millis() as u64 - + 20000; - let request = FetchRequest::new( - "live-capped-window", - targets, - FetchBounds::new(500, deadline).unwrap(), - ) - .unwrap(); - tokio::time::timeout(Duration::from_secs(15), async { - let first = transport.fetch(request.clone()).await.unwrap(); - assert_eq!(first.events().len(), 500); - assert_eq!( - first.target_outcomes()[0].state(), - FetchTargetState::Partial - ); - let NextPage::Cursor(cursor) = first.next_page() else { - panic!("received peers remain") - }; - let second = transport - .fetch(request.clone().with_cursor(cursor.clone())) - .await - .unwrap(); - assert_eq!(second.events().len(), 500); - assert_eq!( - second.target_outcomes()[0].state(), - FetchTargetState::Partial - ); - assert_eq!(calls.load(Ordering::SeqCst), 2); - let received = first - .events() - .iter() - .chain(second.events()) - .map(|e| e.event().id_str().to_owned()) - .collect::<BTreeSet<_>>(); - assert_eq!(received, expected); - let NextPage::Cancelled { - resume_from: Some(older), - } = second.next_page() - else { - panic!("explicit partial window yield") - }; - let third = transport - .fetch(request.with_cursor(older.clone())) - .await - .unwrap(); - assert_eq!(third.events().len(), 1); - assert_eq!(third.events()[0].event().created_at(), 99); - assert!(matches!(third.next_page(), NextPage::Complete)); - assert_eq!(calls.load(Ordering::SeqCst), 3); - }) - .await - .unwrap(); - server.abort(); -} diff --git a/crates/transport_nostr/tests/local_io.rs b/crates/transport_nostr/tests/local_io.rs @@ -1,378 +0,0 @@ -use futures::{SinkExt, StreamExt}; -use radroots_transport::{ - EventSource, EventSubscriber, FetchRequest, SubscriptionNext, SubscriptionRequest, TargetSet, - capability::Availability, - outcome::FetchTargetState, - source::{FetchBounds, SubscriptionBounds, SubscriptionEndReason}, -}; -use radroots_transport_nostr::{ - Config, NostrTransport, RelayAccess, RelayAggregateState, RelayEndpoint, RelayEvidenceState, - RelayProfile, RelayProfileKind, RelayUrlPolicy, -}; -use serde_json::Value; -use std::time::{Duration, SystemTime, UNIX_EPOCH}; -use tokio::net::TcpListener; -use tokio_tungstenite::{accept_async, tungstenite::Message}; - -const FIXTURE_SECRET_KEY: &str = "0000000000000000000000000000000000000000000000000000000000000001"; - -#[tokio::test(flavor = "multi_thread")] -async fn simulator_profile_proves_read_capability_against_a_real_loopback_socket() { - let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind relay"); - let address = listener.local_addr().expect("relay address"); - let relay_url = format!("ws://{address}"); - let server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.expect("accept relay client"); - let mut websocket = accept_async(stream).await.expect("websocket handshake"); - while let Some(message) = websocket.next().await { - let Message::Text(message) = message.expect("client message") else { - continue; - }; - let parsed: Value = serde_json::from_str(message.as_str()).expect("Nostr message"); - let Some(values) = parsed.as_array() else { - continue; - }; - let [Value::String(kind), Value::String(subscription), ..] = values.as_slice() else { - continue; - }; - if kind == "REQ" { - websocket - .send(Message::Text( - serde_json::to_string(&("EOSE", subscription)) - .expect("EOSE message") - .into(), - )) - .await - .expect("send EOSE"); - break; - } - } - }); - - let endpoint = RelayEndpoint::new( - relay_url.as_str(), - RelayUrlPolicy::Local, - RelayAccess::ReadWrite, - ) - .expect("loopback endpoint"); - let profile = - RelayProfile::explicit(RelayProfileKind::Simulator, [endpoint]).expect("simulator profile"); - let config = Config::from_profile(profile) - .with_timeouts(1_000, 2_000, 500) - .expect("timeouts"); - let targets = TargetSet::new( - config - .read_relays() - .map(|relay| relay.to_target()) - .collect::<Result<Vec<_>, _>>() - .expect("targets"), - ) - .expect("target set"); - let request = FetchRequest::new( - "local-real-io", - targets, - FetchBounds::new(1, unix_time_ms() + 5_000).expect("bounds"), - ) - .expect("request"); - let transport = NostrTransport::new(config); - let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) - .await - .expect("bounded fetch") - .expect("fetch page"); - - assert!(page.events().is_empty()); - assert_eq!(page.target_outcomes().len(), 1); - assert_eq!( - page.target_outcomes()[0].state(), - FetchTargetState::Complete - ); - let status = transport.relay_status(); - assert_eq!(status.state(), RelayAggregateState::ReadOnly); - assert_eq!(status.read_availability(), Availability::Available); - assert_eq!(status.write_availability(), Availability::Unavailable); - assert_eq!( - status.relays()[0].read().state(), - RelayEvidenceState::Available - ); - assert_eq!( - status.relays()[0].write().state(), - RelayEvidenceState::Unobserved - ); - server.await.expect("relay task"); -} - -#[tokio::test(flavor = "multi_thread")] -async fn simulator_profile_streams_and_cancels_a_real_live_subscription() { - use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Timestamp}; - - let event = EventBuilder::new(Kind::TextNote, "bounded live event") - .custom_created_at(Timestamp::from_secs(1_800_000_100)) - .finalize(&Keys::parse(FIXTURE_SECRET_KEY).expect("fixture keys")) - .expect("signed event"); - let expected_id = event.id.to_hex(); - let event: Value = serde_json::from_str(event.as_json().as_str()).expect("event JSON"); - let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind relay"); - let address = listener.local_addr().expect("relay address"); - let relay_url = format!("ws://{address}"); - let server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.expect("accept relay client"); - let mut websocket = accept_async(stream).await.expect("websocket handshake"); - let mut subscription_id = None; - while let Some(message) = websocket.next().await { - let Message::Text(message) = message.expect("client message") else { - continue; - }; - let parsed: Value = serde_json::from_str(message.as_str()).expect("Nostr message"); - let Some(values) = parsed.as_array() else { - continue; - }; - match values.as_slice() { - [Value::String(kind), Value::String(subscription), ..] if kind == "REQ" => { - subscription_id = Some(subscription.clone()); - websocket - .send(Message::Text( - serde_json::to_string(&("EVENT", subscription, &event)) - .expect("EVENT message") - .into(), - )) - .await - .expect("send EVENT"); - } - [Value::String(kind), Value::String(subscription)] - if kind == "CLOSE" && subscription_id.as_ref() == Some(subscription) => - { - return; - } - _ => {} - } - } - panic!("client disconnected without CLOSE"); - }); - - let endpoint = RelayEndpoint::new( - relay_url.as_str(), - RelayUrlPolicy::Local, - RelayAccess::ReadWrite, - ) - .expect("loopback endpoint"); - let profile = - RelayProfile::explicit(RelayProfileKind::Simulator, [endpoint]).expect("simulator profile"); - let config = Config::from_profile(profile) - .with_timeouts(1_000, 2_000, 500) - .expect("timeouts"); - let targets = TargetSet::new( - config - .read_relays() - .map(|relay| relay.to_target()) - .collect::<Result<Vec<_>, _>>() - .expect("targets"), - ) - .expect("target set"); - let request = SubscriptionRequest::new( - "local-live-io", - targets, - SubscriptionBounds::new(2, unix_time_ms() + 5_000).expect("bounds"), - ) - .expect("request"); - let transport = NostrTransport::new(config); - let mut subscription = - tokio::time::timeout(Duration::from_secs(5), transport.subscribe(request)) - .await - .expect("bounded subscribe") - .expect("subscription"); - let SubscriptionNext::Event(observed) = - tokio::time::timeout(Duration::from_secs(5), subscription.next()) - .await - .expect("bounded event") - .expect("event") - else { - panic!("event expected"); - }; - assert_eq!(observed.observed().event().id_str(), expected_id); - assert_eq!( - subscription.cancel().await.expect("cancel").reason(), - SubscriptionEndReason::Cancelled - ); - tokio::time::timeout(Duration::from_secs(5), server) - .await - .expect("server deadline") - .expect("relay task"); -} - -#[tokio::test(flavor = "multi_thread", worker_threads = 2)] -async fn shutdown_disconnects_the_shared_live_pool_and_refuses_new_effects() { - use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind}; - use radroots_transport::{ - DeliveryRequest, EventSink, - policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, - sink::DeliveryPayload, - }; - - let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); - let relay_url = format!("ws://{}", listener.local_addr().unwrap()); - let mut server = tokio::spawn(async move { - let (stream, _) = listener.accept().await.unwrap(); - let mut socket = accept_async(stream).await.unwrap(); - while let Some(message) = socket.next().await { - match message { - Ok(Message::Text(message)) => { - let value: Value = serde_json::from_str(&message).unwrap(); - if value[0] == "REQ" { - socket - .send(Message::Text( - serde_json::to_string(&("EOSE", &value[1])).unwrap().into(), - )) - .await - .unwrap(); - } - } - Ok(Message::Close(_)) | Err(_) => return listener, - _ => {} - } - } - listener - }); - let profile = RelayProfile::explicit( - RelayProfileKind::Simulator, - [RelayEndpoint::new(&relay_url, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap()], - ) - .unwrap(); - let config = Config::from_profile(profile) - .with_timeouts(1000, 2000, 500) - .unwrap(); - let relay = config.relays()[0].clone(); - let targets = TargetSet::new(vec![relay.to_target().unwrap()]).unwrap(); - let fetch = FetchRequest::new( - "shutdown-fetch", - targets.clone(), - FetchBounds::new(1, unix_time_ms() + 5000).unwrap(), - ) - .unwrap(); - let subscription = SubscriptionRequest::new( - "shutdown-subscription", - targets.clone(), - SubscriptionBounds::new(1, unix_time_ms() + 5000).unwrap(), - ) - .unwrap(); - let event = EventBuilder::new(Kind::TextNote, "synthetic shutdown fixture") - .finalize(&Keys::parse(FIXTURE_SECRET_KEY).unwrap()) - .unwrap(); - let delivery = DeliveryRequest::new( - "shutdown-delivery", - DeliveryPayload::new(radroots_event_codec::decode::signed_event(&event.as_json()).unwrap()), - targets, - SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), - unix_time_ms() + 5000, - ) - .unwrap(); - let transport = NostrTransport::new(config); - let prepared = transport.prepare_delivery(delivery.clone()).unwrap(); - transport - .begin_authentication(&relay, "shutdown challenge", 1000, 2000) - .unwrap(); - let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(fetch.clone())) - .await - .unwrap() - .unwrap(); - assert_eq!( - page.target_outcomes()[0].state(), - FetchTargetState::Complete - ); - - let mut live = transport.subscribe(subscription.clone()).await.unwrap(); - assert!( - !server.is_finished(), - "the pool must still own a live socket before shutdown" - ); - - drop(transport.shutdown()); - assert!(EventSource::status(&transport).await.is_ok()); - let clone = transport.clone(); - clone.shutdown().await; - transport.shutdown().await; - let joined = tokio::time::timeout(Duration::from_secs(2), &mut server).await; - if joined.is_err() { - server.abort(); - let _ = server.await; - panic!("shutdown did not terminate the live loopback socket"); - } - let listener = joined.unwrap().unwrap(); - let ended = tokio::time::timeout(Duration::from_secs(2), live.next()) - .await - .unwrap() - .unwrap(); - assert!( - matches!(ended, SubscriptionNext::End(ref end) if end.reason() == SubscriptionEndReason::SourceClosed) - ); - assert_eq!( - transport.fetch(fetch).await.unwrap_err(), - radroots_transport::Error::TransportClosed - ); - assert!(matches!( - transport.subscribe(subscription).await, - Err(radroots_transport::Error::TransportClosed) - )); - assert_eq!( - EventSource::status(&clone).await.unwrap_err(), - radroots_transport::Error::TransportClosed - ); - assert_eq!( - EventSink::status(&clone).await.unwrap_err(), - radroots_transport::Error::TransportClosed - ); - assert_eq!( - transport - .begin_authentication(&relay, "new challenge", 1000, 2000) - .unwrap_err(), - radroots_transport_nostr::Error::TransportClosed - ); - assert_eq!( - transport - .complete_authentication(&relay, "shutdown challenge", None, 1500) - .await - .unwrap_err(), - radroots_transport_nostr::Error::TransportClosed - ); - assert_eq!( - transport - .reject_authentication(&relay, "shutdown challenge") - .unwrap_err(), - radroots_transport_nostr::Error::TransportClosed - ); - for failure in [ - transport - .execute_prepared_delivery(prepared) - .await - .unwrap_err(), - transport.deliver(delivery.clone()).await.unwrap_err(), - transport - .deliver_selected(delivery.clone(), delivery.target_set().clone()) - .await - .unwrap_err(), - ] { - assert_eq!(failure.code(), "transport_closed"); - failure.validate_for_request(&delivery).unwrap(); - assert_eq!( - failure.partial_evidence().len(), - delivery.target_set().len() - ); - assert!( - failure - .partial_evidence() - .iter() - .all(|row| !row.was_attempted()) - ); - } - assert!( - tokio::time::timeout(Duration::from_millis(150), listener.accept()) - .await - .is_err() - ); -} - -fn unix_time_ms() -> u64 { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .map(|duration| u64::try_from(duration.as_millis()).unwrap_or(u64::MAX)) - .unwrap_or_default() -} diff --git a/crates/transport_nostr/tests/network_hardening.rs b/crates/transport_nostr/tests/network_hardening.rs @@ -10,25 +10,35 @@ const CLIENT_SOURCE: &str = include_str!("../src/client.rs"); #[test] fn tls_verification_and_pinned_dns_are_non_configurable_live_defaults() { assert!(WORKSPACE_MANIFEST.contains("rustls-tls-webpki-roots")); + let socket = include_str!("../src/session_socket.rs"); + let native = include_str!("../../transport_nostr_native/src/connector.rs"); for required in [ "client_async_with_config(", - "tokio_rustls::TlsConnector::from(Arc::new(tls_config))", "roots.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned())", ".with_no_client_auth()", - "rustls::pki_types::ServerName::try_from(", - "host.trim_matches(['[', ']']).to_owned()", - "crate::source_wire::MeteredIo::new(plaintext, ingress)", - ".max_message_size(Some(MAX_WIRE_MESSAGE_BYTES))", - ".max_frame_size(Some(MAX_WIRE_MESSAGE_BYTES))", - "validate_resolved_addresses(", - "connect_pinned(addresses.as_slice())", - "if proxy.is_some()", + "rustls::pki_types::ServerName::try_from(host.to_owned())", + "MeteredIo::new(plaintext, metering, max_message_bytes.get())", + ".max_message_size(Some(max_message_bytes.get()))", + ".max_frame_size(Some(max_message_bytes.get()))", + "admission.permits_address(address.ip())", + "connect_pinned(&addresses)", ] { assert!( - RELAY_SOURCE.contains(required), - "missing hardening witness `{required}`" + native.contains(required), + "missing native policy witness `{required}`" ); } + assert!(socket.contains("if proxy.is_some()")); + for forbidden in [ + "tokio::net::", + "tokio_tungstenite", + "TlsConnector", + "lookup_host", + "MeteredIo", + ] { + assert!(!RELAY_SOURCE.contains(forbidden)); + assert!(!socket.contains(forbidden)); + } for forbidden in [ "danger_accept_invalid_certs", "danger_accept_invalid_hostnames", @@ -36,6 +46,7 @@ fn tls_verification_and_pinned_dns_are_non_configurable_live_defaults() { ] { assert!(!RELAY_SOURCE.contains(forbidden)); assert!(!CLIENT_SOURCE.contains(forbidden)); + assert!(!native.contains(forbidden)); } assert!(RelayUrl::parse("ws://relay.example.com", RelayUrlPolicy::Public).is_err()); diff --git a/crates/transport_nostr/tests/package_boundary.rs b/crates/transport_nostr/tests/package_boundary.rs @@ -52,7 +52,8 @@ fn manifest_and_root_match_the_governed_transport_boundary() { "socket_write", "source", "source_ingress", - "source_wire", + "session_socket", + "test_host", "status", "subscription" ]) @@ -109,7 +110,7 @@ fn documentation_example_and_reviewed_api_baseline_are_complete() { "Config::from_profile(", "RelayEndpoint::new(", "RelayProfile::explicit(", - "NostrTransport::new(config)", + "NostrTransport::new(config, host)", "let source: &dyn EventSource", "let subscriber: &dyn EventSubscriber", "let sink: &dyn EventSink", @@ -337,8 +338,9 @@ fn adapter_owns_no_storage_outbox_or_orchestration_surface() { "source_ingress.rs".to_owned(), "source_paging_tests.rs".to_owned(), "source_window.rs".to_owned(), - "source_wire.rs".to_owned(), - "source_wire_tests.rs".to_owned(), + "session_socket.rs".to_owned(), + "session_socket_tests.rs".to_owned(), + "test_host.rs".to_owned(), "status.rs".to_owned(), "subscription.rs".to_owned(), ]) diff --git a/crates/transport_nostr_native/Cargo.toml b/crates/transport_nostr_native/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "radroots_transport_nostr_native" -publish = false +publish = ["crates-io"] version = "0.1.0-alpha" edition.workspace = true rust-version.workspace = true @@ -10,6 +10,9 @@ repository.workspace = true homepage.workspace = true description = "Native socket ownership for the shared Radroots Nostr session" readme = "README.md" +documentation = "https://docs.rs/radroots_transport_nostr_native" +keywords = ["radroots", "nostr", "transport", "websocket"] +categories = ["asynchronous", "network-programming"] [dependencies] radroots_transport = { workspace = true, features = ["std"] } @@ -23,6 +26,9 @@ url = { workspace = true } webpki-roots = { workspace = true } [dev-dependencies] +radroots_event_codec = { workspace = true } +nostr-sdk = { workspace = true } +serde_json = { workspace = true, features = ["std"] } tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] } [lints] diff --git a/crates/transport_nostr_native/README.md b/crates/transport_nostr_native/README.md @@ -5,5 +5,7 @@ metering for the shared Radroots Nostr session. The host exchanges owned frames through `radroots_transport::host::websocket`; it owns no protocol relay pool, signer, storage, outbox, retries or application executor. -This package begins private while its concrete I/O boundary is verified. The -shared session's ordinary client has not switched to this provider yet. +`create_transport` composes the existing shared protocol session with this +provider. Construction is inert. The caller supplies an explicit validated +profile and a Tokio executor; the package creates neither a runtime nor a +second relay pool. Browser hosts use their separately governed provider. diff --git a/crates/transport_nostr_native/src/lib.rs b/crates/transport_nostr_native/src/lib.rs @@ -7,3 +7,11 @@ mod socket; mod wire; pub use connector::NativeConnector; + +/// Composes the shared Nostr session with the native socket provider. +/// Construction opens no socket and creates no runtime or worker. +pub fn create_transport( + config: radroots_transport_nostr::Config, +) -> radroots_transport_nostr::NostrTransport { + radroots_transport_nostr::NostrTransport::new(config, std::sync::Arc::new(NativeConnector)) +} diff --git a/crates/transport_nostr_native/src/wire_tests.rs b/crates/transport_nostr_native/src/wire_tests.rs @@ -1,5 +1,5 @@ use super::*; -use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; const UPGRADE: &[u8] = b"HTTP/1.1 101 Switching Protocols\r\n\r\n"; const MAX_MESSAGE_BYTES: usize = 512 * 1024; @@ -119,6 +119,11 @@ fn eof_rejects_partial_upgrade_header_and_payload() { struct Authority { open: AtomicBool, charge: AtomicBool, + bytes: AtomicUsize, + frames: AtomicUsize, + data: AtomicUsize, + byte_limit: AtomicUsize, + data_limit: AtomicUsize, } impl Admission for Authority { @@ -131,8 +136,13 @@ impl Admission for Authority { fn admitted_write(&self, _: &Context<'_>) -> bool { self.open.load(Ordering::SeqCst) } - fn charge(&self, _: usize, _: usize, _: usize) -> bool { + fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool { + let bytes = self.bytes.fetch_add(bytes, Ordering::SeqCst) + bytes; + self.frames.fetch_add(frames, Ordering::SeqCst); + let data = self.data.fetch_add(data, Ordering::SeqCst) + data; self.charge.load(Ordering::SeqCst) + && bytes <= self.byte_limit.load(Ordering::SeqCst) + && data <= self.data_limit.load(Ordering::SeqCst) } } @@ -190,6 +200,11 @@ fn metered(bytes: Vec<u8>) -> (MeteredIo<ControlledIo>, Arc<Authority>) { let authority = Arc::new(Authority { open: AtomicBool::new(true), charge: AtomicBool::new(true), + bytes: AtomicUsize::new(0), + frames: AtomicUsize::new(0), + data: AtomicUsize::new(0), + byte_limit: AtomicUsize::new(usize::MAX), + data_limit: AtomicUsize::new(usize::MAX), }); let inner = ControlledIo { bytes, @@ -334,3 +349,49 @@ fn truncated_payload_eof_is_terminal_at_the_meter_boundary() { )); assert_eq!(meter.inner.reads, 2); } + +#[test] +fn raw_upgrade_and_frame_overhead_are_charged_before_any_message_decode() { + let mut bytes = UPGRADE.to_vec(); + bytes.extend([0x81, 0]); + let length = bytes.len(); + let (mut meter, authority) = metered(bytes); + authority.byte_limit.store(length, Ordering::SeqCst); + assert!( + matches!(read_meter(&mut meter, 4096), (Poll::Ready(Ok(())), count) if count == length) + ); + assert_eq!(authority.bytes.load(Ordering::SeqCst), length); + assert_eq!(authority.frames.load(Ordering::SeqCst), 1); + assert_eq!(authority.data.load(Ordering::SeqCst), 1); + meter.inner.bytes.extend([0x81, 0]); + assert!(matches!( + read_meter(&mut meter, 4096), + (Poll::Ready(Err(_)), 0) + )); + assert!(meter.failed); +} + +#[test] +fn empty_data_frames_exhaust_the_original_attempt_allowance_before_decode() { + let mut bytes = UPGRADE.to_vec(); + for _ in 0..4097 { + bytes.extend([0x81, 0]); + } + let (mut meter, authority) = metered(bytes); + authority.data_limit.store(4096, Ordering::SeqCst); + loop { + match read_meter(&mut meter, 4096) { + (Poll::Ready(Ok(())), count) => assert!(count > 0), + (Poll::Ready(Err(_)), 0) => break, + other => panic!("unexpected read: {other:?}"), + } + } + assert_eq!(authority.data.load(Ordering::SeqCst), 4097); + assert_eq!(authority.frames.load(Ordering::SeqCst), 4097); + let reads = meter.inner.reads; + assert!(matches!( + read_meter(&mut meter, 4096), + (Poll::Ready(Err(_)), 0) + )); + assert_eq!(meter.inner.reads, reads); +} diff --git a/crates/transport_nostr_native/tests/exact_delivery.rs b/crates/transport_nostr_native/tests/exact_delivery.rs @@ -0,0 +1,543 @@ +use futures::{FutureExt, SinkExt, StreamExt}; +use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Tag, Timestamp}; +use radroots_transport::{ + DeliveryRequest, EventSink, EventSource, FetchRequest, TargetSet, + policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, + sink::DeliveryPayload, + source::FetchBounds, +}; +use radroots_transport_nostr::{ + Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, +}; +use serde_json::{Value, json}; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; +use tokio::net::{TcpListener, TcpStream}; +use tokio_tungstenite::{WebSocketStream, accept_async, tungstenite::Message}; + +const KEY: &str = "0000000000000000000000000000000000000000000000000000000000000001"; + +fn now() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_millis() + .try_into() + .unwrap() +} + +fn raw_event() -> String { + let event = EventBuilder::new(Kind::TextNote, "harvest café\n🌱") + .custom_created_at(Timestamp::from_secs(1_800_000_000)) + .finalize(&Keys::parse(KEY).unwrap()) + .unwrap(); + let mut value: Value = serde_json::from_str(&event.as_json()).unwrap(); + value["extension"] = json!({"retained": true}); + format!(" \n{} \t", serde_json::to_string_pretty(&value).unwrap()) +} + +fn config(url: &str, timeout: u64) -> Config { + Config::from_profile( + RelayProfile::explicit( + RelayProfileKind::Simulator, + [RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap()], + ) + .unwrap(), + ) + .with_timeouts(1_000, timeout, 500) + .unwrap() +} + +fn targets(config: &Config) -> TargetSet { + TargetSet::new( + config + .relays() + .iter() + .map(|relay| relay.to_target().unwrap()) + .collect(), + ) + .unwrap() +} + +fn request(config: &Config, raw: &str) -> DeliveryRequest { + DeliveryRequest::new( + "exact-wire", + DeliveryPayload::new(radroots_event_codec::decode::signed_event(raw).unwrap()), + targets(config), + SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), + now() + 5_000, + ) + .unwrap() +} + +async fn text(socket: &mut WebSocketStream<TcpStream>) -> String { + tokio::time::timeout(Duration::from_secs(5), async { + loop { + if let Message::Text(text) = socket.next().await.unwrap().unwrap() { + return text.to_string(); + } + } + }) + .await + .unwrap() +} + +async fn reply(socket: &mut WebSocketStream<TcpStream>, value: Value) { + socket + .send(Message::Text(value.to_string().into())) + .await + .unwrap(); +} + +#[tokio::test] +async fn selected_delivery_never_connects_to_held_target_and_preserves_full_request() { + let a = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let b = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let config = Config::from_profile( + RelayProfile::explicit( + RelayProfileKind::Simulator, + [a.local_addr().unwrap(), b.local_addr().unwrap()].map(|address| { + RelayEndpoint::new( + format!("ws://{address}"), + RelayUrlPolicy::Local, + RelayAccess::ReadWrite, + ) + .unwrap() + }), + ) + .unwrap(), + ) + .with_timeouts(1_000, 2_000, 500) + .unwrap(); + let raw = raw_event(); + let expected = format!("[\"EVENT\",{raw}]"); + let server = tokio::spawn(async move { + let (tcp, _) = a.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let wire = text(&mut socket).await; + assert_eq!(wire, expected); + let event: Value = serde_json::from_str(&wire).unwrap(); + reply(&mut socket, json!(["OK", event[1]["id"], true, ""])).await; + }); + let transport = radroots_transport_nostr_native::create_transport(config.clone()); + let request = request(&config, &raw); + let selected = TargetSet::new(vec![request.target_set().targets()[0].clone()]).unwrap(); + let result = transport + .deliver_selected(request.clone(), selected) + .await + .unwrap(); + result.validate_for_request(&request).unwrap(); + assert!(result.target_receipts()[0].was_attempted()); + assert!( + result.target_receipts()[0] + .outcome() + .satisfies(SatisfactionClass::Accepted) + ); + assert!(!result.target_receipts()[1].was_attempted()); + assert_eq!( + result.target_receipts()[1].outcome().code(), + Some("target_not_selected") + ); + assert!(!result.is_satisfied(&request).unwrap()); + server.await.unwrap(); + assert!( + tokio::time::timeout(Duration::from_millis(150), b.accept()) + .await + .is_err() + ); +} + +#[tokio::test] +async fn exact_signed_bytes_read_requests_and_auth_use_the_same_connection() { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); + let raw = raw_event(); + let expected = format!("[\"EVENT\",{raw}]"); + let (auth_sent, auth_seen) = tokio::sync::oneshot::channel(); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let req: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); + assert_eq!(req[0], "REQ"); + reply(&mut socket, json!(["EOSE", req[1]])).await; + loop { + let message: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); + if message[0] == "AUTH" { + assert_eq!(message[1]["kind"], 22242); + auth_sent.send(()).unwrap(); + break; + } + assert_eq!(message[0], "CLOSE"); + } + let wire = text(&mut socket).await; + assert_eq!(wire, expected); + let event: Value = serde_json::from_str(&wire).unwrap(); + reply( + &mut socket, + json!(["OK", "11".repeat(32), true, "unrelated event"]), + ) + .await; + reply(&mut socket, json!(["OK", event[1]["id"], true, ""])).await; + }); + let transport = radroots_transport_nostr_native::create_transport(config.clone()); + let page = transport + .fetch( + FetchRequest::new( + "same-socket-read", + targets(&config), + FetchBounds::new(1, now() + 5_000).unwrap(), + ) + .unwrap(), + ) + .await + .unwrap(); + assert!(page.events().is_empty()); + let relay = &config.relays()[0]; + let at = now() / 1_000 * 1_000; + transport + .begin_authentication(relay, "challenge", at, at + 5_000) + .unwrap(); + let auth = EventBuilder::new(Kind::Authentication, "") + .tags([ + Tag::parse(["relay", relay.as_str()]).unwrap(), + Tag::parse(["challenge", "challenge"]).unwrap(), + ]) + .custom_created_at(Timestamp::from_secs(at / 1_000)) + .finalize(&Keys::parse(KEY).unwrap()) + .unwrap(); + transport + .complete_authentication(relay, "challenge", Some(&auth.as_json()), at) + .await + .unwrap(); + tokio::time::timeout(Duration::from_secs(5), auth_seen) + .await + .unwrap() + .unwrap(); + let receipt = transport.deliver(request(&config, &raw)).await.unwrap(); + assert!( + receipt.target_receipts()[0] + .outcome() + .satisfies(SatisfactionClass::Accepted) + ); + server.await.unwrap(); +} + +#[tokio::test] +async fn an_overlong_ack_identifier_never_accepts_the_matching_prefix() { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 250); + let raw = raw_event(); + let (done, wait) = tokio::sync::oneshot::channel(); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); + let overlong = format!("{}00", event[1]["id"].as_str().unwrap()); + reply(&mut socket, json!(["OK", overlong, true, ""])).await; + wait.await.unwrap(); + }); + let request = request(&config, &raw); + let receipt = tokio::time::timeout( + Duration::from_secs(5), + radroots_transport_nostr_native::create_transport(config).deliver(request.clone()), + ) + .await + .unwrap() + .unwrap(); + done.send(()).unwrap(); + server.await.unwrap(); + assert!(!receipt.is_satisfied(&request).unwrap()); +} + +#[tokio::test] +async fn binary_acknowledgements_never_invent_acceptance_for_exact_or_overlong_ids() { + for canonical in [true, false] { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 250); + let raw = raw_event(); + let (done, wait) = tokio::sync::oneshot::channel(); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); + let id = event[1]["id"].as_str().unwrap(); + let id = if canonical { + id.to_owned() + } else { + format!("{id}00") + }; + socket + .send(Message::Binary( + json!(["OK", id, true, ""]).to_string().into_bytes().into(), + )) + .await + .unwrap(); + wait.await.unwrap(); + }); + let request = request(&config, &raw); + let transport = radroots_transport_nostr_native::create_transport(config); + let receipt = + tokio::time::timeout(Duration::from_secs(5), transport.deliver(request.clone())) + .await + .unwrap() + .unwrap(); + done.send(()).unwrap(); + server.await.unwrap(); + transport.shutdown().await; + assert!(!receipt.is_satisfied(&request).unwrap()); + } +} + +#[tokio::test] +async fn relay_challenge_never_creates_an_implicit_authentication_response() { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); + let raw = raw_event(); + let expected = format!("[\"EVENT\",{raw}]"); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let wire = text(&mut socket).await; + assert_eq!(wire, expected); + let event: Value = serde_json::from_str(&wire).unwrap(); + reply(&mut socket, json!(["AUTH", "explicit-signer-required"])).await; + assert!( + tokio::time::timeout(Duration::from_millis(100), text(&mut socket)) + .await + .is_err() + ); + reply(&mut socket, json!(["OK", event[1]["id"], true, ""])).await; + }); + let transport = radroots_transport_nostr_native::create_transport(config.clone()); + let request = request(&config, &raw); + let receipt = tokio::time::timeout(Duration::from_secs(5), transport.deliver(request.clone())) + .await + .unwrap() + .unwrap(); + server.await.unwrap(); + assert!(receipt.is_satisfied(&request).unwrap()); +} + +#[tokio::test] +async fn rejection_lost_ack_and_disconnect_never_invent_acceptance() { + for mode in ["reject", "lost", "disconnect"] { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 250); + let raw = raw_event(); + let expected = format!("[\"EVENT\",{raw}]"); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let wire = text(&mut socket).await; + assert_eq!(wire, expected); + let event: Value = serde_json::from_str(&wire).unwrap(); + match mode { + "reject" => { + reply( + &mut socket, + json!(["OK", event[1]["id"], false, "blocked: fixture"]), + ) + .await + } + "lost" => { + reply( + &mut socket, + json!(["OK", "22".repeat(32), true, "wrong ID"]), + ) + .await; + tokio::time::sleep(Duration::from_millis(500)).await; + } + "disconnect" => socket.close(None).await.unwrap(), + _ => unreachable!(), + } + }); + let receipt = radroots_transport_nostr_native::create_transport(config.clone()) + .deliver(request(&config, &raw)) + .await + .unwrap(); + assert!( + !receipt.target_receipts()[0] + .outcome() + .satisfies(SatisfactionClass::Accepted), + "{mode}" + ); + assert!(receipt.target_receipts()[0].was_attempted()); + server.await.unwrap(); + } +} + +#[tokio::test] +async fn matching_negative_ack_never_accepts_duplicate_text() { + for message in [ + "blocked: not a duplicate; event was rejected", + "duplicate: already have this event", + "already have this event", + "error: duplicate detector unavailable", + "auth-required: duplicate path requires login", + "rate-limited: duplicate retries", + "invalid: duplicate event format", + ] { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); + let raw = raw_event(); + let expected = format!("[\"EVENT\",{raw}]"); + let (done, wait) = tokio::sync::oneshot::channel(); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let wire = text(&mut socket).await; + assert_eq!(wire, expected); + let event: Value = serde_json::from_str(&wire).unwrap(); + reply(&mut socket, json!(["OK", event[1]["id"], false, message])).await; + tokio::time::timeout(Duration::from_secs(5), wait) + .await + .unwrap() + .unwrap(); + }); + let transport = radroots_transport_nostr_native::create_transport(config.clone()); + let request = request(&config, &raw); + let receipt = + tokio::time::timeout(Duration::from_secs(5), transport.deliver(request.clone())) + .await + .unwrap() + .unwrap(); + done.send(()).unwrap(); + server.await.unwrap(); + receipt.validate_for_request(&request).unwrap(); + assert!(receipt.target_receipts()[0].was_attempted()); + assert!(!receipt.is_satisfied(&request).unwrap(), "{message}"); + assert!( + !receipt.target_receipts()[0] + .outcome() + .satisfies(SatisfactionClass::Accepted), + "{message}" + ); + } +} + +#[tokio::test] +async fn matching_positive_ack_accepts_existing_duplicate_and_empty_messages() { + for message in ["", "duplicate: already have this event"] { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); + let raw = raw_event(); + let (done, wait) = tokio::sync::oneshot::channel(); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); + assert_eq!(event[0], "EVENT"); + reply(&mut socket, json!(["OK", event[1]["id"], true, message])).await; + tokio::time::timeout(Duration::from_secs(5), wait) + .await + .unwrap() + .unwrap(); + }); + let request = request(&config, &raw); + let receipt = tokio::time::timeout( + Duration::from_secs(5), + radroots_transport_nostr_native::create_transport(config).deliver(request.clone()), + ) + .await + .unwrap() + .unwrap(); + done.send(()).unwrap(); + server.await.unwrap(); + receipt.validate_for_request(&request).unwrap(); + assert!(receipt.is_satisfied(&request).unwrap(), "{message}"); + } +} + +#[tokio::test] +async fn quota_refusal_is_terminal_and_redacted_at_the_receipt_boundary() { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let config = config(&format!("ws://{}", listener.local_addr().unwrap()), 2_000); + let server = tokio::spawn(async move { + let (tcp, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let event: Value = serde_json::from_str(&text(&mut socket).await).unwrap(); + reply( + &mut socket, + json!([ + "OK", + event[1]["id"], + false, + "quota exceeded: private-account-detail" + ]), + ) + .await; + }); + let transport = radroots_transport_nostr_native::create_transport(config.clone()); + let receipt = transport + .deliver(request(&config, &raw_event())) + .await + .unwrap(); + let target = &receipt.target_receipts()[0]; + assert!(target.was_attempted()); + assert_eq!(target.outcome().code(), Some("quota_exceeded")); + assert_eq!( + target.outcome().retryability(), + radroots_transport::outcome::Retryability::Terminal + ); + assert_eq!( + target.outcome().kind(), + radroots_transport::outcome::DeliveryOutcomeKind::Rejected + ); + assert_eq!( + target.outcome().message(), + Some("relay quota was exhausted") + ); + assert_eq!( + transport.relay_status().relays()[0] + .write() + .last_failure_retryable(), + Some(false) + ); + server.await.unwrap(); +} + +#[tokio::test] +async fn queued_delivery_targets_cannot_start_after_the_shared_deadline() { + let first = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let second = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let endpoints = [&first, &second].map(|listener| { + RelayEndpoint::new( + format!("ws://{}", listener.local_addr().unwrap()), + RelayUrlPolicy::Local, + RelayAccess::ReadWrite, + ) + .unwrap() + }); + let config = Config::from_profile( + RelayProfile::explicit(RelayProfileKind::Simulator, endpoints).unwrap(), + ) + .with_timeouts(1_000, 250, 500) + .unwrap() + .with_max_connections(1) + .unwrap(); + let server = tokio::spawn(async move { + let (tcp, _) = first.accept().await.unwrap(); + let mut socket = accept_async(tcp).await.unwrap(); + let _published = text(&mut socket).await; + futures::future::pending::<()>().await; + }); + let transport = radroots_transport_nostr_native::create_transport(config.clone()); + let receipt = transport + .deliver(request(&config, &raw_event())) + .await + .unwrap(); + assert_eq!(receipt.target_receipts().len(), 2); + assert!( + receipt + .target_receipts() + .iter() + .all(|target| !target.outcome().satisfies(SatisfactionClass::Accepted)) + ); + assert!(second.accept().now_or_never().is_none()); + assert!(receipt.target_receipts()[0].was_attempted()); + assert!( + !receipt.target_receipts()[1].was_attempted(), + "a target expired while queued never entered remote publication" + ); + server.abort(); + assert!(server.await.unwrap_err().is_cancelled()); +} diff --git a/crates/transport_nostr_native/tests/fetch_bounds.rs b/crates/transport_nostr_native/tests/fetch_bounds.rs @@ -0,0 +1,348 @@ +use futures::{SinkExt, StreamExt}; +use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind}; +use radroots_transport::{ + EventSource, FetchRequest, TargetSet, outcome::FetchTargetState, source::FetchBounds, +}; +use radroots_transport_nostr::{ + Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, + RelayUrlPolicy, +}; +use serde_json::Value; +use std::{ + sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }, + time::{Duration, SystemTime, UNIX_EPOCH}, +}; +use tokio::{net::TcpListener, sync::oneshot}; +use tokio_tungstenite::{accept_async, tungstenite::Message}; + +fn transport(urls: &[String], connections: usize) -> (NostrTransport, FetchRequest) { + let endpoints = urls + .iter() + .map(|url| RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap()); + let profile = RelayProfile::explicit(RelayProfileKind::Simulator, endpoints).unwrap(); + let config = Config::from_profile(profile) + .with_timeouts(1000, 1000, 500) + .unwrap() + .with_max_connections(connections) + .unwrap(); + let targets = TargetSet::new( + config + .read_relays() + .map(|relay| relay.to_target().unwrap()) + .collect(), + ) + .unwrap(); + let now = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_millis() as u64; + let request = FetchRequest::new( + "bounded-loopback", + targets, + FetchBounds::new(10, now + 5000).unwrap(), + ) + .unwrap(); + ( + radroots_transport_nostr_native::create_transport(config), + request, + ) +} + +async fn listener() -> (TcpListener, String) { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("ws://{}", listener.local_addr().unwrap()); + (listener, url) +} + +fn event(content: &str) -> Value { + let keys = + Keys::parse("0000000000000000000000000000000000000000000000000000000000000001").unwrap(); + let event = EventBuilder::new(Kind::TextNote, content) + .finalize(&keys) + .unwrap(); + serde_json::from_str(&event.as_json()).unwrap() +} + +async fn serve( + listener: TcpListener, + payload: Option<Value>, + eose: bool, + requests: Arc<AtomicUsize>, +) { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + while let Some(message) = socket.next().await { + let Ok(Message::Text(message)) = message else { + continue; + }; + let values: Value = serde_json::from_str(&message).unwrap(); + if values[0] != "REQ" { + continue; + } + requests.fetch_add(1, Ordering::SeqCst); + if let Some(payload) = &payload { + socket + .send(Message::Text( + serde_json::to_string(&("EVENT", &values[1], payload)) + .unwrap() + .into(), + )) + .await + .unwrap(); + } + if eose { + socket + .send(Message::Text( + serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), + )) + .await + .unwrap(); + } + std::future::pending::<()>().await; + } +} + +#[tokio::test(flavor = "multi_thread")] +async fn a_cached_event_id_never_admits_a_changed_signature() { + let (listener, url) = listener().await; + let valid = event("cached signature admission"); + let mut changed = valid.clone(); + changed["sig"] = Value::String("0".repeat(128)); + let (release, released) = oneshot::channel(); + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + for payload in [valid, changed, event("valid continuation after rejection")] { + loop { + let message = socket.next().await.unwrap().unwrap(); + let Message::Text(text) = message else { + socket.flush().await.unwrap(); + continue; + }; + let values: Value = serde_json::from_str(&text).unwrap(); + if values[0] != "REQ" { + continue; + } + socket + .send(Message::Text( + serde_json::to_string(&("EVENT", &values[1], &payload)) + .unwrap() + .into(), + )) + .await + .unwrap(); + socket + .send(Message::Text( + serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), + )) + .await + .unwrap(); + break; + } + } + released.await.unwrap(); + }); + let (transport, request) = transport(&[url], 1); + let pages = tokio::time::timeout(Duration::from_secs(5), async { + let first = transport.fetch(request.clone()).await.unwrap(); + let repeated = transport.fetch(request.clone()).await.unwrap(); + let continuation = transport.fetch(request).await.unwrap(); + (first, repeated, continuation) + }) + .await + .unwrap(); + release.send(()).unwrap(); + server.await.unwrap(); + assert_eq!(pages.0.events().len(), 1); + assert!( + pages.1.events().is_empty(), + "changed signature reached fetch output" + ); + assert_eq!(pages.2.events().len(), 1); + assert!( + [&pages.0, &pages.1, &pages.2] + .into_iter() + .all(|page| page.target_outcomes()[0].state() == FetchTargetState::Complete) + ); +} + +#[tokio::test(flavor = "multi_thread")] +async fn overlong_event_identifiers_never_become_normalized_fetch_results() { + for field in ["id", "pubkey", "sig"] { + let (listener, url) = listener().await; + let mut payload = event("strict wire identifiers"); + payload[field] = Value::String(format!("{}00", payload[field].as_str().unwrap())); + let calls = Arc::new(AtomicUsize::new(0)); + let server = tokio::spawn(serve(listener, Some(payload), true, Arc::clone(&calls))); + let (transport, request) = transport(&[url], 1); + let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) + .await + .unwrap() + .unwrap(); + server.abort(); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert!(page.events().is_empty(), "{field}"); + assert_ne!( + page.target_outcomes()[0].state(), + FetchTargetState::Complete, + "{field}" + ); + } +} + +#[tokio::test(flavor = "multi_thread")] +async fn queued_relays_do_not_receive_a_fresh_timeout_after_a_stalled_relay() { + let (first, first_url) = listener().await; + let (second, second_url) = listener().await; + // Adapter scheduling is canonical URL order, independent of profile order. + let mut relays = [(first_url, first), (second_url, second)]; + relays.sort_by(|left, right| left.0.cmp(&right.0)); + let [(first_url, first), (second_url, second)] = relays; + let first_requests = Arc::new(AtomicUsize::new(0)); + let second_requests = Arc::new(AtomicUsize::new(0)); + let first_task = tokio::spawn(serve(first, None, false, Arc::clone(&first_requests))); + let second_task = tokio::spawn(serve(second, None, true, Arc::clone(&second_requests))); + let (transport, request) = transport(&[first_url, second_url], 1); + let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) + .await + .unwrap() + .unwrap(); + first_task.abort(); + second_task.abort(); + assert_eq!(first_requests.load(Ordering::SeqCst), 1); + assert_eq!(second_requests.load(Ordering::SeqCst), 0); + assert_eq!(page.target_outcomes().len(), 2); + assert!( + page.target_outcomes() + .iter() + .all(|outcome| outcome.state() == FetchTargetState::Cancelled) + ); +} + +#[tokio::test(flavor = "multi_thread")] +async fn a_slow_relay_preserves_the_other_relays_completed_evidence_and_collected_events() { + let (good, good_url) = listener().await; + let (slow, slow_url) = listener().await; + let good_event = event("complete relay"); + let slow_event = event("partial relay"); + let expected = [ + good_event["id"].as_str().unwrap().to_owned(), + slow_event["id"].as_str().unwrap().to_owned(), + ]; + let calls = Arc::new(AtomicUsize::new(0)); + let good_task = tokio::spawn(serve(good, Some(good_event), true, Arc::clone(&calls))); + let slow_task = tokio::spawn(serve(slow, Some(slow_event), false, Arc::clone(&calls))); + let (transport, request) = transport(&[good_url, slow_url], 2); + let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) + .await + .unwrap() + .unwrap(); + good_task.abort(); + slow_task.abort(); + assert_eq!(calls.load(Ordering::SeqCst), 2); + assert_eq!(page.events().len(), 2); + for id in expected { + assert!( + page.events() + .iter() + .any(|event| event.event().id_str() == id) + ); + } + assert_eq!( + page.target_outcomes() + .iter() + .filter(|outcome| outcome.state() == FetchTargetState::Complete) + .count(), + 1 + ); + assert_eq!( + page.target_outcomes() + .iter() + .filter(|outcome| outcome.state() == FetchTargetState::Cancelled) + .count(), + 1 + ); +} + +#[tokio::test(flavor = "multi_thread")] +async fn oversized_wire_messages_never_become_completed_fetch_evidence() { + let (listener, url) = listener().await; + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + while let Some(message) = socket.next().await { + let message = match message { + Ok(Message::Text(message)) => message, + Ok(Message::Close(_)) | Err(_) => return, + _ => continue, + }; + let values: Value = serde_json::from_str(&message).unwrap(); + if values[0] == "REQ" { + let _ = socket + .send(Message::Text( + serde_json::to_string(&("NOTICE", "x".repeat(512 * 1024))) + .unwrap() + .into(), + )) + .await; + } + } + }); + let (transport, request) = transport(&[url], 1); + let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) + .await + .unwrap() + .unwrap(); + tokio::time::timeout(Duration::from_secs(5), server) + .await + .unwrap() + .unwrap(); + assert!(page.events().is_empty()); + assert_eq!(page.target_outcomes().len(), 1); + assert_ne!( + page.target_outcomes()[0].state(), + FetchTargetState::Complete + ); +} + +#[tokio::test(flavor = "multi_thread")] +async fn dropping_a_polled_fetch_closes_the_subscription_or_connection() { + let (listener, url) = listener().await; + let (started, observed) = oneshot::channel(); + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + let mut started = Some(started); + while let Some(message) = socket.next().await { + let message = match message { + Ok(Message::Text(message)) => message, + Ok(Message::Close(_)) | Err(_) => return, + _ => continue, + }; + let values: Value = serde_json::from_str(&message).unwrap(); + if values[0] == "REQ" { + started.take().unwrap().send(()).unwrap(); + } else if values[0] == "CLOSE" { + return; + } + } + }); + let (transport, request) = transport(&[url], 1); + let mut fetch = Box::pin(transport.fetch(request)); + tokio::time::timeout(Duration::from_secs(5), async { + tokio::select! { + _ = &mut fetch => panic!("fetch completed before its relay response"), + result = observed => { result.unwrap(); } + } + }) + .await + .unwrap(); + drop(fetch); + tokio::time::timeout(Duration::from_secs(5), server) + .await + .unwrap() + .unwrap(); +} diff --git a/crates/transport_nostr_native/tests/fetch_raw_budget.rs b/crates/transport_nostr_native/tests/fetch_raw_budget.rs @@ -0,0 +1,302 @@ +use futures::{SinkExt, StreamExt}; +use radroots_transport::{ + EventSource, FetchRequest, TargetSet, outcome::FetchTargetState, source::FetchBounds, +}; +use radroots_transport_nostr::{ + Config, NostrTransport, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, + RelayUrlPolicy, +}; +use serde_json::Value; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; +use tokio::net::{TcpListener, TcpStream}; +use tokio_tungstenite::{WebSocketStream, accept_async, tungstenite::Message}; + +const WATCHDOG: Duration = Duration::from_secs(10); + +fn transport(urls: &[String]) -> (NostrTransport, FetchRequest) { + let profile = RelayProfile::explicit( + RelayProfileKind::Simulator, + urls.iter().map(|url| { + RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap() + }), + ) + .unwrap(); + let config = Config::from_profile(profile) + .with_timeouts(1000, 5000, 500) + .unwrap() + .with_max_connections(1) + .unwrap(); + let targets = TargetSet::new( + config + .read_relays() + .map(|relay| relay.to_target().unwrap()) + .collect(), + ) + .unwrap(); + let now = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_millis() as u64; + let request = FetchRequest::new( + "raw-budget-loopback", + targets, + FetchBounds::new(10, now + 5000).unwrap(), + ) + .unwrap(); + ( + radroots_transport_nostr_native::create_transport(config), + request, + ) +} + +async fn listener() -> (TcpListener, String) { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("ws://{}", listener.local_addr().unwrap()); + (listener, url) +} + +fn malformed_event() -> Value { + // Canonical primitive fields pass wire admission, while absent event + // fields still exercise malformed traffic in the aggregate ingress budget. + let value = serde_json::json!({ + "id": "00".repeat(32), + "pubkey": "11".repeat(32), + "sig": "22".repeat(64), + "invalid_event": "x".repeat(384 * 1024), + }); + assert!(serde_json::from_value::<nostr_sdk::prelude::Event>(value.clone()).is_err()); + value +} + +// A WebSocket pong is produced only after the client's receive stream has +// consumed all preceding messages. No scheduling sleep is an admission barrier. +async fn barrier(socket: &mut WebSocketStream<TcpStream>, sequence: usize) -> bool { + let marker = sequence.to_be_bytes().to_vec(); + if socket + .send(Message::Ping(marker.clone().into())) + .await + .is_err() + { + return false; + } + while let Some(message) = socket.next().await { + match message { + Ok(Message::Pong(value)) if value.as_ref() == marker.as_slice() => return true, + Ok(Message::Close(_)) | Err(_) => return false, + _ => { + if socket.flush().await.is_err() { + return false; + } + } + } + } + false +} + +async fn serve_malformed(listener: TcpListener, frames: usize) { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + while let Some(message) = socket.next().await { + let text = match message { + Ok(Message::Text(text)) => text, + Ok(Message::Close(_)) | Err(_) => return, + _ => { + let _ = socket.flush().await; + continue; + } + }; + let values: Value = serde_json::from_str(&text).unwrap(); + if values[0] != "REQ" { + continue; + } + let malformed = serde_json::to_string(&("EVENT", &values[1], malformed_event())).unwrap(); + assert!(malformed.len() < 512 * 1024); + for sequence in 0..frames { + if socket + .send(Message::Text(malformed.clone().into())) + .await + .is_err() + || !barrier(&mut socket, sequence).await + { + return; + } + } + if socket + .send(Message::Text( + serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), + )) + .await + .is_err() + { + return; + } + } +} + +async fn fetch_malformed(frames: usize) -> FetchTargetState { + let (listener, url) = listener().await; + let server = tokio::spawn(serve_malformed(listener, frames)); + let (transport, request) = transport(&[url]); + let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; + server.abort(); + let joined = server.await; + assert!(joined.is_ok() || joined.unwrap_err().is_cancelled()); + let page = result.unwrap().unwrap(); + assert!(page.events().is_empty()); + assert_eq!(page.target_outcomes().len(), 1); + page.target_outcomes()[0].state() +} + +#[tokio::test(flavor = "multi_thread")] +async fn empty_eose_remains_complete_with_raw_ingress_accounting() { + assert_eq!(fetch_malformed(0).await, FetchTargetState::Complete); +} + +#[tokio::test(flavor = "multi_thread")] +async fn malformed_event_traffic_exhausts_raw_budget_before_eose() { + assert_eq!(fetch_malformed(24).await, FetchTargetState::Partial); +} + +async fn finish_server(mut server: tokio::task::JoinHandle<()>) { + let result = tokio::time::timeout(WATCHDOG, &mut server).await; + if result.is_err() { + server.abort(); + let _ = server.await; + } + result + .expect("client must close the bounded relay connection") + .unwrap(); +} + +#[tokio::test(flavor = "multi_thread")] +async fn completed_batches_do_not_refund_raw_bytes_for_later_relays() { + let (one, one_url) = listener().await; + let (two, two_url) = listener().await; + let servers = [ + tokio::spawn(serve_malformed(one, 12)), + tokio::spawn(serve_malformed(two, 12)), + ]; + let (transport, request) = transport(&[one_url, two_url]); + let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; + for server in servers { + finish_server(server).await; + } + let page = result.unwrap().unwrap(); + assert!(page.events().is_empty()); + assert_eq!( + page.target_outcomes() + .iter() + .filter(|outcome| outcome.state() == FetchTargetState::Complete) + .count(), + 1 + ); + assert_eq!( + page.target_outcomes() + .iter() + .filter(|outcome| outcome.state() == FetchTargetState::Partial) + .count(), + 1 + ); +} + +#[tokio::test(flavor = "multi_thread")] +async fn unsolicited_malformed_traffic_is_bounded_before_the_request() { + let (listener, url) = listener().await; + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + let malformed = + serde_json::to_string(&("EVENT", "unsolicited", malformed_event())).unwrap(); + for sequence in 0..24 { + if socket + .send(Message::Text(malformed.clone().into())) + .await + .is_err() + || !barrier(&mut socket, sequence).await + { + return; + } + } + panic!("oversized unsolicited inventory must close before admission"); + }); + let (transport, request) = transport(&[url]); + let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; + finish_server(server).await; + assert_eq!( + result.unwrap().unwrap().target_outcomes()[0].state(), + FetchTargetState::Partial + ); +} + +#[tokio::test(flavor = "multi_thread")] +async fn zero_payload_continuation_frames_consume_work_before_message_decoding() { + use tokio_tungstenite::tungstenite::protocol::frame::{ + Frame, + coding::{Data, OpCode}, + }; + let (listener, url) = listener().await; + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + while let Some(message) = socket.next().await { + let text = match message { + Ok(Message::Text(text)) => text, + Ok(Message::Close(_)) | Err(_) => return, + _ => { + let _ = socket.flush().await; + continue; + } + }; + let values: Value = serde_json::from_str(&text).unwrap(); + if values[0] != "REQ" { + continue; + } + socket + .send(Message::Frame(Frame::message( + Vec::new(), + OpCode::Data(Data::Text), + false, + ))) + .await + .unwrap(); + for sequence in 0..8193 { + if socket + .send(Message::Frame(Frame::message( + Vec::new(), + OpCode::Data(Data::Continue), + false, + ))) + .await + .is_err() + { + return; + } + if sequence % 128 == 0 && !barrier(&mut socket, sequence).await { + return; + } + } + if socket + .send(Message::Frame(Frame::message( + b"[]".to_vec(), + OpCode::Data(Data::Continue), + true, + ))) + .await + .is_err() + { + return; + } + let _ = socket + .send(Message::Text( + serde_json::to_string(&("EOSE", &values[1])).unwrap().into(), + )) + .await; + } + }); + let (transport, request) = transport(&[url]); + let result = tokio::time::timeout(WATCHDOG, transport.fetch(request)).await; + finish_server(server).await; + let page = result.unwrap().unwrap(); + assert!(page.events().is_empty()); + assert_eq!(page.target_outcomes()[0].state(), FetchTargetState::Partial); +} diff --git a/crates/transport_nostr_native/tests/fetch_windows.rs b/crates/transport_nostr_native/tests/fetch_windows.rs @@ -0,0 +1,160 @@ +use futures::{SinkExt, StreamExt}; +use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Timestamp}; +use radroots_transport::{ + EventSource, FetchRequest, TargetSet, + outcome::FetchTargetState, + source::{FetchBounds, NextPage}, +}; +use radroots_transport_nostr::{ + Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, +}; +use serde_json::Value; +use std::{ + collections::BTreeSet, + sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }, + time::{Duration, SystemTime, UNIX_EPOCH}, +}; +use tokio::net::TcpListener; +use tokio_tungstenite::{accept_async, tungstenite::Message}; + +#[tokio::test(flavor = "multi_thread")] +async fn real_capped_eose_preserves_received_ties_and_yields_explicit_older_history() { + let keys = + Keys::parse("0000000000000000000000000000000000000000000000000000000000000001").unwrap(); + let mut history = (0..1001) + .map(|index| { + let event = EventBuilder::new(Kind::TextNote, format!("equal-time {index}")) + .custom_created_at(Timestamp::from_secs(100)) + .finalize(&keys) + .unwrap(); + serde_json::from_str::<Value>(&event.as_json()).unwrap() + }) + .collect::<Vec<_>>(); + history.sort_by(|left, right| right["id"].as_str().cmp(&left["id"].as_str())); + let expected = history[..1000] + .iter() + .map(|event| event["id"].as_str().unwrap().to_owned()) + .collect::<BTreeSet<_>>(); + let older = EventBuilder::new(Kind::TextNote, "older") + .custom_created_at(Timestamp::from_secs(99)) + .finalize(&keys) + .unwrap(); + history.push(serde_json::from_str(&older.as_json()).unwrap()); + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("ws://{}", listener.local_addr().unwrap()); + let calls = Arc::new(AtomicUsize::new(0)); + let server_calls = calls.clone(); + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + while let Some(Ok(message)) = socket.next().await { + let Message::Text(message) = message else { + continue; + }; + let request: Value = serde_json::from_str(&message).unwrap(); + if request[0] != "REQ" { + continue; + } + server_calls.fetch_add(1, Ordering::SeqCst); + assert_eq!(request[2]["limit"], 1000); + let until = request[2]["until"].as_u64().unwrap_or(u64::MAX); + for event in history + .iter() + .filter(|event| event["created_at"].as_u64().unwrap() <= until) + .take(1000) + { + socket + .send(Message::Text( + serde_json::to_string(&("EVENT", &request[1], event)) + .unwrap() + .into(), + )) + .await + .unwrap(); + } + socket + .send(Message::Text( + serde_json::to_string(&("EOSE", &request[1])) + .unwrap() + .into(), + )) + .await + .unwrap(); + } + }); + let profile = RelayProfile::explicit( + RelayProfileKind::Simulator, + [RelayEndpoint::new(&url, RelayUrlPolicy::Local, RelayAccess::ReadOnly).unwrap()], + ) + .unwrap(); + let config = Config::from_profile(profile) + .with_timeouts(5000, 5000, 500) + .unwrap(); + let targets = TargetSet::new( + config + .read_relays() + .map(|relay| relay.to_target().unwrap()) + .collect(), + ) + .unwrap(); + let transport = radroots_transport_nostr_native::create_transport(config); + let deadline = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_millis() as u64 + + 20000; + let request = FetchRequest::new( + "live-capped-window", + targets, + FetchBounds::new(500, deadline).unwrap(), + ) + .unwrap(); + tokio::time::timeout(Duration::from_secs(15), async { + let first = transport.fetch(request.clone()).await.unwrap(); + assert_eq!(first.events().len(), 500); + assert_eq!( + first.target_outcomes()[0].state(), + FetchTargetState::Partial + ); + let NextPage::Cursor(cursor) = first.next_page() else { + panic!("received peers remain") + }; + let second = transport + .fetch(request.clone().with_cursor(cursor.clone())) + .await + .unwrap(); + assert_eq!(second.events().len(), 500); + assert_eq!( + second.target_outcomes()[0].state(), + FetchTargetState::Partial + ); + assert_eq!(calls.load(Ordering::SeqCst), 2); + let received = first + .events() + .iter() + .chain(second.events()) + .map(|e| e.event().id_str().to_owned()) + .collect::<BTreeSet<_>>(); + assert_eq!(received, expected); + let NextPage::Cancelled { + resume_from: Some(older), + } = second.next_page() + else { + panic!("explicit partial window yield") + }; + let third = transport + .fetch(request.with_cursor(older.clone())) + .await + .unwrap(); + assert_eq!(third.events().len(), 1); + assert_eq!(third.events()[0].event().created_at(), 99); + assert!(matches!(third.next_page(), NextPage::Complete)); + assert_eq!(calls.load(Ordering::SeqCst), 3); + }) + .await + .unwrap(); + server.abort(); +} diff --git a/crates/transport_nostr_native/tests/local_io.rs b/crates/transport_nostr_native/tests/local_io.rs @@ -0,0 +1,378 @@ +use futures::{SinkExt, StreamExt}; +use radroots_transport::{ + EventSource, EventSubscriber, FetchRequest, SubscriptionNext, SubscriptionRequest, TargetSet, + capability::Availability, + outcome::FetchTargetState, + source::{FetchBounds, SubscriptionBounds, SubscriptionEndReason}, +}; +use radroots_transport_nostr::{ + Config, RelayAccess, RelayAggregateState, RelayEndpoint, RelayEvidenceState, RelayProfile, + RelayProfileKind, RelayUrlPolicy, +}; +use serde_json::Value; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; +use tokio::net::TcpListener; +use tokio_tungstenite::{accept_async, tungstenite::Message}; + +const FIXTURE_SECRET_KEY: &str = "0000000000000000000000000000000000000000000000000000000000000001"; + +#[tokio::test(flavor = "multi_thread")] +async fn simulator_profile_proves_read_capability_against_a_real_loopback_socket() { + let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind relay"); + let address = listener.local_addr().expect("relay address"); + let relay_url = format!("ws://{address}"); + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.expect("accept relay client"); + let mut websocket = accept_async(stream).await.expect("websocket handshake"); + while let Some(message) = websocket.next().await { + let Message::Text(message) = message.expect("client message") else { + continue; + }; + let parsed: Value = serde_json::from_str(message.as_str()).expect("Nostr message"); + let Some(values) = parsed.as_array() else { + continue; + }; + let [Value::String(kind), Value::String(subscription), ..] = values.as_slice() else { + continue; + }; + if kind == "REQ" { + websocket + .send(Message::Text( + serde_json::to_string(&("EOSE", subscription)) + .expect("EOSE message") + .into(), + )) + .await + .expect("send EOSE"); + break; + } + } + }); + + let endpoint = RelayEndpoint::new( + relay_url.as_str(), + RelayUrlPolicy::Local, + RelayAccess::ReadWrite, + ) + .expect("loopback endpoint"); + let profile = + RelayProfile::explicit(RelayProfileKind::Simulator, [endpoint]).expect("simulator profile"); + let config = Config::from_profile(profile) + .with_timeouts(1_000, 2_000, 500) + .expect("timeouts"); + let targets = TargetSet::new( + config + .read_relays() + .map(|relay| relay.to_target()) + .collect::<Result<Vec<_>, _>>() + .expect("targets"), + ) + .expect("target set"); + let request = FetchRequest::new( + "local-real-io", + targets, + FetchBounds::new(1, unix_time_ms() + 5_000).expect("bounds"), + ) + .expect("request"); + let transport = radroots_transport_nostr_native::create_transport(config); + let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(request)) + .await + .expect("bounded fetch") + .expect("fetch page"); + + assert!(page.events().is_empty()); + assert_eq!(page.target_outcomes().len(), 1); + assert_eq!( + page.target_outcomes()[0].state(), + FetchTargetState::Complete + ); + let status = transport.relay_status(); + assert_eq!(status.state(), RelayAggregateState::ReadOnly); + assert_eq!(status.read_availability(), Availability::Available); + assert_eq!(status.write_availability(), Availability::Unavailable); + assert_eq!( + status.relays()[0].read().state(), + RelayEvidenceState::Available + ); + assert_eq!( + status.relays()[0].write().state(), + RelayEvidenceState::Unobserved + ); + server.await.expect("relay task"); +} + +#[tokio::test(flavor = "multi_thread")] +async fn simulator_profile_streams_and_cancels_a_real_live_subscription() { + use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind, Timestamp}; + + let event = EventBuilder::new(Kind::TextNote, "bounded live event") + .custom_created_at(Timestamp::from_secs(1_800_000_100)) + .finalize(&Keys::parse(FIXTURE_SECRET_KEY).expect("fixture keys")) + .expect("signed event"); + let expected_id = event.id.to_hex(); + let event: Value = serde_json::from_str(event.as_json().as_str()).expect("event JSON"); + let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind relay"); + let address = listener.local_addr().expect("relay address"); + let relay_url = format!("ws://{address}"); + let server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.expect("accept relay client"); + let mut websocket = accept_async(stream).await.expect("websocket handshake"); + let mut subscription_id = None; + while let Some(message) = websocket.next().await { + let Message::Text(message) = message.expect("client message") else { + continue; + }; + let parsed: Value = serde_json::from_str(message.as_str()).expect("Nostr message"); + let Some(values) = parsed.as_array() else { + continue; + }; + match values.as_slice() { + [Value::String(kind), Value::String(subscription), ..] if kind == "REQ" => { + subscription_id = Some(subscription.clone()); + websocket + .send(Message::Text( + serde_json::to_string(&("EVENT", subscription, &event)) + .expect("EVENT message") + .into(), + )) + .await + .expect("send EVENT"); + } + [Value::String(kind), Value::String(subscription)] + if kind == "CLOSE" && subscription_id.as_ref() == Some(subscription) => + { + return; + } + _ => {} + } + } + panic!("client disconnected without CLOSE"); + }); + + let endpoint = RelayEndpoint::new( + relay_url.as_str(), + RelayUrlPolicy::Local, + RelayAccess::ReadWrite, + ) + .expect("loopback endpoint"); + let profile = + RelayProfile::explicit(RelayProfileKind::Simulator, [endpoint]).expect("simulator profile"); + let config = Config::from_profile(profile) + .with_timeouts(1_000, 2_000, 500) + .expect("timeouts"); + let targets = TargetSet::new( + config + .read_relays() + .map(|relay| relay.to_target()) + .collect::<Result<Vec<_>, _>>() + .expect("targets"), + ) + .expect("target set"); + let request = SubscriptionRequest::new( + "local-live-io", + targets, + SubscriptionBounds::new(2, unix_time_ms() + 5_000).expect("bounds"), + ) + .expect("request"); + let transport = radroots_transport_nostr_native::create_transport(config); + let mut subscription = + tokio::time::timeout(Duration::from_secs(5), transport.subscribe(request)) + .await + .expect("bounded subscribe") + .expect("subscription"); + let SubscriptionNext::Event(observed) = + tokio::time::timeout(Duration::from_secs(5), subscription.next()) + .await + .expect("bounded event") + .expect("event") + else { + panic!("event expected"); + }; + assert_eq!(observed.observed().event().id_str(), expected_id); + assert_eq!( + subscription.cancel().await.expect("cancel").reason(), + SubscriptionEndReason::Cancelled + ); + tokio::time::timeout(Duration::from_secs(5), server) + .await + .expect("server deadline") + .expect("relay task"); +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn shutdown_disconnects_the_shared_live_pool_and_refuses_new_effects() { + use nostr_sdk::prelude::{EventBuilder, FinalizeEvent, Keys, Kind}; + use radroots_transport::{ + DeliveryRequest, EventSink, + policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, + sink::DeliveryPayload, + }; + + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let relay_url = format!("ws://{}", listener.local_addr().unwrap()); + let mut server = tokio::spawn(async move { + let (stream, _) = listener.accept().await.unwrap(); + let mut socket = accept_async(stream).await.unwrap(); + while let Some(message) = socket.next().await { + match message { + Ok(Message::Text(message)) => { + let value: Value = serde_json::from_str(&message).unwrap(); + if value[0] == "REQ" { + socket + .send(Message::Text( + serde_json::to_string(&("EOSE", &value[1])).unwrap().into(), + )) + .await + .unwrap(); + } + } + Ok(Message::Close(_)) | Err(_) => return listener, + _ => {} + } + } + listener + }); + let profile = RelayProfile::explicit( + RelayProfileKind::Simulator, + [RelayEndpoint::new(&relay_url, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap()], + ) + .unwrap(); + let config = Config::from_profile(profile) + .with_timeouts(1000, 2000, 500) + .unwrap(); + let relay = config.relays()[0].clone(); + let targets = TargetSet::new(vec![relay.to_target().unwrap()]).unwrap(); + let fetch = FetchRequest::new( + "shutdown-fetch", + targets.clone(), + FetchBounds::new(1, unix_time_ms() + 5000).unwrap(), + ) + .unwrap(); + let subscription = SubscriptionRequest::new( + "shutdown-subscription", + targets.clone(), + SubscriptionBounds::new(1, unix_time_ms() + 5000).unwrap(), + ) + .unwrap(); + let event = EventBuilder::new(Kind::TextNote, "synthetic shutdown fixture") + .finalize(&Keys::parse(FIXTURE_SECRET_KEY).unwrap()) + .unwrap(); + let delivery = DeliveryRequest::new( + "shutdown-delivery", + DeliveryPayload::new(radroots_event_codec::decode::signed_event(&event.as_json()).unwrap()), + targets, + SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), + unix_time_ms() + 5000, + ) + .unwrap(); + let transport = radroots_transport_nostr_native::create_transport(config); + let prepared = transport.prepare_delivery(delivery.clone()).unwrap(); + transport + .begin_authentication(&relay, "shutdown challenge", 1000, 2000) + .unwrap(); + let page = tokio::time::timeout(Duration::from_secs(5), transport.fetch(fetch.clone())) + .await + .unwrap() + .unwrap(); + assert_eq!( + page.target_outcomes()[0].state(), + FetchTargetState::Complete + ); + + let mut live = transport.subscribe(subscription.clone()).await.unwrap(); + assert!( + !server.is_finished(), + "the pool must still own a live socket before shutdown" + ); + + drop(transport.shutdown()); + assert!(EventSource::status(&transport).await.is_ok()); + let clone = transport.clone(); + clone.shutdown().await; + transport.shutdown().await; + let joined = tokio::time::timeout(Duration::from_secs(2), &mut server).await; + if joined.is_err() { + server.abort(); + let _ = server.await; + panic!("shutdown did not terminate the live loopback socket"); + } + let listener = joined.unwrap().unwrap(); + let ended = tokio::time::timeout(Duration::from_secs(2), live.next()) + .await + .unwrap() + .unwrap(); + assert!( + matches!(ended, SubscriptionNext::End(ref end) if end.reason() == SubscriptionEndReason::SourceClosed) + ); + assert_eq!( + transport.fetch(fetch).await.unwrap_err(), + radroots_transport::Error::TransportClosed + ); + assert!(matches!( + transport.subscribe(subscription).await, + Err(radroots_transport::Error::TransportClosed) + )); + assert_eq!( + EventSource::status(&clone).await.unwrap_err(), + radroots_transport::Error::TransportClosed + ); + assert_eq!( + EventSink::status(&clone).await.unwrap_err(), + radroots_transport::Error::TransportClosed + ); + assert_eq!( + transport + .begin_authentication(&relay, "new challenge", 1000, 2000) + .unwrap_err(), + radroots_transport_nostr::Error::TransportClosed + ); + assert_eq!( + transport + .complete_authentication(&relay, "shutdown challenge", None, 1500) + .await + .unwrap_err(), + radroots_transport_nostr::Error::TransportClosed + ); + assert_eq!( + transport + .reject_authentication(&relay, "shutdown challenge") + .unwrap_err(), + radroots_transport_nostr::Error::TransportClosed + ); + for failure in [ + transport + .execute_prepared_delivery(prepared) + .await + .unwrap_err(), + transport.deliver(delivery.clone()).await.unwrap_err(), + transport + .deliver_selected(delivery.clone(), delivery.target_set().clone()) + .await + .unwrap_err(), + ] { + assert_eq!(failure.code(), "transport_closed"); + failure.validate_for_request(&delivery).unwrap(); + assert_eq!( + failure.partial_evidence().len(), + delivery.target_set().len() + ); + assert!( + failure + .partial_evidence() + .iter() + .all(|row| !row.was_attempted()) + ); + } + assert!( + tokio::time::timeout(Duration::from_millis(150), listener.accept()) + .await + .is_err() + ); +} + +fn unix_time_ms() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|duration| u64::try_from(duration.as_millis()).unwrap_or(u64::MAX)) + .unwrap_or_default() +} diff --git a/tools/xtask/src/api_qualification.rs b/tools/xtask/src/api_qualification.rs @@ -81,6 +81,7 @@ fn validate(contract: &Contract, expected_packages: usize) -> Result<(), String> "radroots_sdk", "radroots_domain", "radroots_execution", + "radroots_transport_nostr_native", ]) || contract.baseline_override.len() != overrides.len() || contract @@ -165,7 +166,7 @@ mod tests { .and_then(std::path::Path::parent) .expect("workspace root"); let contract = load(root).expect("contract"); - validate(&contract, 21).expect("valid contract"); + validate(&contract, 22).expect("valid contract"); let invocation = invocation(&contract, "radroots_core"); assert!(invocation.contains(&"--all-features".to_owned())); assert!(invocation.ends_with(&["--release-type".to_owned(), "major".to_owned()])); diff --git a/tools/xtask/src/architecture.rs b/tools/xtask/src/architecture.rs @@ -1495,7 +1495,7 @@ adr_required = false .parent() .unwrap(); let names = super::public_package_names(root, &architecture()).unwrap(); - assert_eq!(names.len(), 21); + assert_eq!(names.len(), 22); assert!(names.contains("radroots_domain") && names.contains("radroots_execution")); assert!(!names.contains("radroots_nostrdb")); } diff --git a/tools/xtask/src/catalog.rs b/tools/xtask/src/catalog.rs @@ -25,7 +25,11 @@ const CONSOLIDATION_ID: &str = "radroots.rust.consolidation.v1"; const VERSION: &str = "0.1.0-alpha"; // Implemented public owners from the approved shared SDK target. Native // introduction provenance is independent of publication eligibility. -const NATIVE_PUBLIC_PACKAGES: &[&str] = &["radroots_domain", "radroots_execution"]; +const NATIVE_PUBLIC_PACKAGES: &[&str] = &[ + "radroots_domain", + "radroots_execution", + "radroots_transport_nostr_native", +]; const APPLICATION_RETIREMENT: &str = "contracts/architecture/decisions/tera_application_ownership.v1.json"; const RETIRED_APPLICATION_PACKAGES: [&str; 4] = [ @@ -1550,7 +1554,7 @@ mod tests { #[test] fn public_inventory_is_exact() { - assert_eq!(expected_public_packages().len(), 21); + assert_eq!(expected_public_packages().len(), 22); assert!(expected_public_packages().contains("radroots")); assert!(expected_public_packages().contains("radroots_sdk")); } @@ -1566,7 +1570,11 @@ mod tests { #[test] fn only_approved_shared_native_packages_can_be_public() { - for name in ["radroots_domain", "radroots_execution"] { + for name in [ + "radroots_domain", + "radroots_execution", + "radroots_transport_nostr_native", + ] { let mut catalog = checked_in_catalog(); let package = catalog.package.iter_mut().find(|p| p.name == name).unwrap(); package.visibility = "public_release".to_owned(); diff --git a/tools/xtask/src/target_qualification.rs b/tools/xtask/src/target_qualification.rs @@ -214,7 +214,7 @@ mod tests { ("macos", "aarch64-apple-darwin"), ] ); - assert_eq!(packages.len(), 21); + assert_eq!(packages.len(), 22); } #[test]