lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

commit 6638d84dc7017108e218196e8e3f4234b901885e
parent 7e06829b72657707cb4de95e837af9b188745f65
Author: triesap <tyson@radroots.org>
Date:   Tue, 20 Oct 2026 05:10:41 +0000

transport: Add bounded origin-thread browser socket I/O

- Keep DOM state local behind safe owned messages and frozen socket limits
- Reuse shared Nostr verification, sessions and original-byte publication
- Verify real page and worker I/O, acknowledgement handling and cancellation
- Preserve private provenance and unchanged source, API and coverage gates

Diffstat:
MCargo.lock | 16++++++++++++++++
MCargo.toml | 2++
Mcontracts/coverage.toml | 1+
Mcontracts/crates/catalog.v2.toml | 20+++++++++++++++++++-
Mcontracts/crates/generated/package_groups.v1.toml | 10+++++-----
Mcontracts/crates/generated/platform_inventory.v1.toml | 4++--
Mcontracts/crates/generated/release_inventory.v2.toml | 4++--
Mcontracts/releases/publish_policy.toml | 1+
Acrates/transport_nostr_browser/Cargo.toml | 29+++++++++++++++++++++++++++++
Acrates/transport_nostr_browser/README.md | 35+++++++++++++++++++++++++++++++++++
Acrates/transport_nostr_browser/src/browser.rs | 357+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/transport_nostr_browser/src/connector.rs | 123+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/transport_nostr_browser/src/lib.rs | 19+++++++++++++++++++
Acrates/transport_nostr_browser/src/state.rs | 164+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/transport_nostr_browser/src/state_tests.rs | 240+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/transport_nostr_browser/tests/browser/Cargo.lock | 2613+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/transport_nostr_browser/tests/browser/Cargo.toml | 24++++++++++++++++++++++++
Acrates/transport_nostr_browser/tests/browser/run.mjs | 158+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/transport_nostr_browser/tests/browser/src/clock.rs | 26++++++++++++++++++++++++++
Acrates/transport_nostr_browser/tests/browser/src/lib.rs | 328+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Acrates/transport_nostr_browser/tests/browser/src/shared.rs | 176+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
21 files changed, 4340 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock @@ -3788,6 +3788,22 @@ dependencies = [ ] [[package]] +name = "radroots_transport_nostr_browser" +version = "0.1.0-alpha" +dependencies = [ + "async-utility", + "futures", + "js-sys", + "radroots_transport", + "radroots_transport_nostr", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "web-time", +] + +[[package]] name = "radroots_transport_nostr_native" version = "0.1.0-alpha" dependencies = [ diff --git a/Cargo.toml b/Cargo.toml @@ -20,6 +20,7 @@ members = [ "crates/nostrdb", "crates/transport_nostr", "crates/transport_nostr_native", + "crates/transport_nostr_browser", "crates/transport_reticulum", "crates/simplex_app_store", "crates/simplex_agent_proto", @@ -138,6 +139,7 @@ radroots_service_host = { path = "crates/service_host", version = "=0.1.0-alpha" radroots_service_sqlite = { path = "crates/service_sqlite", version = "=0.1.0-alpha", default-features = false } radroots_transport_nostr = { package = "radroots_transport_nostr", path = "crates/transport_nostr", version = "=0.1.0-alpha", default-features = false } radroots_transport_nostr_native = { package = "radroots_transport_nostr_native", path = "crates/transport_nostr_native", version = "=0.1.0-alpha", default-features = false } +radroots_transport_nostr_browser = { path = "crates/transport_nostr_browser", version = "=0.1.0-alpha", default-features = false } radroots_transport_reticulum = { path = "crates/transport_reticulum", version = "=0.1.0-alpha", default-features = false } radroots_simplex_agent_proto = { path = "crates/simplex_agent_proto", version = "=0.1.0-alpha", default-features = false } radroots_simplex_chat_proto = { path = "crates/simplex_chat_proto", version = "=0.1.0-alpha", default-features = false } diff --git a/contracts/coverage.toml b/contracts/coverage.toml @@ -75,6 +75,7 @@ crates = [ "radroots_sync", "radroots_transport_nostr", "radroots_transport_nostr_native", + "radroots_transport_nostr_browser", "radroots_transport_reticulum", "radroots_replica_store", "radroots_replica_store_wasm", diff --git a/contracts/crates/catalog.v2.toml b/contracts/crates/catalog.v2.toml @@ -7,7 +7,7 @@ rust_version = "1.99.0" edition = "2024" resolver = "3" public_package_count = 22 -package_count = 55 +package_count = 56 digest_algorithm = "sha256-raw-bytes-v1" source_tree_digest_algorithm = "sha256-git-ls-tree-r-v1" native_introduction_tree_digest_algorithm = "sha256-git-tree-records-z-v1" @@ -409,6 +409,24 @@ compatibility = ["rust_api", "network", "features", "package"] replaces = [] [[package]] +name = "radroots_transport_nostr_browser" +path = "crates/transport_nostr_browser" +state = "active" +tier = "adapter" +visibility = "private_adapter" +publish = false +version = "0.1.0-alpha" +license = "MIT OR Apache-2.0" +platforms = ["wasm32"] +groups = ["coverage_required", "wasm"] +owners = ["transport"] +permitted_dependency_tiers = ["foundation", "domain", "spi", "adapter"] +provenance_kind = "native" +introduction_tree_sha256 = "bc8425c519ca6d3921d8e05c454ee01e4644bd86ae7ff2bf2818ab6ea1dd2685" +compatibility = ["package_private", "rust_api", "network"] +replaces = [] + +[[package]] name = "radroots_transport_nostr_native" path = "crates/transport_nostr_native" state = "active" 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 = "9dc291f170c1888cd2f9e9acb10c1251e32dd7b94c9b3c347feb7a6eaa44b475" +catalog_sha256 = "00210ad66c7305d5e57f24e821a0c215e8bd9db25a1382490d6710aca88d3650" [[group]] id = "boundaries" @@ -9,8 +9,8 @@ reserved_packages = [] [[group]] id = "coverage_required" -packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_core_bindings", "radroots_domain", "radroots_event", "radroots_event_bindings", "radroots_event_codec", "radroots_event_codec_wasm", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostr", "radroots_nostr_connect", "radroots_nostrdb", "radroots_protocol", "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", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_secrets", "radroots_service_host", "radroots_service_sqlite", "radroots_signing", "radroots_sql_core", "radroots_storage", "radroots_storage_indexeddb", "radroots_storage_sqlite", "radroots_sync", "radroots_test_fixtures", "radroots_trade", "radroots_trade_bindings", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native", "radroots_transport_reticulum", "xtask"] -active_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_core_bindings", "radroots_domain", "radroots_event", "radroots_event_bindings", "radroots_event_codec", "radroots_event_codec_wasm", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostr", "radroots_nostr_connect", "radroots_nostrdb", "radroots_protocol", "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", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_secrets", "radroots_service_host", "radroots_service_sqlite", "radroots_signing", "radroots_sql_core", "radroots_storage", "radroots_storage_indexeddb", "radroots_storage_sqlite", "radroots_sync", "radroots_test_fixtures", "radroots_trade", "radroots_trade_bindings", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_native", "radroots_transport_reticulum", "xtask"] +packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_core_bindings", "radroots_domain", "radroots_event", "radroots_event_bindings", "radroots_event_codec", "radroots_event_codec_wasm", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostr", "radroots_nostr_connect", "radroots_nostrdb", "radroots_protocol", "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", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_secrets", "radroots_service_host", "radroots_service_sqlite", "radroots_signing", "radroots_sql_core", "radroots_storage", "radroots_storage_indexeddb", "radroots_storage_sqlite", "radroots_sync", "radroots_test_fixtures", "radroots_trade", "radroots_trade_bindings", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_browser", "radroots_transport_nostr_native", "radroots_transport_reticulum", "xtask"] +active_packages = ["radroots", "radroots_blossom", "radroots_core", "radroots_core_bindings", "radroots_domain", "radroots_event", "radroots_event_bindings", "radroots_event_codec", "radroots_event_codec_wasm", "radroots_execution", "radroots_geonames", "radroots_identity", "radroots_identity_bindings", "radroots_mesh", "radroots_mesh_agent_client", "radroots_mesh_agent_proto", "radroots_nostr", "radroots_nostr_connect", "radroots_nostrdb", "radroots_protocol", "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", "radroots_sdk_ffi", "radroots_sdk_sql_wasm_runtime", "radroots_secrets", "radroots_service_host", "radroots_service_sqlite", "radroots_signing", "radroots_sql_core", "radroots_storage", "radroots_storage_indexeddb", "radroots_storage_sqlite", "radroots_sync", "radroots_test_fixtures", "radroots_trade", "radroots_trade_bindings", "radroots_transport", "radroots_transport_nostr", "radroots_transport_nostr_browser", "radroots_transport_nostr_native", "radroots_transport_reticulum", "xtask"] reserved_packages = [] [[group]] @@ -45,6 +45,6 @@ reserved_packages = [] [[group]] id = "wasm" -packages = ["radroots_event_codec_wasm", "radroots_replica_store_wasm", "radroots_replica_sync_wasm", "radroots_sdk_sql_wasm_runtime", "radroots_sql_core", "radroots_storage_indexeddb"] -active_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_browser"] +active_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_browser"] reserved_packages = [] 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 = "9dc291f170c1888cd2f9e9acb10c1251e32dd7b94c9b3c347feb7a6eaa44b475" +catalog_sha256 = "00210ad66c7305d5e57f24e821a0c215e8bd9db25a1382490d6710aca88d3650" [[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", "radroots_transport_nostr"] +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", "radroots_transport_nostr_browser"] 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 = "9dc291f170c1888cd2f9e9acb10c1251e32dd7b94c9b3c347feb7a6eaa44b475" +catalog_sha256 = "00210ad66c7305d5e57f24e821a0c215e8bd9db25a1382490d6710aca88d3650" 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", "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"] +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_browser", "radroots_transport_reticulum", "xtask"] reserved_packages = [] diff --git a/contracts/releases/publish_policy.toml b/contracts/releases/publish_policy.toml @@ -66,6 +66,7 @@ private = [ "radroots_service_sqlite", "radroots_sql_core", "radroots_storage_indexeddb", + "radroots_transport_nostr_browser", ] build_codegen = [ "radroots_core_bindings", diff --git a/crates/transport_nostr_browser/Cargo.toml b/crates/transport_nostr_browser/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "radroots_transport_nostr_browser" +publish = false +version = "0.1.0-alpha" +edition.workspace = true +rust-version.workspace = true +authors.workspace = true +license.workspace = true +repository.workspace = true +homepage.workspace = true +description = "Bounded browser sockets for the shared Radroots Nostr session" +readme = "README.md" + +[dependencies] +radroots_transport = { workspace = true, features = ["std"] } +radroots_transport_nostr = { workspace = true } +futures = { workspace = true } +url = { workspace = true } + +[target.'cfg(target_arch = "wasm32")'.dependencies] +async-utility = { workspace = true } +js-sys = { workspace = true } +wasm-bindgen = { workspace = true } +wasm-bindgen-futures = { workspace = true } +web-time = { workspace = true } +web-sys = { workspace = true, features = ["BinaryType", "CloseEvent", "Event", "EventTarget", "MessageEvent", "WebSocket"] } + +[lints] +workspace = true diff --git a/crates/transport_nostr_browser/README.md b/crates/transport_nostr_browser/README.md @@ -0,0 +1,35 @@ +# radroots_transport_nostr_browser + +Origin-thread WebSocket I/O for the existing shared Radroots Nostr session. +`BrowserConnector` is inert; `create_transport` selects this concrete provider. +DOM objects and callbacks remain in one local owner. Cross-boundary futures +contain only owned Rust data and safe channels. There is no second relay pool. + +Received messages are limited to 512 KiB, 256 queued messages and 4 MiB of +queued payload. The original connection admission charges each delivered +message before exposing it to the shared decoder. Refusal closes this socket +and reports an error. Outgoing messages are serialized, bounded, and refused +when the browser's reported buffered amount would exceed 4 MiB. A successful +send means local browser enqueue only; protocol acceptance remains owned by +the shared session. Binary and text remain distinct and unchanged. + +The browser owns DNS, TLS, WebSocket framing, control frames and allocations +before callbacks. This provider cannot pin DNS results, meter plaintext before +decode, observe wire fragmentation or bound the user agent's internal buffers. +It checks literal IP destinations against admission and relies on the shared +explicit URL policy for configured DNS names. Its byte/work charges describe +delivered payload and message starts, not native wire framing. Ping/pong are +unsupported. User-agent error objects and close reasons are not diagnostics. +Use `Socket::close` for local close; sending a control-frame variant is refused. + +The pinned upstream session requires one compile-time time-provider selection +in a final WASM artifact. That artifact root must bind the provider to real +browser monotonic and wall clocks. This library exports no global provider +symbol. The source-owned browser I/O fixture makes this artifact-root choice +explicitly; it does not use a simulated clock. + +Explicit close waits for local callback detachment and socket close initiation; +it does not prove a remote close handshake. Cancelling a connect or dropping the +last socket handle requests that same local cleanup. A page or worker being +terminated has no asynchronous completion guarantee. Import and construction +perform no I/O. Non-browser targets refuse connections. diff --git a/crates/transport_nostr_browser/src/browser.rs b/crates/transport_nostr_browser/src/browser.rs @@ -0,0 +1,357 @@ +use crate::state::{MAX_QUEUE_BYTES, SendRequest, Shared, Status, payload_len}; +use futures::{ + channel::oneshot, + future::{Either, poll_fn, select}, + lock::Mutex, +}; +use radroots_transport::host::websocket::{Admission, Error, Frame, IoFuture, Socket}; +use std::{num::NonZeroUsize, pin::pin, sync::Arc, task::Poll, time::Duration}; +use wasm_bindgen::{JsCast, closure::Closure}; +use web_sys::{BinaryType, Event, MessageEvent, WebSocket}; +use web_time::Instant; + +pub(crate) async fn connect( + endpoint: &str, + timeout: Duration, + limit: NonZeroUsize, + admission: Arc<dyn Admission>, +) -> Result<Arc<dyn Socket>, Error> { + poll_fn(|context| { + Poll::Ready( + if admission.admitted_read(context) && admission.admitted_write(context) { + Ok(()) + } else { + Err(Error::Policy) + }, + ) + }) + .await?; + let shared = Arc::new(Shared::new(admission, limit.get())); + let (sender, receiver) = oneshot::channel(); + let mut cancellation = CancelConnect(Some(shared.clone())); + start_owner( + endpoint.to_owned(), + Instant::now() + timeout, + shared, + sender, + ); + let result = receiver.await.unwrap_or(Err(Error::Closed)); + if result.is_ok() { + cancellation.0.take(); + } + result +} + +struct CancelConnect(Option<Arc<Shared>>); +impl Drop for CancelConnect { + fn drop(&mut self) { + if let Some(shared) = &self.0 { + shared.stop(); + } + } +} + +// This synchronous handoff is the only place the Send future touches the local +// executor. The spawned future, DOM values and callbacks never leave it. +fn start_owner( + endpoint: String, + deadline: Instant, + shared: Arc<Shared>, + ready: oneshot::Sender<Result<Arc<dyn Socket>, Error>>, +) { + wasm_bindgen_futures::spawn_local(async move { + let result = poll_fn(|context| { + // The local owner may start after the original caller yielded. + // Recheck the original grant before constructing the DOM socket. + if !shared.admission.admitted_read(context) || !shared.admission.admitted_write(context) + { + return Poll::Ready(Err(Error::Policy)); + } + Poll::Ready(Owner::open(&endpoint, shared.clone(), deadline)) + }) + .await; + let mut owner = match result { + Ok(owner) => owner, + Err(error) => { + shared.fail(error); + shared.finish(); + let _ = ready.send(Err(error)); + return; + } + }; + let opening = poll_fn(|context| { + shared.actor.register(context.waker()); + if !shared.admission.admitted_read(context) || !shared.admission.admitted_write(context) + { + return Poll::Ready(Err(Error::Policy)); + } + let state = shared.lock()?; + Poll::Ready(match state.status { + Status::Open if !state.stopping => Ok(()), + Status::Failed(error) => Err(error), + Status::Ended => Err(Error::Closed), + _ if state.stopping => Err(Error::Closed), + _ => return Poll::Pending, + }) + }); + let opened = match select(pin!(opening), pin!(sleep_until(deadline))).await { + Either::Left((result, _)) => result, + Either::Right(_) => Err(Error::Timeout), + }; + if let Err(error) = opened { + shared.fail(error); + let _ = ready.send(Err(error)); + return; + } + let socket: Arc<dyn Socket> = Arc::new(BrowserSocket { + shared: shared.clone(), + sending: Mutex::new(()), + receiving: Mutex::new(()), + closing: Mutex::new(()), + }); + if ready.send(Ok(socket)).is_err() { + return; + } + owner.drive().await; + }); +} + +async fn sleep_until(deadline: Instant) { + loop { + let remaining = deadline.saturating_duration_since(Instant::now()); + if remaining.is_zero() { + return; + } + let millis = remaining + .as_nanos() + .div_ceil(1_000_000) + .min(i32::MAX as u128) as u64; + async_utility::time::sleep(Duration::from_millis(millis)).await; + } +} + +struct BrowserSocket { + shared: Arc<Shared>, + sending: Mutex<()>, + receiving: Mutex<()>, + closing: Mutex<()>, +} + +impl Drop for BrowserSocket { + fn drop(&mut self) { + self.shared.stop(); + } +} + +impl Socket for BrowserSocket { + fn send(&self, frame: Frame) -> IoFuture<'_, Result<(), Error>> { + Box::pin(async move { + let bytes = payload_len(&frame)?; + if bytes > self.shared.limit { + return Err(Error::Protocol); + } + let _guard = self.sending.lock().await; + let (sender, receiver) = oneshot::channel(); + { + let mut state = self.shared.lock()?; + if state.stopping || state.status != Status::Open { + return Err(Error::Closed); + } + // Cancellation of a send observer does not erase admitted I/O. + if state.outgoing.is_some() { + return Err(Error::Policy); + } + state.outgoing = Some(SendRequest { + frame, + result: sender, + }); + } + self.shared.actor.wake(); + receiver.await.unwrap_or(Err(Error::Closed)) + }) + } + + fn receive(&self) -> IoFuture<'_, Result<Option<Frame>, Error>> { + Box::pin(async move { + let _guard = self.receiving.lock().await; + poll_fn(|context| { + self.shared.reader.register(context.waker()); + if !self.shared.admission.admitted_read(context) { + self.shared.fail(Error::Policy); + return Poll::Ready(Err(Error::Policy)); + } + if let Some(frame) = self.shared.pop()? { + return Poll::Ready(Ok(Some(frame))); + } + let state = self.shared.lock()?; + if state.finished || state.stopping || state.status == Status::Ended { + Poll::Ready(Ok(None)) + } else { + Poll::Pending + } + }) + .await + }) + } + + fn close(&self) -> IoFuture<'_, Result<(), Error>> { + Box::pin(async move { + let _guard = self.closing.lock().await; + self.shared.stop(); + poll_fn(|context| { + self.shared.closer.register(context.waker()); + if self.shared.lock()?.finished { + Poll::Ready(Ok(())) + } else { + Poll::Pending + } + }) + .await + }) + } +} + +struct Owner { + socket: WebSocket, + shared: Arc<Shared>, + _open: Closure<dyn FnMut(Event)>, + _message: Closure<dyn FnMut(MessageEvent)>, + _error: Closure<dyn FnMut(Event)>, + _close: Closure<dyn FnMut(Event)>, +} + +impl Owner { + fn open(endpoint: &str, shared: Arc<Shared>, deadline: Instant) -> Result<Self, Error> { + if shared.lock()?.stopping { + return Err(Error::Closed); + } + if Instant::now() >= deadline { + return Err(Error::Timeout); + } + let socket = WebSocket::new(endpoint).map_err(|_| Error::Unavailable)?; + socket.set_binary_type(BinaryType::Arraybuffer); + let state = shared.clone(); + let open = Closure::new(move |_: Event| { + if let Ok(mut inner) = state.lock() + && inner.status == Status::Connecting + && !inner.stopping + { + inner.status = Status::Open; + } + state.wake(); + }); + let state = shared.clone(); + let message = Closure::new(move |event: MessageEvent| { + let frame = decode_message(event, state.limit).and_then(|frame| state.push(frame)); + if let Err(error) = frame { + state.fail(error); + } + }); + let state = shared.clone(); + let error = Closure::new(move |_: Event| state.fail(Error::Unavailable)); + let state = shared.clone(); + let close = Closure::new(move |_: Event| { + if let Ok(mut inner) = state.lock() + && !matches!(inner.status, Status::Failed(_)) + { + inner.status = Status::Ended; + } + state.wake(); + }); + socket.set_onopen(Some(open.as_ref().unchecked_ref())); + socket.set_onmessage(Some(message.as_ref().unchecked_ref())); + socket.set_onerror(Some(error.as_ref().unchecked_ref())); + socket.set_onclose(Some(close.as_ref().unchecked_ref())); + Ok(Self { + socket, + shared, + _open: open, + _message: message, + _error: error, + _close: close, + }) + } + + async fn drive(&mut self) { + poll_fn(|context| { + self.shared.actor.register(context.waker()); + if !self.shared.admission.admitted_read(context) + || !self.shared.admission.admitted_write(context) + { + self.shared.fail(Error::Policy); + } + let request = { + let mut state = match self.shared.lock() { + Ok(state) => state, + Err(_) => return Poll::Ready(()), + }; + if state.stopping || state.status != Status::Open { + return Poll::Ready(()); + } + state.outgoing.take() + }; + if let Some(request) = request { + let result = self.send(request.frame); + if let Err(error) = result { + self.shared.fail(error); + } + let _ = request.result.send(result); + if result.is_err() { + return Poll::Ready(()); + } + } + Poll::Pending + }) + .await; + } + + fn send(&self, frame: Frame) -> Result<(), Error> { + let bytes = payload_len(&frame)?; + if bytes > self.shared.limit { + return Err(Error::Protocol); + } + if u64::from(self.socket.buffered_amount()) + bytes as u64 > MAX_QUEUE_BYTES as u64 { + return Err(Error::Policy); + } + match frame { + Frame::Text(text) => self.socket.send_with_str(&text), + Frame::Binary(bytes) => self.socket.send_with_u8_array(&bytes), + _ => return Err(Error::Unsupported), + } + .map_err(|_| Error::Unavailable) + } +} + +impl Drop for Owner { + fn drop(&mut self) { + self.socket.set_onopen(None); + self.socket.set_onmessage(None); + self.socket.set_onerror(None); + self.socket.set_onclose(None); + let _ = self.socket.close(); + self.shared.finish(); + } +} + +fn decode_message(event: MessageEvent, limit: usize) -> Result<Frame, Error> { + let data = event.data(); + if data.is_string() { + let value: js_sys::JsString = data.unchecked_into(); + if value.length() as usize > limit { + return Err(Error::Protocol); + } + let text: String = value.into(); + if text.len() > limit { + return Err(Error::Protocol); + } + Ok(Frame::Text(text)) + } else if data.is_instance_of::<js_sys::ArrayBuffer>() { + let buffer: js_sys::ArrayBuffer = data.unchecked_into(); + if buffer.byte_length() as usize > limit { + return Err(Error::Protocol); + } + Ok(Frame::Binary(js_sys::Uint8Array::new(&buffer).to_vec())) + } else { + Err(Error::Protocol) + } +} diff --git a/crates/transport_nostr_browser/src/connector.rs b/crates/transport_nostr_browser/src/connector.rs @@ -0,0 +1,123 @@ +use radroots_transport::host::websocket::{Admission, Connector, Error, IoFuture, Socket}; +use std::{net::IpAddr, num::NonZeroUsize, sync::Arc, time::Duration}; + +/// Inert provider whose DOM socket and callbacks stay on their origin thread. +#[derive(Clone, Copy, Debug, Default)] +pub struct BrowserConnector; + +impl Connector for BrowserConnector { + fn supports_ping(&self) -> bool { + false + } + + fn connect<'a>( + &'a self, + endpoint: &'a str, + timeout: Duration, + max_message_bytes: NonZeroUsize, + admission: Arc<dyn Admission>, + ) -> IoFuture<'a, Result<Arc<dyn Socket>, Error>> { + Box::pin(async move { + validate_endpoint(endpoint, admission.as_ref())?; + if timeout.is_zero() { + return Err(Error::Timeout); + } + #[cfg(target_arch = "wasm32")] + { + crate::browser::connect(endpoint, timeout, max_message_bytes, admission).await + } + #[cfg(not(target_arch = "wasm32"))] + { + let _ = max_message_bytes; + Err(Error::Unsupported) + } + }) + } +} + +fn validate_endpoint(endpoint: &str, admission: &dyn Admission) -> Result<(), Error> { + let url = url::Url::parse(endpoint).map_err(|_| Error::Policy)?; + if !matches!(url.scheme(), "ws" | "wss") + || !url.username().is_empty() + || url.password().is_some() + || url.fragment().is_some() + { + return Err(Error::Policy); + } + let host = url + .host_str() + .ok_or(Error::Policy)? + .trim_matches(['[', ']']); + if let Ok(address) = host.parse::<IpAddr>() + && !admission.permits_address(address) + { + return Err(Error::Policy); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::state::tests::AdmissionCounter as Grant; + #[test] + fn endpoint_validation_is_explicit_and_never_resolves_dns() { + for endpoint in [ + "invalid", + "https://example.org", + "ws://a:b@example.org", + "wss://example.org/#fragment", + ] { + assert_eq!( + validate_endpoint(endpoint, Grant::new(true).as_ref()), + Err(Error::Policy) + ); + } + for endpoint in ["ws://127.0.0.1", "wss://[::1]"] { + assert_eq!( + validate_endpoint(endpoint, Grant::new(false).as_ref()), + Err(Error::Policy) + ); + assert_eq!( + validate_endpoint(endpoint, Grant::new(true).as_ref()), + Ok(()) + ); + } + assert_eq!( + validate_endpoint("wss://relay.example/path?q=1", Grant::new(false).as_ref()), + Ok(()) + ); + } + #[test] + fn non_browser_connection_refuses_and_zero_deadline_does_not_start_io() { + assert!(!BrowserConnector.supports_ping()); + for (endpoint, duration, error) in [ + ("ws://127.0.0.1", Duration::from_secs(1), Error::Unsupported), + ("wss://example.org", Duration::ZERO, Error::Timeout), + ("invalid", Duration::from_secs(1), Error::Policy), + ] { + let result = futures::executor::block_on(BrowserConnector.connect( + endpoint, + duration, + NonZeroUsize::new(1).unwrap(), + Grant::new(true), + )); + assert!(matches!(result, Err(found) if found == error)); + } + } + + #[test] + fn factory_constructs_the_shared_session_without_host_effects() { + use radroots_transport_nostr::{ + Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, + }; + let endpoint = RelayEndpoint::new( + "wss://relay.example", + RelayUrlPolicy::Public, + RelayAccess::ReadWrite, + ) + .unwrap(); + let profile = RelayProfile::explicit(RelayProfileKind::Public, [endpoint]).unwrap(); + let _transport = crate::create_transport(Config::from_profile(profile)); + } +} diff --git a/crates/transport_nostr_browser/src/lib.rs b/crates/transport_nostr_browser/src/lib.rs @@ -0,0 +1,19 @@ +#![doc = include_str!("../README.md")] +#![forbid(unsafe_code)] +#![cfg_attr(coverage_nightly, feature(coverage_attribute))] + +#[cfg(target_arch = "wasm32")] +mod browser; +mod connector; +#[cfg(any(target_arch = "wasm32", test))] +mod state; + +pub use connector::BrowserConnector; + +/// Composes the shared Nostr session with origin-thread browser socket I/O. +/// Construction performs no I/O and spawns no task. +pub fn create_transport( + config: radroots_transport_nostr::Config, +) -> radroots_transport_nostr::NostrTransport { + radroots_transport_nostr::NostrTransport::new(config, std::sync::Arc::new(BrowserConnector)) +} diff --git a/crates/transport_nostr_browser/src/state.rs b/crates/transport_nostr_browser/src/state.rs @@ -0,0 +1,164 @@ +//! Bounded owned data only. No JavaScript values cross this boundary. + +use futures::{channel::oneshot, task::AtomicWaker}; +use radroots_transport::host::websocket::{Admission, Error, Frame}; +use std::{ + collections::VecDeque, + sync::{Arc, Mutex, MutexGuard}, +}; + +pub(crate) const MAX_MESSAGE: usize = 512 * 1024; +pub(crate) const MAX_QUEUE_BYTES: usize = 4 * 1024 * 1024; +pub(crate) const MAX_QUEUE_MESSAGES: usize = 256; + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) enum Status { + Connecting, + Open, + Ended, + Failed(Error), +} + +pub(crate) struct SendRequest { + pub(crate) frame: Frame, + pub(crate) result: oneshot::Sender<Result<(), Error>>, +} + +pub(crate) struct State { + pub(crate) status: Status, + pub(crate) stopping: bool, + pub(crate) finished: bool, + pub(crate) outgoing: Option<SendRequest>, + incoming: VecDeque<Frame>, + bytes: usize, +} + +impl State { + fn check_enqueue(&self, bytes: usize, limit: usize) -> Result<(), Error> { + if self.stopping || self.status != Status::Open { + return Err(Error::Closed); + } + if bytes > limit + || self.incoming.len() >= MAX_QUEUE_MESSAGES + || bytes > MAX_QUEUE_BYTES.saturating_sub(self.bytes) + { + return Err(Error::Policy); + } + Ok(()) + } +} + +pub(crate) struct Shared { + state: Mutex<State>, + pub(crate) admission: Arc<dyn Admission>, + pub(crate) limit: usize, + pub(crate) actor: AtomicWaker, + pub(crate) reader: AtomicWaker, + pub(crate) closer: AtomicWaker, +} + +impl Shared { + pub(crate) fn new(admission: Arc<dyn Admission>, limit: usize) -> Self { + Self { + state: Mutex::new(State { + status: Status::Connecting, + stopping: false, + finished: false, + outgoing: None, + incoming: VecDeque::new(), + bytes: 0, + }), + admission, + limit: limit.min(MAX_MESSAGE), + actor: AtomicWaker::new(), + reader: AtomicWaker::new(), + closer: AtomicWaker::new(), + } + } + + pub(crate) fn lock(&self) -> Result<MutexGuard<'_, State>, Error> { + self.state.lock().map_err(|_| Error::Closed) + } + + pub(crate) fn wake(&self) { + self.actor.wake(); + self.reader.wake(); + self.closer.wake(); + } + + pub(crate) fn stop(&self) { + if let Ok(mut state) = self.lock() { + state.stopping = true; + } + self.wake(); + } + + pub(crate) fn fail(&self, error: Error) { + if let Ok(mut state) = self.lock() { + // The first refusal remains authoritative through later callbacks. + if !matches!(state.status, Status::Failed(_)) { + state.status = Status::Failed(error); + } + state.incoming.clear(); + state.bytes = 0; + } + self.wake(); + } + + pub(crate) fn push(&self, frame: Frame) -> Result<(), Error> { + let bytes = payload_len(&frame)?; + self.lock()?.check_enqueue(bytes, self.limit)?; + // Admission may wake or cancel an observer. Call it without our lock, + // then revalidate closure and queue credit before exposing the frame. + if !self.admission.charge(bytes, 1, 1) { + return Err(Error::Policy); + } + let mut state = self.lock()?; + state.check_enqueue(bytes, self.limit)?; + state.bytes += bytes; + state.incoming.push_back(frame); + drop(state); + self.wake(); + Ok(()) + } + + pub(crate) fn pop(&self) -> Result<Option<Frame>, Error> { + let mut state = self.lock()?; + if let Status::Failed(error) = state.status { + return Err(error); + } + let frame = state.incoming.pop_front(); + if let Some(frame) = &frame { + state.bytes -= payload_len(frame)?; + } + Ok(frame) + } + + pub(crate) fn finish(&self) { + let outgoing = if let Ok(mut state) = self.lock() { + state.finished = true; + if !matches!(state.status, Status::Failed(_)) { + state.status = Status::Ended; + } + state.outgoing.take() + } else { + None + }; + if let Some(request) = outgoing { + let _ = request.result.send(Err(Error::Closed)); + } + self.wake(); + } +} + +pub(crate) fn payload_len(frame: &Frame) -> Result<usize, Error> { + match frame { + Frame::Text(text) => Ok(text.len()), + Frame::Binary(bytes) => Ok(bytes.len()), + _ => Err(Error::Unsupported), + } +} + +#[cfg(test)] +#[path = "state_tests.rs"] +pub(crate) mod tests; diff --git a/crates/transport_nostr_browser/src/state_tests.rs b/crates/transport_nostr_browser/src/state_tests.rs @@ -0,0 +1,240 @@ +use super::*; +use std::{ + net::IpAddr, + sync::atomic::{AtomicBool, AtomicUsize, Ordering}, + task::Context, +}; + +pub(crate) struct AdmissionCounter { + allow: AtomicBool, + bytes: AtomicUsize, + frames: AtomicUsize, + cancelling: Mutex<Option<std::sync::Weak<Shared>>>, +} +impl AdmissionCounter { + pub(crate) fn new(allow: bool) -> Arc<Self> { + Arc::new(Self { + allow: AtomicBool::new(allow), + bytes: AtomicUsize::new(0), + frames: AtomicUsize::new(0), + cancelling: Mutex::new(None), + }) + } +} +impl Admission for AdmissionCounter { + fn permits_address(&self, _: IpAddr) -> bool { + self.allow.load(Ordering::SeqCst) + } + fn admitted_read(&self, _: &Context<'_>) -> bool { + self.allow.load(Ordering::SeqCst) + } + fn admitted_write(&self, _: &Context<'_>) -> bool { + self.allow.load(Ordering::SeqCst) + } + fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool { + assert_eq!(frames, data); + self.bytes.fetch_add(bytes, Ordering::SeqCst); + self.frames.fetch_add(frames, Ordering::SeqCst); + let cancelling = self.cancelling.lock().unwrap().clone(); + if let Some(shared) = cancelling.and_then(|weak| weak.upgrade()) { + // Fail promptly rather than deadlocking the regression if a host + // calls the admission callback while holding its own state lock. + if shared.state.try_lock().is_err() { + return false; + } + shared.stop(); + } + self.allow.load(Ordering::SeqCst) + } +} +fn shared(limit: usize) -> (Shared, Arc<AdmissionCounter>) { + let admission = AdmissionCounter::new(true); + (Shared::new(admission.clone(), limit), admission) +} +fn open(limit: usize) -> (Shared, Arc<AdmissionCounter>) { + let result = shared(limit); + result.0.lock().unwrap().status = Status::Open; + result +} + +#[test] +fn original_binary_and_text_are_charged_once_and_dequeue_releases_bytes() { + let (shared, admission) = open(64); + assert_eq!(shared.pop(), Ok(None)); + let frames = [ + Frame::Text(" [\"raw\", 3] ".into()), + Frame::Binary(vec![0, 255, 12]), + ]; + for frame in &frames { + shared.push(frame.clone()).unwrap(); + } + assert_eq!(admission.bytes.load(Ordering::SeqCst), 16); + assert_eq!(admission.frames.load(Ordering::SeqCst), 2); + for frame in frames { + assert_eq!(shared.pop(), Ok(Some(frame))); + } + assert_eq!(shared.lock().unwrap().bytes, 0); +} + +#[test] +fn item_limit_counts_empty_messages_and_never_charges_rejected_queue_work() { + let (shared, admission) = open(1); + for _ in 0..MAX_QUEUE_MESSAGES { + shared.push(Frame::Text(String::new())).unwrap(); + } + assert_eq!(shared.push(Frame::Binary(vec![])), Err(Error::Policy)); + assert_eq!(admission.frames.load(Ordering::SeqCst), MAX_QUEUE_MESSAGES); + assert_eq!(shared.pop(), Ok(Some(Frame::Text(String::new())))); + shared.push(Frame::Binary(vec![])).unwrap(); +} + +#[test] +fn byte_limit_is_exact_and_newly_freed_credit_is_reusable() { + let (shared, _) = open(MAX_MESSAGE); + for _ in 0..8 { + shared.push(Frame::Binary(vec![7; MAX_MESSAGE])).unwrap(); + } + assert_eq!(shared.lock().unwrap().bytes, MAX_QUEUE_BYTES); + assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Policy)); + shared.pop().unwrap(); + shared.push(Frame::Binary(vec![9; MAX_MESSAGE])).unwrap(); + assert_eq!(shared.lock().unwrap().bytes, MAX_QUEUE_BYTES); +} + +#[test] +fn message_limit_and_control_frames_refuse_before_charging() { + let (shared, admission) = open(2); + assert_eq!(shared.push(Frame::Text("abc".into())), Err(Error::Policy)); + assert_eq!(shared.push(Frame::Ping(vec![])), Err(Error::Unsupported)); + assert_eq!(shared.push(Frame::Pong(vec![])), Err(Error::Unsupported)); + assert_eq!(shared.push(Frame::Close(None)), Err(Error::Unsupported)); + assert_eq!(admission.frames.load(Ordering::SeqCst), 0); + shared.push(Frame::Text("é".into())).unwrap(); + assert_eq!(admission.bytes.load(Ordering::SeqCst), 2); + assert_eq!(Shared::new(admission, usize::MAX).limit, MAX_MESSAGE); +} + +#[test] +fn admission_refusal_never_exposes_the_original_payload() { + let (shared, admission) = open(4); + admission.allow.store(false, Ordering::SeqCst); + assert_eq!(shared.push(Frame::Text("deny".into())), Err(Error::Policy)); + assert_eq!(shared.pop(), Ok(None)); + assert_eq!(admission.bytes.load(Ordering::SeqCst), 4); +} + +#[test] +fn first_failure_survives_subsequent_failure_close_and_finish() { + let (shared, _) = open(4); + shared.push(Frame::Text("live".into())).unwrap(); + shared.fail(Error::Policy); + shared.fail(Error::Unavailable); + shared.stop(); + shared.finish(); + shared.finish(); + assert_eq!(shared.pop(), Err(Error::Policy)); + let state = shared.lock().unwrap(); + assert_eq!(state.status, Status::Failed(Error::Policy)); + assert!(state.finished && state.stopping); + assert_eq!(state.bytes, 0); +} + +#[test] +fn graceful_finish_preserves_original_queued_frames_and_fails_pending_send() { + let (shared, _) = open(8); + shared.push(Frame::Binary(vec![1, 2, 3])).unwrap(); + let (sender, receiver) = oneshot::channel(); + shared.lock().unwrap().outgoing = Some(SendRequest { + frame: Frame::Text("send".into()), + result: sender, + }); + assert_eq!( + shared.lock().unwrap().outgoing.as_ref().unwrap().frame, + Frame::Text("send".into()) + ); + shared.finish(); + assert_eq!( + futures::executor::block_on(receiver), + Ok(Err(Error::Closed)) + ); + assert_eq!(shared.pop(), Ok(Some(Frame::Binary(vec![1, 2, 3])))); + assert_eq!(shared.pop(), Ok(None)); + assert_eq!(shared.lock().unwrap().status, Status::Ended); +} + +#[test] +fn connecting_stopping_ended_and_failed_refuse_new_payloads() { + let (shared, _) = shared(4); + assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed)); + for status in [Status::Ended, Status::Failed(Error::Policy)] { + shared.lock().unwrap().status = status; + assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed)); + } + shared.lock().unwrap().status = Status::Open; + shared.stop(); + assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed)); +} + +#[test] +fn poisoned_state_refuses_and_cleanup_does_not_panic() { + let (shared, _) = shared(1); + let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _guard = shared.state.lock().unwrap(); + panic!("deliberate test poison"); + })); + assert!(matches!(shared.lock(), Err(Error::Closed))); + assert_eq!(shared.push(Frame::Text("x".into())), Err(Error::Closed)); + assert_eq!(shared.pop(), Err(Error::Closed)); + shared.fail(Error::Policy); + shared.stop(); + shared.finish(); +} + +#[test] +fn admission_callback_can_cancel_before_a_frame_is_exposed() { + let admission = AdmissionCounter::new(true); + let shared = Arc::new(Shared::new(admission.clone(), 8)); + *admission.cancelling.lock().unwrap() = Some(Arc::downgrade(&shared)); + shared.lock().unwrap().status = Status::Open; + assert_eq!( + shared.push(Frame::Text("original".into())), + Err(Error::Closed) + ); + assert_eq!(shared.pop(), Ok(None)); +} + +#[test] +fn send_completion_wakes_its_observer_after_releasing_the_host_lock() { + use std::{future::Future, pin::Pin}; + struct Observer { + shared: Arc<Shared>, + locked: AtomicBool, + } + impl futures::task::ArcWake for Observer { + fn wake_by_ref(this: &Arc<Self>) { + if this.shared.state.try_lock().is_err() { + this.locked.store(true, Ordering::SeqCst); + } + } + } + let (shared, _) = open(8); + let shared = Arc::new(shared); + let observer = Arc::new(Observer { + shared: shared.clone(), + locked: AtomicBool::new(false), + }); + let waker = futures::task::waker(observer.clone()); + let mut context = Context::from_waker(&waker); + let (sender, mut receiver) = oneshot::channel(); + assert!(Pin::new(&mut receiver).poll(&mut context).is_pending()); + shared.lock().unwrap().outgoing = Some(SendRequest { + frame: Frame::Text("original".into()), + result: sender, + }); + shared.finish(); + assert!(!observer.locked.load(Ordering::SeqCst)); + assert_eq!( + futures::executor::block_on(receiver), + Ok(Err(Error::Closed)) + ); +} diff --git a/crates/transport_nostr_browser/tests/browser/Cargo.lock b/crates/transport_nostr_browser/tests/browser/Cargo.lock @@ -0,0 +1,2613 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "addr2line" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "aead" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" +dependencies = [ + "crypto-common", + "generic-array", +] + +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" + +[[package]] +name = "async-utility" +version = "0.3.2" +source = "git+https://github.com/yukibtc/async-utility?rev=b323ae0c1c1424b78bf8bb8832b95e86771f1dee#b323ae0c1c1424b78bf8bb8832b95e86771f1dee" +dependencies = [ + "futures-util", + "gloo-timers", + "tokio", + "wasm-bindgen-futures", +] + +[[package]] +name = "async-wsocket" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c713e1f14c7b82e32ea159af1c6e2f070cfadbdf23fb2512acce9af0a26f1a2" +dependencies = [ + "futures", + "futures-util", + "js-sys", + "tokio", + "tokio-happy-eyeballs", + "tokio-rustls", + "tokio-socks", + "tokio-tungstenite", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "backtrace" +version = "0.3.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6" +dependencies = [ + "addr2line", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", + "windows-link", +] + +[[package]] +name = "base16ct" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "base64ct" +version = "1.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" + +[[package]] +name = "bech32" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32637268377fc7b10a8c6d51de3e7fba1ce5dd371a96e342b34e6078db558e7f" + +[[package]] +name = "bech32" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "efbd3e1070bbdf4cd88a75264e18e8a26f7cb5c6949eadf0ceb85fb159cf08f8" + +[[package]] +name = "bip39" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90dbd31c98227229239363921e60fcf5e558e43ec69094d46fc4996f08d1d5bc" +dependencies = [ + "bitcoin_hashes 0.14.1", + "serde", + "unicode-normalization", +] + +[[package]] +name = "bitcoin-consensus-encoding" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9daa31138eb443d5751b207f3f64154e2bb09cd59960562ccc7a7112be38147f" +dependencies = [ + "bitcoin-internals 0.7.0", +] + +[[package]] +name = "bitcoin-internals" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d573f4cf32996a8dce612e4348cece65a241f1882ed594047c9ba348e8869fa5" + +[[package]] +name = "bitcoin-internals" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8bea3a9f0cfece4564e37cb49a38cc245ca5184719e50d7d0dda3268722c4e2" + +[[package]] +name = "bitcoin-io" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dee39a0ee5b4095224a0cfc6bf4cc1baf0f9624b96b367e53b66d974e51d953" + +[[package]] +name = "bitcoin_hashes" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26ec84b80c482df901772e931a9a681e26a1b9ee2302edeff23cb30328745c8b" +dependencies = [ + "bitcoin-io", + "hex-conservative 0.2.2", + "serde", +] + +[[package]] +name = "bitcoin_hashes" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5304e53726dbe5f93141535e102ed97b5bf4714fbecefdda8f9fb98d7fdaff0e" +dependencies = [ + "bitcoin-consensus-encoding", + "bitcoin-internals 0.6.0", + "hex-conservative 1.3.0", + "serde", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af" + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "block-padding" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93" +dependencies = [ + "generic-array", +] + +[[package]] +name = "bumpalo" +version = "3.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" + +[[package]] +name = "cbc" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6" +dependencies = [ + "cipher", +] + +[[package]] +name = "cc" +version = "1.2.57" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "chacha20" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + +[[package]] +name = "chacha20poly1305" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35" +dependencies = [ + "aead", + "chacha20", + "cipher", + "poly1305", + "zeroize", +] + +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common", + "inout", + "zeroize", +] + +[[package]] +name = "const-oid" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "crypto-bigint" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" +dependencies = [ + "generic-array", + "rand_core 0.6.4", + "subtle", + "zeroize", +] + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "rand_core 0.6.4", + "typenum", +] + +[[package]] +name = "data-encoding" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea" + +[[package]] +name = "defmt" +version = "0.3.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4deef977660e373c458df605a913d4ab121db0ccd18d1ad6976dff7d37cddb53" +dependencies = [ + "defmt 1.2.0", +] + +[[package]] +name = "defmt" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4a0795ac740cb54d7b3775c9c17345f6aaecf884c01733b39d6017738e0e3e1" +dependencies = [ + "bitflags 1.3.2", + "defmt-macros", +] + +[[package]] +name = "defmt-macros" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "840bb056bd99c495c9188198a258ab787c79f306d864db3e6e8451442d6d8366" +dependencies = [ + "defmt-parser", + "proc-macro2", + "quote", + "syn 3.0.2", +] + +[[package]] +name = "defmt-parser" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "71958f69fb2de856c5dd51ac9377e986ca1aa5919f931bf5395a807277f889a0" +dependencies = [ + "thiserror 2.0.18", +] + +[[package]] +name = "der" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" +dependencies = [ + "const-oid", + "zeroize", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", + "subtle", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "elliptic-curve" +version = "0.13.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" +dependencies = [ + "base16ct", + "crypto-bigint", + "ff", + "generic-array", + "group", + "rand_core 0.6.4", + "sec1", + "subtle", + "zeroize", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "faster-hex" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04839bdf9d8c10f66806fad16b852fc72aab80873aebc3cb69d85b4fa41543ed" +dependencies = [ + "autocfg", + "defmt 0.3.101", + "heapless", + "serde", +] + +[[package]] +name = "ff" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" +dependencies = [ + "rand_core 0.6.4", + "subtle", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "futures" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-executor" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718" + +[[package]] +name = "futures-macro" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "futures-sink" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893" + +[[package]] +name = "futures-task" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" + +[[package]] +name = "futures-util" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "slab", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", + "zeroize", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + +[[package]] +name = "getrandom" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "r-efi 6.0.0", + "rand_core 0.10.1", + "wasip2", + "wasip3", + "wasm-bindgen", +] + +[[package]] +name = "gimli" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" + +[[package]] +name = "gloo-timers" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994" +dependencies = [ + "futures-channel", + "futures-core", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "group" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +dependencies = [ + "ff", + "rand_core 0.6.4", + "subtle", +] + +[[package]] +name = "hash32" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606" +dependencies = [ + "byteorder", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" + +[[package]] +name = "heapless" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" +dependencies = [ + "hash32", + "stable_deref_trait", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hex-conservative" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fda06d18ac606267c40c04e41b9947729bf8b9efe74bd4e82b61a5f26a510b9f" +dependencies = [ + "arrayvec", +] + +[[package]] +name = "hex-conservative" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "271e0d19bcb473b6675739a2b536076b24a082316cb5199ad918edce10c599e8" +dependencies = [ + "arrayvec", +] + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest", +] + +[[package]] +name = "http" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "icu_collections" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a" + +[[package]] +name = "icu_properties" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af" + +[[package]] +name = "icu_provider" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614" +dependencies = [ + "displaydoc", + "icu_locale_core", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + +[[package]] +name = "idna" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6" +dependencies = [ + "unicode-bidi", + "unicode-normalization", +] + +[[package]] +name = "idna" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +dependencies = [ + "equivalent", + "hashbrown 0.16.1", + "serde", + "serde_core", +] + +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "block-padding", + "generic-array", +] + +[[package]] +name = "instant" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222" +dependencies = [ + "cfg-if", + "js-sys", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "io-uring" +version = "0.7.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9080b15e63775b9a2ac7dca720f7050a8b955e092ea0f6020a4a80f69998cdc0" +dependencies = [ + "bitflags 2.11.0", + "cfg-if", + "libc", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "jiff-tzdb" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e" + +[[package]] +name = "js-sys" +version = "0.3.91" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b49715b7073f385ba4bc528e5747d02e66cb39c6146efb66b781f131f0fb399c" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "k256" +version = "0.13.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b" +dependencies = [ + "cfg-if", + "elliptic-curve", +] + +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + +[[package]] +name = "libc" +version = "0.2.183" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d" + +[[package]] +name = "litemap" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77" + +[[package]] +name = "log" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" + +[[package]] +name = "lru" +version = "0.18.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef9ac18847474e638e3702b76c65d4eb93428471a74778ef0f1be711717f89b5" + +[[package]] +name = "mediatype" +version = "0.21.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "120fa187be19d9962f0926633453784691731018a2bf936ddb4e29101b79c4a7" + +[[package]] +name = "memchr" +version = "2.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", +] + +[[package]] +name = "mio" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc" +dependencies = [ + "libc", + "wasi", + "windows-sys 0.61.2", +] + +[[package]] +name = "negentropy" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a3d66662cb5ca384d4991509755ed5a42dd8e31c4282bf881938e506fc3146ec" + +[[package]] +name = "nostr" +version = "0.44.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7d3d987ea7078dc36947cde532637c472a229426702e4331dd7667325378bd9" +dependencies = [ + "aes", + "base64", + "bech32 0.11.1", + "bip39", + "bitcoin_hashes 0.14.1", + "cbc", + "chacha20", + "chacha20poly1305", + "getrandom 0.2.17", + "hex", + "instant", + "scrypt", + "secp256k1 0.29.1", + "serde", + "serde_json", + "unicode-normalization", + "url", + "url-fork", +] + +[[package]] +name = "nostr" +version = "0.45.5" +source = "git+https://github.com/nostrdevkit/nostr.git?rev=de3031aa99986eb29b3f34580355f9a099e4c927#de3031aa99986eb29b3f34580355f9a099e4c927" +dependencies = [ + "base64", + "bech32 0.12.0", + "bip39", + "bitcoin_hashes 1.2.0", + "cbc", + "chacha20", + "chacha20poly1305", + "faster-hex", + "opaquerr", + "rand 0.10.1", + "secp256k1 0.30.0", + "serde", + "serde_json", + "unicode-normalization", + "universal-time", + "url", + "zeroize", +] + +[[package]] +name = "nostr-database" +version = "0.45.2" +source = "git+https://github.com/nostrdevkit/nostr.git?rev=de3031aa99986eb29b3f34580355f9a099e4c927#de3031aa99986eb29b3f34580355f9a099e4c927" +dependencies = [ + "nostr 0.45.5", + "opaquerr", +] + +[[package]] +name = "nostr-gossip" +version = "0.45.1" +source = "git+https://github.com/nostrdevkit/nostr.git?rev=de3031aa99986eb29b3f34580355f9a099e4c927#de3031aa99986eb29b3f34580355f9a099e4c927" +dependencies = [ + "nostr 0.45.5", + "opaquerr", +] + +[[package]] +name = "nostr-sdk" +version = "0.45.4" +source = "git+https://github.com/nostrdevkit/nostr.git?rev=de3031aa99986eb29b3f34580355f9a099e4c927#de3031aa99986eb29b3f34580355f9a099e4c927" +dependencies = [ + "async-utility", + "async-wsocket", + "faster-hex", + "futures", + "lru", + "negentropy", + "nostr 0.45.5", + "nostr-database", + "nostr-gossip", + "opaquerr", + "rand 0.10.1", + "tokio", + "tokio-stream", + "tracing", + "universal-time", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "memchr", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "opaque-debug" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" + +[[package]] +name = "opaquerr" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f933a4265d5cdad61d19bbdfc972ea5726d56cd8d3d57b8f2d3c365dd42bee9" + +[[package]] +name = "password-hash" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166" +dependencies = [ + "base64ct", + "rand_core 0.6.4", + "subtle", +] + +[[package]] +name = "pbkdf2" +version = "0.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2" +dependencies = [ + "digest", + "hmac", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "poly1305" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf" +dependencies = [ + "cpufeatures", + "opaque-debug", + "universal-hash", +] + +[[package]] +name = "potential_utf" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77" +dependencies = [ + "zerovec", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn 2.0.117", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "radroots_blossom" +version = "0.1.0-alpha" +dependencies = [ + "mediatype", + "serde", + "sha2", + "unicode-general-category", + "url", +] + +[[package]] +name = "radroots_core" +version = "0.1.0-alpha" +dependencies = [ + "rust_decimal", + "serde", +] + +[[package]] +name = "radroots_event" +version = "0.1.0-alpha" +dependencies = [ + "hex", + "jiff-tzdb", + "radroots_blossom", + "radroots_core", + "radroots_identity", + "radroots_protocol", + "serde", + "serde_json", + "sha2", + "unicode-general-category", + "url", +] + +[[package]] +name = "radroots_event_codec" +version = "0.1.0-alpha" +dependencies = [ + "hex", + "radroots_blossom", + "radroots_core", + "radroots_event", + "radroots_identity", + "radroots_protocol", + "secp256k1 0.29.1", + "serde", + "serde_json", + "sha2", +] + +[[package]] +name = "radroots_identity" +version = "0.1.0-alpha" +dependencies = [ + "k256", + "serde", + "thiserror 2.0.18", +] + +[[package]] +name = "radroots_nostr" +version = "0.1.0-alpha" +dependencies = [ + "nostr 0.44.7", + "radroots_event", + "radroots_event_codec", + "radroots_identity", + "serde", + "serde_json", + "thiserror 2.0.18", + "zeroize", +] + +[[package]] +name = "radroots_nostr_socket_browser_fixture" +version = "0.0.0" +dependencies = [ + "async-utility", + "futures", + "js-sys", + "radroots_event_codec", + "radroots_transport", + "radroots_transport_nostr", + "radroots_transport_nostr_browser", + "serde_json", + "universal-time", + "wasm-bindgen", + "wasm-bindgen-futures", +] + +[[package]] +name = "radroots_protocol" +version = "0.1.0-alpha" +dependencies = [ + "radroots_identity", + "serde", + "sha2", + "zeroize", +] + +[[package]] +name = "radroots_transport" +version = "0.1.0-alpha" +dependencies = [ + "radroots_event", + "radroots_identity", + "radroots_protocol", + "serde", + "sha2", +] + +[[package]] +name = "radroots_transport_nostr" +version = "0.1.0-alpha" +dependencies = [ + "async-utility", + "async-wsocket", + "futures", + "getrandom 0.4.2", + "nostr-sdk", + "radroots_event_codec", + "radroots_nostr", + "radroots_protocol", + "radroots_transport", + "serde_json", + "sha2", + "tokio", + "url", + "wasm-bindgen-futures", + "web-time", +] + +[[package]] +name = "radroots_transport_nostr_browser" +version = "0.1.0-alpha" +dependencies = [ + "async-utility", + "futures", + "js-sys", + "radroots_transport", + "radroots_transport_nostr", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "web-time", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha 0.3.1", + "rand_core 0.6.4", +] + +[[package]] +name = "rand" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +dependencies = [ + "rand_chacha 0.9.0", + "rand_core 0.9.5", +] + +[[package]] +name = "rand" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" +dependencies = [ + "getrandom 0.4.2", + "rand_core 0.10.1", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", +] + +[[package]] +name = "rand_core" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "rust_decimal" +version = "1.40.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61f703d19852dbf87cbc513643fa81428361eb6940f1ac14fd58155d295a3eb0" +dependencies = [ + "arrayvec", + "num-traits", + "serde", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b74b56ffa8bb2830709a538c2cbcae9aa062db0d2a42563bfb09bdaae44020eb" + +[[package]] +name = "rustls" +version = "0.23.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf" +dependencies = [ + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-pki-types" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd" +dependencies = [ + "zeroize", +] + +[[package]] +name = "rustls-webpki" +version = "0.103.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2" +dependencies = [ + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "salsa20" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213" +dependencies = [ + "cipher", +] + +[[package]] +name = "scrypt" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f" +dependencies = [ + "password-hash", + "pbkdf2", + "salsa20", + "sha2", +] + +[[package]] +name = "sec1" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" +dependencies = [ + "base16ct", + "der", + "generic-array", + "subtle", + "zeroize", +] + +[[package]] +name = "secp256k1" +version = "0.29.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9465315bc9d4566e1724f0fffcbcc446268cb522e60f9a27bcded6b19c108113" +dependencies = [ + "rand 0.8.5", + "secp256k1-sys", + "serde", +] + +[[package]] +name = "secp256k1" +version = "0.30.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252" +dependencies = [ + "bitcoin_hashes 0.14.1", + "rand 0.8.5", + "secp256k1-sys", +] + +[[package]] +name = "secp256k1-sys" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9" +dependencies = [ + "cc", +] + +[[package]] +name = "semver" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "serde_json" +version = "1.0.149" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "sha1" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "socket2" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e" +dependencies = [ + "libc", + "windows-sys 0.60.2", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a207d6d6a2b7fc470b80443726053f18a2481b7e1eee970597051596567987a3" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" +dependencies = [ + "thiserror-impl 2.0.18", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "tinystr" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "tinyvec" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" + +[[package]] +name = "tokio" +version = "1.47.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038" +dependencies = [ + "backtrace", + "bytes", + "io-uring", + "libc", + "mio", + "pin-project-lite", + "slab", + "socket2", + "tokio-macros", + "windows-sys 0.59.0", +] + +[[package]] +name = "tokio-happy-eyeballs" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8564c32dfb6f4257f8bc6edfc178a34af97520e0b7b9815500c55eb3d092f29f" +dependencies = [ + "tokio", +] + +[[package]] +name = "tokio-macros" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "tokio-rustls" +version = "0.26.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61" +dependencies = [ + "rustls", + "tokio", +] + +[[package]] +name = "tokio-socks" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7e2948f60dbe26b35f2c7fb74ac2854c1fddded0fe9d7548fcc674a246f7615" +dependencies = [ + "either", + "futures-util", + "thiserror 1.0.69", + "tokio", +] + +[[package]] +name = "tokio-stream" +version = "0.1.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70" +dependencies = [ + "futures-core", + "pin-project-lite", + "tokio", + "tokio-util", +] + +[[package]] +name = "tokio-tungstenite" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857" +dependencies = [ + "futures-util", + "log", + "rustls", + "rustls-pki-types", + "tokio", + "tokio-rustls", + "tungstenite", + "webpki-roots 0.26.11", +] + +[[package]] +name = "tokio-util" +version = "0.7.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-core", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", +] + +[[package]] +name = "tungstenite" +version = "0.28.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442" +dependencies = [ + "bytes", + "data-encoding", + "http", + "httparse", + "log", + "rand 0.9.2", + "rustls", + "rustls-pki-types", + "sha1", + "thiserror 2.0.18", + "utf-8", +] + +[[package]] +name = "typenum" +version = "1.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" + +[[package]] +name = "unicode-bidi" +version = "0.3.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5" + +[[package]] +name = "unicode-general-category" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b993bddc193ae5bd0d623b49ec06ac3e9312875fdae725a975c51db1cc1677f" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unicode-normalization" +version = "0.1.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "universal-hash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" +dependencies = [ + "crypto-common", + "subtle", +] + +[[package]] +name = "universal-time" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47a939edecc3c5a7b83c02e5f6b3c31d2bc69eabcc9a87ab12c6d37ee6dbc856" + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "url" +version = "2.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" +dependencies = [ + "form_urlencoded", + "idna 1.1.0", + "percent-encoding", + "serde", + "serde_derive", +] + +[[package]] +name = "url-fork" +version = "3.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fa3323c39b8e786154d3000b70ae9af0e9bd746c9791456da0d4a1f68ad89d6" +dependencies = [ + "form_urlencoded", + "idna 0.5.0", + "percent-encoding", + "serde", +] + +[[package]] +name = "utf-8" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.2+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6532f9a5c1ece3798cb1c2cfdba640b9b3ba884f5db45973a6f442510a87d38e" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.64" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e9c5522b3a28661442748e09d40924dfb9ca614b21c00d3fd135720e48b67db8" +dependencies = [ + "cfg-if", + "futures-util", + "js-sys", + "once_cell", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18a2d50fcf105fb33bb15f00e7a77b772945a2ee45dcf454961fd843e74c18e6" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03ce4caeaac547cdf713d280eda22a730824dd11e6b8c3ca9e42247b25c631e3" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 2.0.117", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder", + "wasmparser", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags 2.11.0", + "hashbrown 0.15.5", + "indexmap", + "semver", +] + +[[package]] +name = "web-sys" +version = "0.3.91" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "854ba17bb104abfb26ba36da9729addc7ce7f06f5c0f90f3c391f8461cca21f9" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-roots" +version = "0.26.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9" +dependencies = [ + "webpki-roots 1.0.6", +] + +[[package]] +name = "webpki-roots" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm 0.52.6", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn 2.0.117", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn 2.0.117", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" +dependencies = [ + "anyhow", + "bitflags 2.11.0", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", +] + +[[package]] +name = "writeable" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" + +[[package]] +name = "yoke" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", + "synstructure", +] + +[[package]] +name = "zerocopy" +version = "0.8.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e8bc7269b54418e7aeeef514aa68f8690b8c0489a06b0136e5f57c4c5ccab89" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", + "synstructure", +] + +[[package]] +name = "zeroize" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e" + +[[package]] +name = "zerotrie" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.117", +] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" + +[[patch.unused]] +name = "radroots_geonames" +version = "0.1.0-alpha" + +[[patch.unused]] +name = "radroots_nostr_connect" +version = "0.1.0-alpha" + +[[patch.unused]] +name = "radroots_secrets" +version = "0.1.0-alpha" + +[[patch.unused]] +name = "radroots_signing" +version = "0.1.0-alpha" + +[[patch.unused]] +name = "radroots_storage" +version = "0.1.0-alpha" + +[[patch.unused]] +name = "radroots_storage_sqlite" +version = "0.1.0-alpha" + +[[patch.unused]] +name = "radroots_sync" +version = "0.1.0-alpha" + +[[patch.unused]] +name = "radroots_trade" +version = "0.1.0-alpha" diff --git a/crates/transport_nostr_browser/tests/browser/Cargo.toml b/crates/transport_nostr_browser/tests/browser/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "radroots_nostr_socket_browser_fixture" +version = "0.0.0" +publish = false +edition = "2024" +rust-version = "1.99.0" + +[workspace] + +[lib] +crate-type = ["cdylib"] + +[dependencies] +radroots_transport_nostr_browser = { path = "../.." } +radroots_transport_nostr = { path = "../../../transport_nostr" } +radroots_transport = { path = "../../../transport", features = ["std"] } +radroots_event_codec = { path = "../../../event_codec", default-features = false, features = ["json"] } +serde_json = "=1.0.149" +futures = "=0.3.32" +async-utility = { git = "https://github.com/yukibtc/async-utility", rev = "b323ae0c1c1424b78bf8bb8832b95e86771f1dee", version = "=0.3.2" } +js-sys = "=0.3.91" +wasm-bindgen = "=0.2.114" +wasm-bindgen-futures = "=0.4.64" +universal-time = "=0.3.1" diff --git a/crates/transport_nostr_browser/tests/browser/run.mjs b/crates/transport_nostr_browser/tests/browser/run.mjs @@ -0,0 +1,158 @@ +import assert from 'node:assert/strict'; +import {createRequire} from 'node:module'; +import {createServer} from 'node:http'; +import {readFile} from 'node:fs/promises'; +import {resolve} from 'node:path'; + +const [tools, packageDir, engine = 'chromium'] = process.argv.slice(2); +assert(tools && packageDir && ['chromium', 'firefox', 'webkit'].includes(engine)); +const require = createRequire(resolve(tools, 'package.json')); +const playwright = require('playwright'); +// Use the already locked browser harness's server implementation; no new +// product dependency, relay implementation or protocol client is introduced. +const {wsServer: WebSocketServer} = require(resolve(tools, 'node_modules/playwright-core/lib/utilsBundle.js')); +const wss = new WebSocketServer({noServer: true}); +const sockets = new Set(); +const upgrades = []; +const observed = []; +process.on('uncaughtExceptionMonitor',()=>console.error(JSON.stringify({engine,upgrades,observed}))); +const vectors = JSON.parse(await readFile('contracts/conformance/vectors/event/verified_admission.v1.json','utf8')); +const event = vectors.vectors[1].input.event; + +const observer = ` +const ActualWebSocket=globalThis.WebSocket, observedSockets=[]; +const actualTimeout=globalThis.setTimeout,actualClear=globalThis.clearTimeout,activeTimers=new Set(); +globalThis.setTimeout=(callback,delay,...args)=>{ + let id;id=actualTimeout.call(globalThis,(...values)=>{activeTimers.delete(id);callback(...values);},delay,...args);activeTimers.add(id);return id; +}; +globalThis.clearTimeout=id=>{activeTimers.delete(id);return actualClear.call(globalThis,id);}; +globalThis.WebSocket=class extends ActualWebSocket { + constructor(...args){super(...args);observedSockets.push(this);} +}; +globalThis.waitForBrowserSocketClose=async route=>{ + const socket=observedSockets.findLast(socket=>socket.url.endsWith('/'+route)); + if(!socket)throw Error('missing actual socket: '+route); + const deadline=performance.now()+5000; + while(socket.readyState!==ActualWebSocket.CLOSED){ + if(performance.now()>=deadline)throw Error('socket did not close: '+route); + await new Promise(resolve=>setTimeout(resolve,10)); + } +}; +globalThis.forceBrowserSocketBackpressure=()=>{ + Object.defineProperty(observedSockets.at(-1),'bufferedAmount',{get(){return 4*1024*1024;}}); +}; +async function verifyCleanup(checkTimers=true){ + await new Promise(resolve=>setTimeout(resolve,80)); + for(const socket of observedSockets){ + if(socket.onopen||socket.onmessage||socket.onerror||socket.onclose)throw Error('retained socket callback'); + if(socket.readyState!==ActualWebSocket.CLOSED)throw Error('retained open socket: '+socket.url+' state='+socket.readyState); + } + const inert=['unpolled','cancelled-owner','revoked-owner','expired-owner']; + if(observedSockets.some(socket=>inert.some(route=>socket.url.endsWith('/'+route))))throw Error('inert or expired connection performed I/O'); + if(observedSockets.filter(socket=>socket.url.endsWith('/stall')).length!==2)throw Error('missing original pending handshake attempts'); + if(checkTimers && activeTimers.size)throw Error('retained browser socket timer: '+activeTimers.size); + return observedSockets.length; +}`; +const execute = ` +const {default:init,verify_socket,verify_shared_session,fixture_event}=await import('./fixture.js');await init(); +const passed=Array.from(await verify_socket(base));const directDisposed=await verifyCleanup(); +const shared=Array.from(await verify_shared_session(base));const disposed=await verifyCleanup(false); +return {passed,shared,directDisposed,disposed,expectedRaw:fixture_event()};`; +const worker = `${observer} +self.onmessage=async event=>{try{const base=event.data;const run=async()=>{${execute}};self.postMessage(await run());} +catch(error){self.postMessage({error:String(error)});}};`; +const server = createServer(async (req, res) => { + try { + if(req.url==='/'){res.setHeader('content-type','text/html');res.end('<!doctype html><title>Browser socket fixture</title>');return;} + if(req.url==='/worker.js'){res.setHeader('content-type','text/javascript');res.end(worker);return;} + const name = new Map([['/fixture.js','fixture.js'],['/fixture_bg.wasm','fixture_bg.wasm']]).get(req.url); + if(!name){res.statusCode=404;res.end();return;} + res.setHeader('content-type',name.endsWith('.wasm')?'application/wasm':'text/javascript'); + res.end(await readFile(resolve(packageDir,name))); + } catch {res.statusCode=500;res.end();} +}); +server.on('connection',socket=>{sockets.add(socket);socket.on('close',()=>sockets.delete(socket));}); +server.on('upgrade',(req,socket,head)=>{ + upgrades.push(req.url); + if(req.url==='/stall')return; // Original pending HTTP upgrade, closed by its owner. + wss.handleUpgrade(req,socket,head,ws=>{ + ws.on('error',()=>{}); + if(req.url==='/echo')ws.on('message',(data,binary)=>{observed.push({route:req.url,binary,bytes:data.length});ws.send(data,{binary});}); + else if(req.url==='/oversize')ws.send('a'.repeat(1025)); + else if(req.url==='/unicode')ws.send('é'.repeat(800)); + else if(req.url==='/binary-large')ws.send(Buffer.alloc(1025)); + else if(req.url==='/items')for(let i=0;i<257;i++)ws.send(''); + else if(req.url==='/bytes')for(let i=0;i<9;i++)ws.send(Buffer.alloc(512*1024)); + else if(req.url==='/disconnect'){ws.send('before close');ws.close(1000,'peer done');} + else if(req.url.startsWith('/shared-'))ws.on('message',(data,binary)=>{ + if(binary)return; + const wire=data.toString(),message=JSON.parse(wire); + observed.push({route:req.url,wire}); + if(message[0]==='REQ'){ + if(req.url==='/shared-disconnect'){ws.close(1000,'history interrupted');return;} + if(req.url==='/shared-observer')return; + ws.send(JSON.stringify(['EVENT',message[1],event])); + ws.send(JSON.stringify(['EOSE',message[1]])); + }else if(message[0]==='EVENT'){ + if(req.url==='/shared-noack')return; + if(req.url==='/shared-badack'){ws.send(JSON.stringify(['OK',message[1].id+'00',true,'']));return;} + ws.send(JSON.stringify(['OK','11'.repeat(32),true,'unrelated'])); + ws.send(JSON.stringify(['OK',message[1].id,req.url!=='/shared-negative',''])); + } + }); + }); +}); +await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve)); +const base=`ws://127.0.0.1:${server.address().port}`; +let browser; +const deadline=setTimeout(()=>{void browser?.close();},120000);deadline.unref(); +try { + // The locked Juggler driver asserts when worker WebSocket-open events lack + // its page request record. Use its supported BiDi channel with the exact same + // cached Firefox executable; retain every real worker/product assertion. + const automation=engine==='firefox'?'webdriver_bidi':'playwright_default'; + const options=engine==='firefox'?{headless:true,channel:'moz-firefox-nightly',executablePath:playwright.firefox.executablePath()}:{headless:true}; + browser=await playwright[engine].launch(options); + const page=await browser.newPage(); + const errors=[],expectedUserAgentDiagnostics=[]; + const expectedDiagnostics=new Set([ + `Firefox can’t establish a connection to the server at ${base}/stall.`, + `The connection to ${base}/stall was interrupted while the page was loading.`, + ]); + page.on('pageerror',error=>{ + // BiDi reports these user-agent diagnostics as script errors for the two + // deliberately interrupted handshakes. Retain the exact messages separately; + // every other error still fails, including exceptions from product code. + if(engine==='firefox' && automation==='webdriver_bidi' && expectedDiagnostics.has(error.message))expectedUserAgentDiagnostics.push(error.message); + else errors.push(error.message); + }); + await page.goto(`http://127.0.0.1:${server.address().port}/`); + await page.addScriptTag({content:observer}); + const main=await page.evaluate(new Function('base',`return (async()=>{${execute}})();`),base); + console.error(JSON.stringify({phase:'main_completed',engine,result:main})); + const dedicated=await page.evaluate(base=>new Promise((resolve,reject)=>{ + const worker=new Worker('./worker.js',{type:'module'}); + worker.onerror=event=>{worker.terminate();reject(Error(event.message));}; + worker.onmessage=event=>{worker.terminate();event.data.error?reject(Error(event.data.error)):resolve(event.data);}; + worker.postMessage(base); + }),base); + assert.equal(main.passed.length,19); + assert.equal(main.shared.length,7); + assert.deepEqual(main,dedicated); + assert.deepEqual(errors,[]); + assert(!upgrades.includes('/unpolled')); + const publications=observed.filter(item=>item.wire?.startsWith('["EVENT",')); + assert.equal(publications.length,8); + for(const publication of publications)assert.equal(publication.wire,`["EVENT",${main.expectedRaw}]`); + // A deadline may expire before the user agent transmits an HTTP upgrade. + assert(upgrades.filter(path=>path==='/stall').length<=4); + assert(expectedUserAgentDiagnostics.length<=8); + console.log(JSON.stringify({engine,automation,version:browser.version(),main,dedicated,pageErrors:errors,expectedUserAgentDiagnostics,upgrades,observed})); +} finally { + clearTimeout(deadline); + await browser?.close(); + for(const client of wss.clients)client.terminate(); + for(const socket of sockets)socket.destroy(); + await new Promise(resolve=>wss.close(resolve)); + await new Promise(resolve=>server.close(resolve)); +} diff --git a/crates/transport_nostr_browser/tests/browser/src/clock.rs b/crates/transport_nostr_browser/tests/browser/src/clock.rs @@ -0,0 +1,26 @@ +//! The pinned SDK requires exactly one clock selection in the final WASM +//! artifact. This fixture is an artifact root, not a provider library. Use real +//! browser clocks in both pages and workers; never substitute a test timestamp. + +use std::time::Duration; +use universal_time::{Instant, MonotonicClock, SystemTime, WallClock}; +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +extern "C" { + #[wasm_bindgen(js_namespace = performance, js_name = now)] + fn monotonic_ms() -> f64; +} + +struct BrowserClock; +impl WallClock for BrowserClock { + fn system_time(&self) -> SystemTime { + SystemTime::from_unix_duration(Duration::from_secs_f64(js_sys::Date::now() / 1_000.0)) + } +} +impl MonotonicClock for BrowserClock { + fn instant(&self) -> Instant { + Instant::from_ticks(Duration::from_secs_f64(monotonic_ms() / 1_000.0)) + } +} +universal_time::define_time_provider!(BrowserClock); diff --git a/crates/transport_nostr_browser/tests/browser/src/lib.rs b/crates/transport_nostr_browser/tests/browser/src/lib.rs @@ -0,0 +1,328 @@ +#![forbid(unsafe_code)] + +mod clock; +mod shared; + +use futures::{FutureExt, task::AtomicWaker}; +use radroots_transport::host::websocket::{Admission, Connector, Error, Frame, Socket}; +use radroots_transport_nostr_browser::BrowserConnector; +use std::{ + net::IpAddr, + num::NonZeroUsize, + sync::{ + Arc, + atomic::{AtomicBool, AtomicUsize, Ordering}, + }, + task::Context, + time::Duration, +}; +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +extern "C" { + #[wasm_bindgen(js_namespace = globalThis, js_name = waitForBrowserSocketClose)] + fn wait_for_close(route: &str) -> js_sys::Promise; + #[wasm_bindgen(js_namespace = globalThis, js_name = forceBrowserSocketBackpressure)] + fn force_backpressure(); +} + +struct Grant { + live: AtomicBool, + charge: AtomicBool, + bytes: AtomicUsize, + frames: AtomicUsize, + reader: AtomicWaker, + writer: AtomicWaker, +} +impl Grant { + fn new() -> Arc<Self> { + Arc::new(Self { + live: AtomicBool::new(true), + charge: AtomicBool::new(true), + bytes: AtomicUsize::new(0), + frames: AtomicUsize::new(0), + reader: AtomicWaker::new(), + writer: AtomicWaker::new(), + }) + } + fn revoke(&self) { + self.live.store(false, Ordering::SeqCst); + self.reader.wake(); + self.writer.wake(); + } +} +impl Admission for Grant { + fn permits_address(&self, _: IpAddr) -> bool { + self.live.load(Ordering::SeqCst) + } + fn admitted_read(&self, context: &Context<'_>) -> bool { + self.reader.register(context.waker()); + self.live.load(Ordering::SeqCst) + } + fn admitted_write(&self, context: &Context<'_>) -> bool { + self.writer.register(context.waker()); + self.live.load(Ordering::SeqCst) + } + fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool { + assert_eq!(frames, data); + self.bytes.fetch_add(bytes, Ordering::SeqCst); + self.frames.fetch_add(frames, Ordering::SeqCst); + self.charge.load(Ordering::SeqCst) && self.live.load(Ordering::SeqCst) + } +} +fn check(value: bool, name: &str) -> Result<(), JsValue> { + if value { + Ok(()) + } else { + Err(JsValue::from_str(name)) + } +} +fn error(value: Error) -> JsValue { + JsValue::from_str(&value.to_string()) +} +async fn pause() { + async_utility::time::sleep(Duration::from_millis(40)).await; +} +async fn connect( + base: &str, + route: &str, + limit: usize, + grant: Arc<Grant>, +) -> Result<Arc<dyn Socket>, JsValue> { + BrowserConnector + .connect( + &format!("{base}/{route}"), + Duration::from_secs(2), + NonZeroUsize::new(limit).unwrap(), + grant, + ) + .await + .map_err(error) +} + +#[wasm_bindgen] +pub async fn verify_socket(base: String) -> Result<js_sys::Array, JsValue> { + let passed = js_sys::Array::new(); + let grant = Grant::new(); + let endpoint = format!("{base}/unpolled"); + let future = BrowserConnector.connect( + &endpoint, + Duration::from_secs(1), + NonZeroUsize::new(1024).unwrap(), + grant.clone(), + ); + drop(future); + pause().await; + passed.push(&"unpolled inert".into()); + + let endpoint = format!("{base}/cancelled-owner"); + let mut attempt = BrowserConnector.connect( + &endpoint, + Duration::from_secs(1), + NonZeroUsize::new(1).unwrap(), + Grant::new(), + ); + check( + attempt.as_mut().now_or_never().is_none(), + "owner initially scheduled", + )?; + drop(attempt); + pause().await; + passed.push(&"cancellation before owner startup".into()); + + let endpoint = format!("{base}/revoked-owner"); + let revoked_grant = Grant::new(); + let mut attempt = BrowserConnector.connect( + &endpoint, + Duration::from_secs(1), + NonZeroUsize::new(1).unwrap(), + revoked_grant.clone(), + ); + check( + attempt.as_mut().now_or_never().is_none(), + "revocable owner initially scheduled", + )?; + revoked_grant.revoke(); + check( + matches!(attempt.await, Err(Error::Policy)), + "owner rechecks original grant", + )?; + passed.push(&"revocation before owner startup".into()); + + let endpoint = format!("{base}/expired-owner"); + let mut attempt = BrowserConnector.connect( + &endpoint, + Duration::from_millis(5), + NonZeroUsize::new(1).unwrap(), + Grant::new(), + ); + check( + attempt.as_mut().now_or_never().is_none(), + "deadline owner initially scheduled", + )?; + let until = js_sys::Date::now() + 25.0; + while js_sys::Date::now() < until {} + check( + matches!(attempt.await, Err(Error::Timeout)), + "delayed owner cannot renew original deadline", + )?; + passed.push(&"original deadline before owner startup".into()); + + let socket = connect(&base, "echo", 1024, grant.clone()).await?; + let text = Frame::Text(" [\"original\", 7, \"café🌱\"] \n".into()); + socket.send(text.clone()).await.map_err(error)?; + check( + socket.receive().await.map_err(error)? == Some(text), + "original text", + )?; + let binary = Frame::Binary(vec![0, 255, 10, 13, 128]); + socket.send(binary.clone()).await.map_err(error)?; + check( + socket.receive().await.map_err(error)? == Some(binary), + "original binary", + )?; + check( + grant.frames.load(Ordering::SeqCst) == 2 && grant.bytes.load(Ordering::SeqCst) > 5, + "original admission charges", + )?; + passed.push(&"original text binary and admission".into()); + for frame in [Frame::Ping(vec![]), Frame::Pong(vec![]), Frame::Close(None)] { + check( + socket.send(frame).await == Err(Error::Unsupported), + "unsupported control", + )?; + } + check( + !BrowserConnector.supports_ping(), + "browser ping unavailable", + )?; + check( + socket.send(Frame::Binary(vec![0; 1025])).await == Err(Error::Protocol), + "outgoing size", + )?; + passed.push(&"control and outgoing bounds".into()); + + let mut pending = socket.send(Frame::Text("observer lost".into())); + check( + pending.as_mut().now_or_never().is_none(), + "admitted send starts pending", + )?; + drop(pending); + check( + socket.send(Frame::Text("cannot replace".into())).await == Err(Error::Policy), + "cancelled observer cannot replace accepted send", + )?; + check( + socket.receive().await.map_err(error)? == Some(Frame::Text("observer lost".into())), + "original admitted send retained", + )?; + passed.push(&"send observer cancellation".into()); + + let mut pending = socket.receive(); + check(pending.as_mut().now_or_never().is_none(), "pending receive")?; + let revoking = grant.clone(); + wasm_bindgen_futures::spawn_local(async move { + async_utility::time::sleep(Duration::from_millis(10)).await; + revoking.revoke(); + }); + check( + pending.await == Err(Error::Policy), + "revocation wakes original reader", + )?; + check( + socket.send(Frame::Text("denied".into())).await.is_err(), + "revoked send", + )?; + socket.close().await.map_err(error)?; + socket.close().await.map_err(error)?; + drop(socket); + passed.push(&"revocation and repeated cleanup".into()); + + for (route, limit, expected) in [ + ("oversize", 1024, Error::Protocol), + ("unicode", 1024, Error::Protocol), + ("binary-large", 1024, Error::Protocol), + ("items", 1024, Error::Policy), + ("bytes", 512 * 1024, Error::Policy), + ] { + let socket = connect(&base, route, limit, Grant::new()).await?; + wasm_bindgen_futures::JsFuture::from(wait_for_close(route)).await?; + check(socket.receive().await == Err(expected), route)?; + socket.close().await.map_err(error)?; + passed.push(&JsValue::from_str(route)); + } + let grant = Grant::new(); + grant.charge.store(false, Ordering::SeqCst); + let socket = connect(&base, "echo", 1024, grant.clone()).await?; + socket + .send(Frame::Text("original refusal".into())) + .await + .map_err(error)?; + check( + socket.receive().await == Err(Error::Policy), + "original budget refuses callback", + )?; + check( + grant.bytes.load(Ordering::SeqCst) == 16, + "refused original bytes charged", + )?; + socket.close().await.map_err(error)?; + passed.push(&"original budget refusal".into()); + + let socket = connect(&base, "echo", 1024, Grant::new()).await?; + force_backpressure(); + check( + socket.send(Frame::Text("must not enqueue".into())).await == Err(Error::Policy), + "reported browser outbound credit", + )?; + socket.close().await.map_err(error)?; + passed.push(&"reported outbound buffer refusal".into()); + + let socket = connect(&base, "disconnect", 1024, Grant::new()).await?; + check( + socket.receive().await.map_err(error)? == Some(Frame::Text("before close".into())), + "retained before peer close", + )?; + check( + socket.receive().await.map_err(error)?.is_none(), + "peer end observed", + )?; + socket.close().await.map_err(error)?; + passed.push(&"peer disconnect preserves preceding message".into()); + + let socket = connect(&base, "echo", 1024, Grant::new()).await?; + drop(socket); + pause().await; + passed.push(&"last socket observer cleanup".into()); + + let endpoint = format!("{base}/stall"); + let mut attempt = BrowserConnector.connect( + &endpoint, + Duration::from_secs(2), + NonZeroUsize::new(1).unwrap(), + Grant::new(), + ); + check( + attempt.as_mut().now_or_never().is_none(), + "connect initially pending", + )?; + pause().await; + drop(attempt); + pause().await; + passed.push(&"cancelled handshake cleanup".into()); + let result = BrowserConnector + .connect( + &endpoint, + Duration::from_millis(20), + NonZeroUsize::new(1).unwrap(), + Grant::new(), + ) + .await; + check( + matches!(result, Err(Error::Timeout)), + "original handshake deadline", + )?; + passed.push(&"handshake deadline cleanup".into()); + pause().await; + Ok(passed) +} diff --git a/crates/transport_nostr_browser/tests/browser/src/shared.rs b/crates/transport_nostr_browser/tests/browser/src/shared.rs @@ -0,0 +1,176 @@ +use crate::{check, pause}; +use futures::FutureExt; +use radroots_transport::{ + DeliveryRequest, EventSink, EventSource, FetchRequest, TargetSet, + outcome::FetchTargetState, + policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, + sink::DeliveryPayload, + source::FetchBounds, +}; +use radroots_transport_nostr::{ + Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, +}; +use wasm_bindgen::prelude::*; + +fn now() -> u64 { + js_sys::Date::now() as u64 +} +fn profile_config(base: &str, route: &str) -> Config { + Config::from_profile( + RelayProfile::explicit( + RelayProfileKind::Simulator, + [RelayEndpoint::new( + format!("{base}/{route}"), + RelayUrlPolicy::Local, + RelayAccess::ReadWrite, + ) + .unwrap()], + ) + .unwrap(), + ) + .with_timeouts(1000, 500, 100) + .unwrap() +} +fn targets(config: &Config) -> TargetSet { + TargetSet::new( + config + .relays() + .iter() + .map(|relay| relay.to_target().unwrap()) + .collect(), + ) + .unwrap() +} + +#[wasm_bindgen] +pub fn fixture_event() -> String { + // Consume the source-owned conformance vector, retaining an independently + // verified signature while deliberately changing only its outer whitespace. + let vectors: serde_json::Value = serde_json::from_str(include_str!( + "../../../../../contracts/conformance/vectors/event/verified_admission.v1.json" + )) + .unwrap(); + format!( + " \n{} \t", + serde_json::to_string_pretty(&vectors["vectors"][1]["input"]["event"]).unwrap() + ) +} + +#[wasm_bindgen] +pub async fn verify_shared_session(base: String) -> Result<js_sys::Array, JsValue> { + let passed = js_sys::Array::new(); + let raw = fixture_event(); + let config = profile_config(&base, "shared-accept"); + let transport = radroots_transport_nostr_browser::create_transport(config.clone()); + let page = transport + .fetch( + FetchRequest::new( + "browser-source", + targets(&config), + FetchBounds::new(10, now() + 5000).unwrap(), + ) + .unwrap(), + ) + .await + .map_err(|_| JsValue::from_str("shared fetch error"))?; + check( + page.events().len() == 1 && page.target_outcomes()[0].state() == FetchTargetState::Complete, + "shared verified source and EOSE", + )?; + passed.push(&"shared independently verified event and EOSE".into()); + let request = DeliveryRequest::new( + "browser-exact", + DeliveryPayload::new(radroots_event_codec::decode::signed_event(&raw).unwrap()), + targets(&config), + SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), + now() + 5000, + ) + .unwrap(); + let receipt = transport + .deliver(request) + .await + .map_err(|_| JsValue::from_str("shared deliver error"))?; + check( + receipt.target_receipts()[0] + .outcome() + .satisfies(SatisfactionClass::Accepted), + "shared exact acceptance", + )?; + transport.shutdown().await; + check(transport.admission_is_closed(), "shared shutdown admission")?; + passed.push(&"shared original publication and matching ACK".into()); + + for route in ["shared-negative", "shared-noack", "shared-badack"] { + let config = profile_config(&base, route); + let transport = radroots_transport_nostr_browser::create_transport(config.clone()); + let request = DeliveryRequest::new( + route, + DeliveryPayload::new(radroots_event_codec::decode::signed_event(&raw).unwrap()), + targets(&config), + SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), + now() + 5000, + ) + .unwrap(); + let receipt = transport + .deliver(request) + .await + .map_err(|_| JsValue::from_str("shared negative deliver error"))?; + check( + !receipt.target_receipts()[0] + .outcome() + .satisfies(SatisfactionClass::Accepted), + route, + )?; + transport.shutdown().await; + passed.push(&JsValue::from_str(route)); + } + + let config = profile_config(&base, "shared-disconnect"); + let transport = radroots_transport_nostr_browser::create_transport(config.clone()); + let page = transport + .fetch( + FetchRequest::new( + "browser-gap", + targets(&config), + FetchBounds::new(10, now() + 5000).unwrap(), + ) + .unwrap(), + ) + .await + .map_err(|_| JsValue::from_str("shared disconnect fetch error"))?; + check( + page.target_outcomes()[0].state() != FetchTargetState::Complete, + "disconnect cannot prove complete history", + )?; + transport.shutdown().await; + passed.push(&"shared disconnect never proves complete history".into()); + + let config = profile_config(&base, "shared-observer"); + let transport = radroots_transport_nostr_browser::create_transport(config.clone()); + let mut fetch = transport.fetch( + FetchRequest::new( + "browser-observer", + targets(&config), + FetchBounds::new(10, now() + 5000).unwrap(), + ) + .unwrap(), + ); + check( + fetch.as_mut().now_or_never().is_none(), + "shared fetch starts pending", + )?; + pause().await; + check( + fetch.as_mut().now_or_never().is_none(), + "shared original observer remains pending", + )?; + drop(fetch); + transport.shutdown().await; + pause().await; + check( + !transport.has_in_flight_operations(), + "shared observer loss frees original call", + )?; + passed.push(&"shared fetch observer loss and shutdown".into()); + Ok(passed) +}