commit fcceea68f9311927488655bf96f01375120e0d1d
parent 21ddcd6755fe7de99ea0284c88729fd6adfc5416
Author: triesap <tyson@radroots.org>
Date: Fri, 23 Oct 2026 10:02:52 +0000
transport_nostr: Preserve original signed event evidence across source observations
- Retain bounded original objects in the existing shared socket and exact fetch/live scopes.
- Refuse missing or exhausted evidence without normalized fallback or checkpoint advancement.
- Prove real loopback observations through protected commerce admission and isolated queue cleanup.
- Verify native tests, strict lint, WASM, unchanged APIs, package boundaries and full coverage gates.
Diffstat:
16 files changed, 1045 insertions(+), 39 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
@@ -3828,6 +3828,7 @@ dependencies = [
"radroots_event_codec",
"radroots_nostr",
"radroots_protocol",
+ "radroots_signing",
"radroots_transport",
"serde_json",
"sha2",
diff --git a/contracts/protocol/source_original.v1.json b/contracts/protocol/source_original.v1.json
@@ -0,0 +1,19 @@
+{
+ "schema": "radroots.transport_nostr.original_ingress.v1",
+ "contract_version": 1,
+ "state": "bounded_original_fetch_and_live_evidence",
+ "original_event_max_utf8_bytes": 65536,
+ "pending_events_max": 256,
+ "pending_bytes_max": 4194304,
+ "accounting": "Fixed reserved queue entry capacity, queue object and exact retained Box<str> lengths; no silent eviction. Other bounded session metadata, host buffers and caller-owned obtained results are separate.",
+ "ownership": "Exact registration, relay and subscription; monotonic private scope identities; stale connection generations cannot capture. Scope drop and registration finalization remove only their owned originals.",
+ "correlation": "The exact pinned upstream decoder and SHA256 of its serialization correlate a parsed notification to the original queued object. This key is not authenticity, profile admission or replacement wire evidence. FIFO retains distinct original spellings independently.",
+ "fetch": "Existing monotonic work/byte/frame budgets, ordered finalization and partial results remain. Missing originals or queue loss produce incomplete evidence, never reserialized fallback.",
+ "live": "Uses the same aggregate original queue with independent scope disposal, no inherited cumulative fetch budget and a wakeable loss signal. Queue loss or missing original returns a source error without advancing an event checkpoint. Cancelled live scopes do not invalidate another scope's physical connection.",
+ "admission": "Original objects pass through SignedEvent.raw_json to the owning protected reader. Only that reader establishes complete signature, recipient, seal, rumor and record bindings. Original source data alone supplies no business authority.",
+ "limits": [
+ "This contract governs original network evidence, not a second transport or durable journal.",
+ "Existing general EventWireLimits and ancillary direct-value policies retain their separately governed scope until coherent profile/consumer reconciliation. They do not enlarge this original-network-event bound or the protected reader's64KiB admission.",
+ "No structured authoring enablement, stock/consent/physical truth, coherent consumer adoption or final acceptance follows from this component."
+ ]
+}
diff --git a/crates/transport_nostr/Cargo.toml b/crates/transport_nostr/Cargo.toml
@@ -45,7 +45,7 @@ radroots_transport = { workspace = true, default-features = false, features = ["
async-wsocket = { workspace = true }
futures = { workspace = true }
nostr-sdk = { workspace = true }
-serde_json = { workspace = true, features = ["std"] }
+serde_json = { workspace = true, features = ["std", "raw_value"] }
sha2 = { workspace = true, default-features = false }
tokio = { workspace = true, features = ["sync"] }
url = { workspace = true }
@@ -60,6 +60,8 @@ wasm-bindgen-futures = { workspace = true }
web-time = { workspace = true }
[dev-dependencies]
+radroots_nostr = { workspace = true, default-features = false, features = ["commerce"] }
+radroots_signing = { workspace = true, default-features = false, features = ["std"] }
tokio-tungstenite = { workspace = true }
tokio = { workspace = true, features = [
"macros",
diff --git a/crates/transport_nostr/README.md b/crates/transport_nostr/README.md
@@ -216,13 +216,14 @@ it includes decrypted HTTP upgrade bytes, frame headers and payloads, malformed
and discarded messages, duplicate events, unsolicited traffic, control frames,
and empty continuation frames. Text and binary message starts conservatively
consume data attempts without inspecting their JSON. The HTTP upgrade response
-is also limited to 16 KiB. Each relay retains at most 1,000 events. An event is
-at most 256 KiB, and the WebSocket connector explicitly limits both frames and
+is also limited to 16 KiB. Each relay retains at most 1,000 events. Original
+event objects from the network are limited to64KiB; the existing general
+canonical decoder's256KiB ceiling cannot enlarge network admission. The WebSocket connector explicitly limits both frames and
complete messages to 512 KiB. SDK notification and canonical event collection
retain independent limits of 8,192 notifications, 4,096 events and 8 MiB.
Exhaustion is sticky and wakes all affected fetch collectors; later EOSE cannot
-turn it into completion. At most 64 fetch calls may hold ingress registrations
-on one transport; additional calls fail closed as partial evidence.
+turn it into completion. At most64 fetch/live scopes may hold ingress registrations
+on one transport; additional setup fails with partial evidence or a source error.
The meter reads into a fixed 4 KiB plaintext scratch buffer before admission;
at most that scratch capacity can be read beyond the remaining allowance and
discarded without reaching WebSocket assembly or Nostr parsing. This bound
@@ -247,6 +248,19 @@ additive `nostr-until-v1` form is interpreted only by this concrete adapter.
No automatic retry, unlimited scan, new protocol or global completeness claim
is implied by either form.
+Fetch and live observations retain the original signed event object before
+upstream decoding. A shared queue bounds pending originals to256 events and4MiB,
+including its reserved entry storage and retained object bytes. Exact relay,
+subscription and registration ownership prevents cross-scope reuse. A digest
+of the pinned decoder's representation correlates notifications without granting
+authenticity or replacing original bytes. `SignedEvent::raw_json` retains those
+originals for subsequent protected admission. Missing originals and saturation
+produce incomplete fetch evidence or a live source error; no normalized fallback
+is used. Live scope disposal preserves other live scopes and does not inherit
+a finite fetch's cumulative work budget. Original data remains untrusted until
+its owning signature/profile/participant checks. The owning contract is
+[`source_original.v1.json`](../../contracts/protocol/source_original.v1.json).
+
Live subscriptions use the same explicit readable targets and selector
translation. A caller checkpoint is scoped to one exact target and selector;
the adapter reconnects with Nostr's inclusive `since` timestamp, suppresses
diff --git a/crates/transport_nostr/src/client.rs b/crates/transport_nostr/src/client.rs
@@ -318,12 +318,13 @@ impl NostrTransport {
)),
source_client: Arc::new(crate::source::LiveRelaySourceClient::new(
client.clone(),
- ingress,
+ ingress.clone(),
Arc::clone(&connections),
)),
subscription_client: Arc::new(crate::subscription::LiveRelaySubscriptionClient::new(
client.clone(),
connections,
+ ingress,
)),
auth: Arc::new(crate::auth::AuthFlow::new(Arc::new(
crate::auth::LiveAuthClient::new(client),
diff --git a/crates/transport_nostr/src/lib.rs b/crates/transport_nostr/src/lib.rs
@@ -16,6 +16,7 @@ mod sink;
mod socket_write;
mod source;
mod source_ingress;
+mod source_original;
mod status;
mod subscription;
diff --git a/crates/transport_nostr/src/session_socket.rs b/crates/transport_nostr/src/session_socket.rs
@@ -89,6 +89,7 @@ impl WebSocketTransport for SessionWebsocketTransport {
.ingress
.connection(relay.as_str())
.ok_or_else(|| policy_error("relay ingress unavailable"))?;
+ let originals = ingress.clone();
let admission = Arc::new(ConnectionAdmission { policy, ingress });
let limit = NonZeroUsize::new(MAX_WIRE_MESSAGE_BYTES)
.expect("the fixed wire limit is positive");
@@ -104,11 +105,17 @@ impl WebSocketTransport for SessionWebsocketTransport {
crate::socket_write::SocketWriter::new(Box::pin(HostSink::new(socket.clone())));
self.writers.install(relay.as_str(), &writer)?;
let sink: WebSocketSink = Box::pin(crate::socket_write::SharedSocketSink::new(writer));
- let receiver = stream::try_unfold(socket, |socket| async move {
- let frame = socket.receive().await.map_err(host_error)?;
- let message = frame.map(from_host_frame).transpose()?.flatten();
- Ok(message.map(|message| (message, socket)))
- });
+ let receiver =
+ stream::try_unfold((socket, originals), |(socket, originals)| async move {
+ let frame = socket.receive().await.map_err(host_error)?;
+ let message = frame.map(from_host_frame).transpose()?.flatten();
+ if let Some(Message::Text(text)) = &message
+ && !originals.capture(text)
+ {
+ return Err(policy_error("original relay ingress unavailable"));
+ }
+ Ok(message.map(|message| (message, (socket, originals))))
+ });
Ok((sink, Box::pin(receiver) as WebSocketStream))
})
}
diff --git a/crates/transport_nostr/src/source.rs b/crates/transport_nostr/src/source.rs
@@ -29,6 +29,10 @@ mod window;
#[path = "source_paging_tests.rs"]
mod paging_tests;
+#[cfg(test)]
+#[path = "source_original_tests.rs"]
+mod original_tests;
+
const UPSTREAM_FETCH_LIMIT: usize = 1_000;
const CURSOR_PREFIX: &str = "nostr-v2";
const CURSOR_SCOPE_DOMAIN: &[u8] = b"radroots.transport-nostr.fetch-cursor.v2\0";
@@ -155,6 +159,7 @@ impl RelaySourceClient for LiveRelaySourceClient {
let mut batches: Vec<RelayFetchBatch> = stream::iter(relays.into_iter().map(|relay| {
let selector = selector.clone();
let budget = Arc::clone(&budget);
+ let registration = ®istration;
async move {
let url = relay.as_str().to_owned();
let result = async {
@@ -216,6 +221,11 @@ impl RelaySourceClient for LiveRelaySourceClient {
.with_gaps()
.map(|item| item.map_err(|_| ()));
let subscription_id = SubscriptionId::generate();
+ let Some(originals) =
+ registration.bind_originals(&url, subscription_id.as_str())
+ else {
+ return Ok(RelayFetchResult::ResourceLimit(Vec::new()));
+ };
let remaining =
deadline.saturating_duration_since(crate::host_time::Instant::now());
if remaining.is_zero() {
@@ -243,6 +253,7 @@ impl RelaySourceClient for LiveRelaySourceClient {
&subscription_id,
deadline,
&budget,
+ |event| originals.take(event),
)
.await;
Ok(result)
@@ -321,7 +332,7 @@ async fn admit_fetch_connections(
fn finish_fetch(
batches: &mut [RelayFetchBatch],
- registration: crate::source_ingress::FetchRegistration,
+ registration: crate::source_ingress::IngressRegistration,
) -> bool {
if !batches
.iter()
@@ -380,6 +391,7 @@ async fn collect_until_eose(
subscription_id: &SubscriptionId,
deadline: crate::host_time::Instant,
budget: &FetchBudget,
+ mut original: impl FnMut(&nostr_sdk::prelude::Event) -> Option<String>,
) -> RelayFetchResult {
let mut events = Vec::new();
loop {
@@ -416,7 +428,11 @@ async fn collect_until_eose(
if events.len() >= UPSTREAM_FETCH_LIMIT {
return RelayFetchResult::ResourceLimit(events);
}
- let raw = event.as_ref().as_json();
+ let Some(raw) = original(event.as_ref()) else {
+ // A parsed notification cannot recreate lost original
+ // evidence. Preserve partial results and require recovery.
+ return RelayFetchResult::ResourceLimit(events);
+ };
if !budget.event(raw.len()) {
return RelayFetchResult::ResourceLimit(events);
}
@@ -842,6 +858,18 @@ mod tests {
atomic::{AtomicUsize, Ordering as AtomicOrdering},
};
+ async fn collect_until_eose_test(
+ notifications: &mut (impl Stream<Item = Result<RelayNotification, ()>> + Unpin),
+ subscription_id: &SubscriptionId,
+ deadline: crate::host_time::Instant,
+ budget: &FetchBudget,
+ ) -> RelayFetchResult {
+ collect_until_eose(notifications, subscription_id, deadline, budget, |event| {
+ Some(event.as_json())
+ })
+ .await
+ }
+
const FIRST: &str = r#"{"id":"762bee187e9e645b81ec26ade05a69b5e8398caf527be8de0d9a45311ed0c7a0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1800000100,"kind":0,"tags":[],"content":"{\"display_name\":\"Moss Street Farm\",\"bot\":false,\"website\":\"https://mossstreet.example\",\"picture\":42}","sig":"4290da0bb6422986647bc8cd5f63bd52d49f41e7b665d3b47105b8109183e8d596f322c531d4061df53e1d2b70fda12d5d1c14f3720d7a56d9d0a03746af5109"}"#;
const SECOND: &str = r#"{"id":"56bfc78223bb2221bad82b539efdec1ade0f56d0eb0e1f592fd387df4b2ceee0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1700000001,"kind":0,"tags":[],"content":"{}","sig":"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"}"#;
@@ -1133,7 +1161,7 @@ mod tests {
})
.expect("EOSE");
assert_eq!(
- collect_until_eose(
+ collect_until_eose_test(
&mut test_notifications(&mut receiver),
&subscription_id,
crate::host_time::Instant::now() + Duration::from_secs(1),
@@ -1145,7 +1173,7 @@ mod tests {
let (_sender, mut receiver) = tokio::sync::broadcast::channel(2);
assert_eq!(
- collect_until_eose(
+ collect_until_eose_test(
&mut test_notifications(&mut receiver),
&subscription_id,
crate::host_time::Instant::now(),
@@ -1170,7 +1198,7 @@ mod tests {
let budget = FetchBudget::default();
assert!(!budget.wire(budget::MAX_FETCH_BYTES + 1, 0, 0));
assert_eq!(
- collect_until_eose(
+ collect_until_eose_test(
&mut test_notifications(&mut receiver),
&subscription_id,
crate::host_time::Instant::now() + Duration::from_secs(1),
@@ -1196,7 +1224,7 @@ mod tests {
})
.unwrap();
assert_eq!(
- collect_until_eose(
+ collect_until_eose_test(
&mut test_notifications(&mut receiver),
&id,
crate::host_time::Instant::now() + Duration::from_secs(1),
@@ -1236,7 +1264,7 @@ mod tests {
.unwrap();
batches.push(RelayFetchBatch {
relay: RelayUrl::parse(url, RelayUrlPolicy::Public).unwrap(),
- result: collect_until_eose(
+ result: collect_until_eose_test(
&mut test_notifications(&mut receiver),
&id,
crate::host_time::Instant::now() + Duration::from_secs(1),
@@ -1776,7 +1804,7 @@ mod tests {
.unwrap();
}
assert_eq!(
- collect_until_eose(
+ collect_until_eose_test(
&mut test_notifications(&mut receiver),
&id,
crate::host_time::Instant::now() + Duration::from_secs(10),
@@ -1802,7 +1830,7 @@ mod tests {
})
.unwrap();
}
- let result = collect_until_eose(
+ let result = collect_until_eose_test(
&mut test_notifications(&mut receiver),
&id,
crate::host_time::Instant::now() + Duration::from_secs(10),
@@ -1879,7 +1907,7 @@ mod tests {
message: Box::new(RelayMessage::EndOfStoredEvents(Cow::Owned(id.clone()))),
})
.unwrap();
- let result = collect_until_eose(
+ let result = collect_until_eose_test(
&mut test_notifications(&mut receiver),
&id,
crate::host_time::Instant::now() + Duration::from_secs(10),
diff --git a/crates/transport_nostr/src/source_budget.rs b/crates/transport_nostr/src/source_budget.rs
@@ -22,6 +22,12 @@ struct Usage {
pub(crate) struct FetchBudget(Mutex<Usage>, tokio::sync::Notify);
impl FetchBudget {
+ pub(crate) fn exhaust(&self) {
+ if let Ok(mut usage) = self.0.lock() {
+ usage.exhausted = true;
+ }
+ self.1.notify_waiters();
+ }
pub(crate) fn wire(&self, bytes: usize, frames: usize, data: usize) -> bool {
let Ok(mut usage) = self.0.lock() else {
return false;
@@ -45,7 +51,7 @@ impl FetchBudget {
self.0.lock().map_or(true, |usage| usage.exhausted)
}
- pub(super) async fn wait_exhausted(&self) {
+ pub(crate) async fn wait_exhausted(&self) {
loop {
let notified = self.1.notified();
tokio::pin!(notified);
diff --git a/crates/transport_nostr/src/source_ingress.rs b/crates/transport_nostr/src/source_ingress.rs
@@ -8,7 +8,13 @@ use std::{
task::Context,
};
-const MAX_ACTIVE_FETCHES: usize = 64;
+const MAX_ACTIVE_SCOPES: usize = 64;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum ScopeMode {
+ Fetch,
+ Live,
+}
#[derive(Debug, Default)]
struct RelayState {
@@ -22,13 +28,24 @@ struct RelayState {
struct Registration {
targets: BTreeSet<String>,
budget: Arc<FetchBudget>,
+ originals: Vec<OriginalScope>,
+ mode: ScopeMode,
+}
+
+#[derive(Debug)]
+struct OriginalScope {
+ relay: String,
+ subscription: String,
+ scope: u64,
}
#[derive(Debug, Default)]
struct State {
sequence: u64,
+ original_sequence: u64,
relays: BTreeMap<String, RelayState>,
active: BTreeMap<u64, Registration>,
+ originals: crate::source_original::OriginalQueue,
}
#[derive(Clone, Debug, Default)]
@@ -48,9 +65,25 @@ impl IngressRegistry {
&self,
targets: impl Iterator<Item = String>,
budget: Arc<FetchBudget>,
- ) -> Option<FetchRegistration> {
+ ) -> Option<IngressRegistration> {
+ self.register_scope(targets, budget, ScopeMode::Fetch)
+ }
+
+ pub(crate) fn register_live(
+ &self,
+ targets: impl Iterator<Item = String>,
+ ) -> Option<IngressRegistration> {
+ self.register_scope(targets, Arc::new(FetchBudget::default()), ScopeMode::Live)
+ }
+
+ fn register_scope(
+ &self,
+ targets: impl Iterator<Item = String>,
+ budget: Arc<FetchBudget>,
+ mode: ScopeMode,
+ ) -> Option<IngressRegistration> {
let mut state = self.0.lock().ok()?;
- if state.active.len() == MAX_ACTIVE_FETCHES {
+ if state.active.len() == MAX_ACTIVE_SCOPES {
return None;
}
let targets: BTreeSet<_> = targets.collect();
@@ -62,8 +95,16 @@ impl IngressRegistry {
}
let id = state.sequence.checked_add(1)?;
state.sequence = id;
- state.active.insert(id, Registration { targets, budget });
- Some(FetchRegistration {
+ state.active.insert(
+ id,
+ Registration {
+ targets,
+ budget,
+ originals: Vec::new(),
+ mode,
+ },
+ );
+ Some(IngressRegistration {
registry: self.clone(),
id,
finished: false,
@@ -120,7 +161,10 @@ impl IngressRegistry {
}
let mut denied = BTreeSet::new();
for entry in state.active.values() {
- if entry.targets.contains(relay) && !entry.budget.wire(bytes, frames, data) {
+ if entry.mode == ScopeMode::Fetch
+ && entry.targets.contains(relay)
+ && !entry.budget.wire(bytes, frames, data)
+ {
denied.extend(entry.targets.iter().cloned());
}
}
@@ -141,10 +185,11 @@ impl IngressRegistry {
let Some(entry) = state.active.remove(&id) else {
return false;
};
+ state.originals.remove_owner(id);
// Charge and completion use this same mutex. No ingress can exhaust
// this registration between the budget check and its removal.
let complete = !cancel && !entry.budget.exhausted();
- if !complete {
+ if !complete && entry.mode == ScopeMode::Fetch {
for target in entry.targets {
if let Some(row) = state.relays.get_mut(&target) {
row.invalidated = row.generation;
@@ -155,15 +200,152 @@ impl IngressRegistry {
}
complete
}
+
+ fn bind_originals(
+ &self,
+ owner: u64,
+ relay: &str,
+ subscription: &str,
+ ) -> Option<OriginalSubscription> {
+ if subscription.is_empty() || subscription.len() > 256 {
+ return None;
+ }
+ let mut state = self.0.lock().ok()?;
+ if state.active.values().any(|entry| {
+ entry
+ .originals
+ .iter()
+ .any(|scope| scope.relay == relay && scope.subscription == subscription)
+ }) {
+ return None;
+ }
+ let entry = state.active.get(&owner)?;
+ if !entry.targets.contains(relay) || entry.originals.len() >= crate::client::MAX_RELAYS {
+ return None;
+ }
+ let scope = state.original_sequence.checked_add(1)?;
+ state.original_sequence = scope;
+ state.active.get_mut(&owner)?.originals.push(OriginalScope {
+ relay: relay.into(),
+ subscription: subscription.into(),
+ scope,
+ });
+ Some(OriginalSubscription {
+ registry: self.clone(),
+ owner,
+ scope,
+ })
+ }
+
+ fn capture(&self, relay: &str, generation: u64, text: &str) -> bool {
+ let Some((subscription, raw)) = crate::source_original::frame(text) else {
+ return true;
+ };
+ let selected = {
+ let Ok(state) = self.0.lock() else {
+ return false;
+ };
+ if !state
+ .relays
+ .get(relay)
+ .is_some_and(|row| generation == row.generation && generation > row.invalidated)
+ {
+ return false;
+ }
+ state.active.iter().find_map(|(owner, entry)| {
+ entry
+ .originals
+ .iter()
+ .find(|scope| scope.relay == relay && scope.subscription == subscription)
+ .map(|scope| (*owner, scope.scope))
+ })
+ };
+ let Some((owner, scope)) = selected else {
+ return true;
+ };
+ // Reuse the exact pinned upstream decoder only to correlate its later
+ // notification. It supplies no authentication or original-wire admission.
+ let Ok(event) = nostr_sdk::prelude::Event::from_json(raw.get()) else {
+ return true;
+ };
+ let correlation = crate::source_original::correlation(&event);
+ let Ok(mut state) = self.0.lock() else {
+ return false;
+ };
+ if !state
+ .relays
+ .get(relay)
+ .is_some_and(|row| generation == row.generation && generation > row.invalidated)
+ {
+ return false;
+ }
+ let Some(entry) = state.active.get(&owner) else {
+ return true;
+ };
+ if !entry.originals.iter().any(|entry| entry.scope == scope) {
+ return true;
+ }
+ if entry.budget.exhausted() {
+ return entry.mode == ScopeMode::Live;
+ }
+ if state.originals.insert(owner, scope, correlation, raw.get()) {
+ return true;
+ }
+ let entry = &state.active[&owner];
+ entry.budget.exhaust();
+ if entry.mode == ScopeMode::Live {
+ return true;
+ }
+ let targets = entry.targets.clone();
+ for target in targets {
+ if let Some(row) = state.relays.get_mut(&target) {
+ row.invalidated = row.generation;
+ row.waker.wake();
+ row.write_waker.wake();
+ }
+ }
+ false
+ }
}
-pub(crate) struct FetchRegistration {
+pub(crate) struct IngressRegistration {
registry: IngressRegistry,
id: u64,
finished: bool,
}
-impl FetchRegistration {
+impl IngressRegistration {
+ pub(crate) async fn wait_exhausted(&self) {
+ let budget = self.registry.0.lock().ok().and_then(|state| {
+ state
+ .active
+ .get(&self.id)
+ .map(|entry| Arc::clone(&entry.budget))
+ });
+ if let Some(budget) = budget {
+ budget.wait_exhausted().await;
+ }
+ }
+ pub(crate) fn exhausted(&self) -> bool {
+ self.registry
+ .0
+ .lock()
+ .ok()
+ .and_then(|state| {
+ state
+ .active
+ .get(&self.id)
+ .map(|entry| entry.budget.exhausted())
+ })
+ .unwrap_or(true)
+ }
+ pub(crate) fn bind_originals(
+ &self,
+ relay: &str,
+ subscription: &str,
+ ) -> Option<OriginalSubscription> {
+ self.registry.bind_originals(self.id, relay, subscription)
+ }
pub(crate) fn finish(mut self) -> bool {
let complete = self.registry.remove(self.id, false);
self.finished = true;
@@ -171,7 +353,29 @@ impl FetchRegistration {
}
}
-impl Drop for FetchRegistration {
+pub(crate) struct OriginalSubscription {
+ registry: IngressRegistry,
+ owner: u64,
+ scope: u64,
+}
+impl OriginalSubscription {
+ pub(crate) fn take(&self, event: &nostr_sdk::prelude::Event) -> Option<String> {
+ let key = crate::source_original::correlation(event);
+ self.registry.0.lock().ok()?.originals.take(self.scope, key)
+ }
+}
+impl Drop for OriginalSubscription {
+ fn drop(&mut self) {
+ if let Ok(mut state) = self.registry.0.lock() {
+ state.originals.remove_scope(self.scope);
+ if let Some(entry) = state.active.get_mut(&self.owner) {
+ entry.originals.retain(|entry| entry.scope != self.scope);
+ }
+ }
+ }
+}
+
+impl Drop for IngressRegistration {
fn drop(&mut self) {
if !self.finished {
self.registry.remove(self.id, true);
@@ -187,6 +391,9 @@ pub(crate) struct IngressConnection {
}
impl IngressConnection {
+ pub(crate) fn capture(&self, text: &str) -> bool {
+ self.registry.capture(&self.relay, self.generation, text)
+ }
pub(crate) fn admitted(&self, context: &Context<'_>) -> bool {
self.registry
.admitted(&self.relay, self.generation, context, false)
@@ -208,6 +415,200 @@ mod tests {
use super::*;
use crate::source::budget::{MAX_FETCH_BYTES, MAX_FETCH_EVENTS, MAX_FETCH_NOTIFICATIONS};
+ fn original() -> (String, nostr_sdk::prelude::Event) {
+ let fixture: serde_json::Value =
+ serde_json::from_str(include_str!("../tests/fixtures/source_original.v1.json"))
+ .unwrap();
+ let raw = fixture["raw_wrap"].as_str().unwrap().to_owned();
+ let event = nostr_sdk::prelude::Event::from_json(&raw).unwrap();
+ (raw, event)
+ }
+ fn event_frame(subscription: &str, raw: &str) -> String {
+ format!(
+ "[\"EVENT\",{},{}]",
+ serde_json::to_string(subscription).unwrap(),
+ raw
+ )
+ }
+
+ #[test]
+ fn original_scope_refusals_and_unowned_frames_retain_no_evidence() {
+ let registry = registry();
+ let registration = register(®istry, &["one"], &Arc::new(FetchBudget::default()));
+ assert!(
+ registration
+ .bind_originals("one", &"a".repeat(257))
+ .is_none()
+ );
+ let mut scopes = Vec::new();
+ for index in 0..crate::client::MAX_RELAYS {
+ scopes.push(
+ registration
+ .bind_originals("one", &format!("scope-{index}"))
+ .unwrap(),
+ );
+ }
+ assert!(registration.bind_originals("one", "over-limit").is_none());
+ let connection = registry.connection("one").unwrap();
+ let (raw, event) = original();
+ assert!(connection.capture(&event_frame("unowned", &raw)));
+ assert!(connection.capture(&event_frame("scope-0", "{}")));
+ assert!(scopes[0].take(&event).is_none());
+ assert!(connection.capture(&event_frame("scope-0", &raw)));
+ assert_eq!(scopes[0].take(&event).as_deref(), Some(raw.as_str()));
+ assert!(registration.finish());
+ assert!(scopes[0].take(&event).is_none());
+ }
+
+ #[test]
+ fn originals_are_owned_by_exact_fetch_relay_and_subscription() {
+ let registry = registry();
+ let first = register(®istry, &["one"], &Arc::new(FetchBudget::default()));
+ let second = register(®istry, &["two"], &Arc::new(FetchBudget::default()));
+ let a = first.bind_originals("one", "a").unwrap();
+ let b = second.bind_originals("two", "a").unwrap();
+ assert!(first.bind_originals("one", "a").is_none());
+ assert!(first.bind_originals("missing", "b").is_none());
+ assert!(first.bind_originals("one", "").is_none());
+ let one = registry.connection("one").unwrap();
+ let two = registry.connection("two").unwrap();
+ let (raw, event) = original();
+ assert!(one.capture(&event_frame("a", &raw)));
+ assert!(b.take(&event).is_none());
+ assert!(two.capture(&event_frame("a", &raw)));
+ assert_eq!(a.take(&event).as_deref(), Some(raw.as_str()));
+ assert_eq!(b.take(&event).as_deref(), Some(raw.as_str()));
+ assert!(a.take(&event).is_none());
+ assert!(first.finish());
+ assert!(second.finish());
+ }
+
+ #[test]
+ fn original_scope_cleanup_and_reconnection_preserve_obtained_data_and_reject_stale_ingress() {
+ let registry = registry();
+ let first = register(®istry, &["one"], &Arc::new(FetchBudget::default()));
+ let scope = first.bind_originals("one", "a").unwrap();
+ let stale = registry.connection("one").unwrap();
+ let (raw, event) = original();
+ assert!(stale.capture(&event_frame("a", &raw)));
+ let fresh = registry.connection("one").unwrap();
+ assert!(!stale.capture(&event_frame("a", &raw)));
+ assert_eq!(scope.take(&event).as_deref(), Some(raw.as_str()));
+ assert!(fresh.capture(&event_frame("a", &raw)));
+ drop(scope);
+ assert_eq!(
+ registry.0.lock().unwrap().originals.retained_bytes(),
+ crate::source_original::OriginalQueue::default().retained_bytes()
+ );
+ assert!(fresh.capture(&event_frame("a", &raw)));
+ assert!(first.finish());
+ registry.0.lock().unwrap().original_sequence = u64::MAX;
+ let second = register(®istry, &["one"], &Arc::new(FetchBudget::default()));
+ assert!(second.bind_originals("one", "b").is_none());
+ }
+
+ #[test]
+ fn original_queue_is_globally_bounded_and_exhaustion_does_not_evict_other_fetch_data() {
+ let registry = registry();
+ let a_budget = Arc::new(FetchBudget::default());
+ let b_budget = Arc::new(FetchBudget::default());
+ let a = register(®istry, &["one"], &a_budget);
+ let b = register(®istry, &["two"], &b_budget);
+ let a_scope = a.bind_originals("one", "a").unwrap();
+ let b_scope = b.bind_originals("two", "b").unwrap();
+ let one = registry.connection("one").unwrap();
+ let two = registry.connection("two").unwrap();
+ let (raw, event) = original();
+ assert!(
+ raw.len() * crate::source_original::MAX_PENDING_EVENTS
+ + registry.0.lock().unwrap().originals.retained_bytes()
+ <= crate::source_original::MAX_PENDING_BYTES
+ );
+ for _ in 0..crate::source_original::MAX_PENDING_EVENTS / 2 {
+ assert!(one.capture(&event_frame("a", &raw)));
+ assert!(two.capture(&event_frame("b", &raw)));
+ }
+ assert!(!one.capture(&event_frame("a", &raw)));
+ assert!(a_budget.exhausted());
+ assert!(!b_budget.exhausted());
+ assert!(!admitted(&one));
+ assert!(admitted(&two));
+ assert_eq!(b_scope.take(&event).as_deref(), Some(raw.as_str()));
+ assert!(two.capture(&event_frame("b", &raw)));
+ assert_eq!(a_scope.take(&event).as_deref(), Some(raw.as_str()));
+ drop(a);
+ assert!(b_scope.take(&event).is_some());
+ assert!(b.finish());
+ assert_eq!(
+ registry.0.lock().unwrap().originals.retained_bytes(),
+ crate::source_original::OriginalQueue::default().retained_bytes()
+ );
+ }
+
+ #[test]
+ fn live_scope_cleanup_preserves_other_subscriptions_and_has_no_cumulative_fetch_budget() {
+ let registry = registry();
+ let first = registry
+ .register_live(["one".to_owned()].into_iter())
+ .unwrap();
+ let second = registry
+ .register_live(["one".to_owned()].into_iter())
+ .unwrap();
+ let a = first.bind_originals("one", "a").unwrap();
+ let b = second.bind_originals("one", "b").unwrap();
+ let connection = registry.connection("one").unwrap();
+ assert!(connection.charge(
+ MAX_FETCH_BYTES + 1,
+ MAX_FETCH_NOTIFICATIONS + 1,
+ MAX_FETCH_EVENTS + 1
+ ));
+ assert!(!first.exhausted());
+ assert!(!second.exhausted());
+ let (raw, event) = original();
+ assert!(connection.capture(&event_frame("a", &raw)));
+ assert!(connection.capture(&event_frame("b", &raw)));
+ drop(a);
+ drop(first);
+ assert!(admitted(&connection));
+ assert_eq!(b.take(&event).as_deref(), Some(raw.as_str()));
+ assert!(!second.exhausted());
+ drop(second);
+ assert!(b.take(&event).is_none());
+ assert!(admitted(&connection));
+ }
+
+ #[tokio::test]
+ async fn live_queue_loss_wakes_a_pending_observer_without_closing_another_scope() {
+ let registry = registry();
+ let live = registry
+ .register_live(["one".to_owned()].into_iter())
+ .unwrap();
+ let other = registry
+ .register_live(["one".to_owned()].into_iter())
+ .unwrap();
+ let scope = live.bind_originals("one", "a").unwrap();
+ let _other_scope = other.bind_originals("one", "b").unwrap();
+ let connection = registry.connection("one").unwrap();
+ let (raw, event) = original();
+ let wait = live.wait_exhausted();
+ futures::pin_mut!(wait);
+ assert!(futures::poll!(wait.as_mut()).is_pending());
+ for _ in 0..crate::source_original::MAX_PENDING_EVENTS {
+ assert!(connection.capture(&event_frame("a", &raw)));
+ }
+ assert!(connection.capture(&event_frame("a", &raw)));
+ tokio::time::timeout(std::time::Duration::from_secs(1), wait)
+ .await
+ .unwrap();
+ assert!(live.exhausted());
+ assert!(!other.exhausted());
+ assert!(admitted(&connection));
+ assert_eq!(scope.take(&event).as_deref(), Some(raw.as_str()));
+ // A lost scope cannot resume admission after unrelated dequeueing.
+ assert!(connection.capture(&event_frame("a", &raw)));
+ assert!(live.exhausted());
+ }
+
fn registry() -> IngressRegistry {
IngressRegistry::new(["one".to_owned(), "two".to_owned()].into_iter())
}
@@ -216,7 +617,7 @@ mod tests {
registry: &IngressRegistry,
targets: &[&str],
budget: &Arc<FetchBudget>,
- ) -> FetchRegistration {
+ ) -> IngressRegistration {
registry
.register(
targets.iter().map(|target| (*target).to_owned()),
@@ -302,7 +703,7 @@ mod tests {
.is_none()
);
assert!(registry.connection("unknown").is_none());
- let mut registrations = (0..MAX_ACTIVE_FETCHES)
+ let mut registrations = (0..MAX_ACTIVE_SCOPES)
.map(|_| register(®istry, &["one"], &budget))
.collect::<Vec<_>>();
assert!(
diff --git a/crates/transport_nostr/src/source_original.rs b/crates/transport_nostr/src/source_original.rs
@@ -0,0 +1,126 @@
+//! Original source evidence, correlated without treating a normalized key as
+//! admission. Only original bytes leave this bounded queue.
+use core::mem;
+use nostr_sdk::prelude::Event;
+use serde_json::value::RawValue;
+use sha2::{Digest as _, Sha256};
+use std::{collections::VecDeque, fmt};
+
+pub(crate) const MAX_PENDING_EVENTS: usize = 256;
+pub(crate) const MAX_PENDING_BYTES: usize = 4 * 1024 * 1024;
+pub(crate) const MAX_ORIGINAL_EVENT_BYTES: usize =
+ radroots_protocol::profile::SIGNED_EVENT_MAX_BYTES;
+
+struct Original {
+ owner: u64,
+ scope: u64,
+ correlation: [u8; 32],
+ raw: Box<str>,
+}
+
+pub(crate) struct OriginalQueue {
+ entries: VecDeque<Original>,
+ payload_bytes: usize,
+}
+impl Default for OriginalQueue {
+ fn default() -> Self {
+ Self {
+ entries: VecDeque::with_capacity(MAX_PENDING_EVENTS),
+ payload_bytes: 0,
+ }
+ }
+}
+impl fmt::Debug for OriginalQueue {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("OriginalQueue")
+ .field("events", &self.entries.len())
+ .field("retained_bytes", &self.retained_bytes())
+ .finish()
+ }
+}
+impl OriginalQueue {
+ pub(crate) fn retained_bytes(&self) -> usize {
+ mem::size_of::<Self>()
+ + self.entries.capacity() * mem::size_of::<Original>()
+ + self.payload_bytes
+ }
+ pub(crate) fn insert(
+ &mut self,
+ owner: u64,
+ scope: u64,
+ correlation: [u8; 32],
+ raw: &str,
+ ) -> bool {
+ if self.entries.len() == MAX_PENDING_EVENTS
+ || raw.len() > MAX_ORIGINAL_EVENT_BYTES
+ || raw.len() > MAX_PENDING_BYTES.saturating_sub(self.retained_bytes())
+ {
+ return false;
+ }
+ self.entries.push_back(Original {
+ owner,
+ scope,
+ correlation,
+ raw: Box::from(raw),
+ });
+ self.payload_bytes += raw.len();
+ true
+ }
+ pub(crate) fn take(&mut self, scope: u64, correlation: [u8; 32]) -> Option<String> {
+ let index = self
+ .entries
+ .iter()
+ .position(|entry| entry.scope == scope && entry.correlation == correlation)?;
+ let value = self.entries.remove(index)?;
+ self.payload_bytes -= value.raw.len();
+ Some(value.raw.into_string())
+ }
+ fn retain(&mut self, mut keep: impl FnMut(&Original) -> bool) {
+ let mut removed = 0;
+ self.entries.retain(|value| {
+ if keep(value) {
+ true
+ } else {
+ removed += value.raw.len();
+ false
+ }
+ });
+ self.payload_bytes -= removed;
+ }
+ pub(crate) fn remove_scope(&mut self, scope: u64) {
+ self.retain(|entry| entry.scope != scope);
+ }
+ pub(crate) fn remove_owner(&mut self, owner: u64) {
+ self.retain(|entry| entry.owner != owner);
+ }
+}
+
+/// The key is only correlation with the same already-pinned upstream decoder.
+/// It grants no identity/signature/profile authority and is never substituted
+/// for original bytes. Different raw spellings remain separate queued entries.
+pub(crate) fn correlation(event: &Event) -> [u8; 32] {
+ Sha256::digest(event.as_json().as_bytes()).into()
+}
+
+pub(crate) fn frame(raw: &str) -> Option<(String, &RawValue)> {
+ if raw.len() > crate::session_socket::MAX_WIRE_MESSAGE_BYTES {
+ return None;
+ }
+ let [kind, subscription, event]: [&RawValue; 3] = serde_json::from_str(raw).ok()?;
+ if kind.get().len() > 32 || subscription.get().len() > 6 * 256 + 2 {
+ return None;
+ }
+ let kind: String = serde_json::from_str(kind.get()).ok()?;
+ if kind != "EVENT" || event.get().len() > MAX_ORIGINAL_EVENT_BYTES {
+ return None;
+ }
+ let subscription: String = serde_json::from_str(subscription.get()).ok()?;
+ if subscription.is_empty() || subscription.len() > 256 {
+ return None;
+ }
+ Some((subscription, event))
+}
+
+#[cfg(test)]
+#[path = "source_original_queue_tests.rs"]
+mod tests;
diff --git a/crates/transport_nostr/src/source_original_queue_tests.rs b/crates/transport_nostr/src/source_original_queue_tests.rs
@@ -0,0 +1,85 @@
+use super::*;
+
+#[test]
+fn pending_count_refuses_next_entry_without_evicting_originals() {
+ let mut queue = OriginalQueue::default();
+ let baseline = queue.retained_bytes();
+ for i in 0..MAX_PENDING_EVENTS {
+ assert!(queue.insert(1, i as u64, [0; 32], "synthetic original"));
+ }
+ let exact = queue.retained_bytes();
+ assert_eq!(
+ exact,
+ baseline + MAX_PENDING_EVENTS * "synthetic original".len()
+ );
+ assert!(!queue.insert(2, 999, [0; 32], "next"));
+ assert_eq!(queue.retained_bytes(), exact);
+ assert_eq!(
+ queue.take(0, [0; 32]).as_deref(),
+ Some("synthetic original")
+ );
+ assert!(queue.insert(2, 999, [0; 32], "next"));
+}
+
+#[test]
+fn complete_byte_bound_includes_reserved_entries_and_releases_only_taken_or_owned_data() {
+ let mut queue = OriginalQueue::default();
+ let baseline = queue.retained_bytes();
+ let mut index = 0;
+ while MAX_PENDING_BYTES - queue.retained_bytes() > MAX_ORIGINAL_EVENT_BYTES {
+ assert!(queue.insert(1, index, [0; 32], &"a".repeat(MAX_ORIGINAL_EVENT_BYTES)));
+ index += 1;
+ }
+ let remaining = MAX_PENDING_BYTES - queue.retained_bytes();
+ assert!(queue.insert(2, index, [0; 32], &"b".repeat(remaining)));
+ assert_eq!(queue.retained_bytes(), MAX_PENDING_BYTES);
+ assert!(!queue.insert(3, index + 1, [0; 32], "x"));
+ assert_eq!(queue.retained_bytes(), MAX_PENDING_BYTES);
+ assert_eq!(queue.take(index, [0; 32]).unwrap().len(), remaining);
+ assert_eq!(queue.retained_bytes(), MAX_PENDING_BYTES - remaining);
+ queue.remove_owner(1);
+ assert_eq!(queue.retained_bytes(), baseline);
+ assert!(queue.entries.is_empty());
+ assert!(!queue.insert(1, 1, [0; 32], &"a".repeat(MAX_ORIGINAL_EVENT_BYTES + 1)));
+ assert_eq!(queue.retained_bytes(), baseline);
+}
+
+#[test]
+fn correlation_is_scoped_fifo_and_never_reconstructs_original_spelling() {
+ let mut queue = OriginalQueue::default();
+ assert!(queue.insert(1, 10, [1; 32], "{ \"a\": 1 }"));
+ assert!(queue.insert(1, 10, [1; 32], "{\"a\":1}"));
+ assert!(queue.insert(2, 20, [1; 32], "another scope"));
+ assert!(queue.take(10, [2; 32]).is_none());
+ assert!(queue.take(99, [1; 32]).is_none());
+ assert_eq!(queue.take(10, [1; 32]).as_deref(), Some("{ \"a\": 1 }"));
+ queue.remove_scope(10);
+ assert!(queue.take(10, [1; 32]).is_none());
+ assert_eq!(queue.take(20, [1; 32]).as_deref(), Some("another scope"));
+ assert!(!format!("{queue:?}").contains("another scope"));
+}
+
+#[test]
+fn raw_frame_projection_preserves_object_bytes_and_bounds_header_decoding() {
+ let raw = "[\"EV\\u0045NT\",\"a\\u0062\", { \"unknown\": [1, 2] }]";
+ let (subscription, value) = frame(raw).unwrap();
+ assert_eq!(subscription, "ab");
+ assert_eq!(value.get(), "{ \"unknown\": [1, 2] }");
+ for raw in [
+ "[]".into(),
+ "{}".into(),
+ "[\"EVENT\",\"a\"]".into(),
+ "[\"EVENT\",\"\",{}]".into(),
+ "[\"EOSE\",\"a\",{}]".into(),
+ format!("[\"{}\",\"a\",{{}}]", "E".repeat(33)),
+ format!("[\"EVENT\",\"{}\",{{}}]", "a".repeat(6 * 256 + 1)),
+ format!("[\"EVENT\",\"{}\",{{}}]", "a".repeat(257)),
+ format!(
+ "[\"EVENT\",\"a\",{{\"large\":\"{}\"}}]",
+ "a".repeat(MAX_ORIGINAL_EVENT_BYTES)
+ ),
+ "x".repeat(crate::session_socket::MAX_WIRE_MESSAGE_BYTES + 1),
+ ] {
+ assert!(frame(&raw).is_none());
+ }
+}
diff --git a/crates/transport_nostr/src/source_original_tests.rs b/crates/transport_nostr/src/source_original_tests.rs
@@ -0,0 +1,209 @@
+use super::*;
+use crate::RelayUrlPolicy;
+use futures::SinkExt;
+use radroots_transport::{
+ EventSubscriber, FetchRequest, SubscriptionNext, SubscriptionRequest, Target, TargetSet,
+ source::{FetchBounds, FetchSelector, SubscriptionBounds},
+};
+use tokio_tungstenite::{accept_async, tungstenite::Message};
+
+async fn observed_wire(original: String, live: bool) -> String {
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let url = format!("ws://{}", listener.local_addr().unwrap());
+ let endpoint =
+ crate::RelayEndpoint::new(&url, RelayUrlPolicy::Local, crate::RelayAccess::ReadOnly)
+ .unwrap();
+ let profile =
+ crate::RelayProfile::explicit(crate::RelayProfileKind::Simulator, [endpoint]).unwrap();
+ let transport = crate::test_host::transport(crate::Config::from_profile(profile));
+ let server = tokio::spawn(async move {
+ let (tcp, _) = listener.accept().await.unwrap();
+ let mut socket = accept_async(tcp).await.unwrap();
+ while let Some(Ok(frame)) = socket.next().await {
+ match frame {
+ Message::Text(text) => {
+ let value: serde_json::Value = serde_json::from_str(&text).unwrap();
+ if value[0] == "REQ" {
+ socket
+ .send(Message::Text(
+ format!("[\"EVENT\",{},{}]", value[1], original).into(),
+ ))
+ .await
+ .unwrap();
+ socket
+ .send(Message::Text(
+ serde_json::json!(["EOSE", value[1]]).to_string().into(),
+ ))
+ .await
+ .unwrap();
+ }
+ }
+ Message::Close(_) => break,
+ _ => {
+ if socket.flush().await.is_err() {
+ break;
+ }
+ }
+ }
+ }
+ });
+ let targets = TargetSet::new(vec![Target::nostr_relay(&url).unwrap()]).unwrap();
+ let obtained = if live {
+ let request = SubscriptionRequest::new(
+ "original-protected-live",
+ targets,
+ SubscriptionBounds::new(10, crate::host_time::unix_time_ms() + 5000).unwrap(),
+ )
+ .unwrap();
+ let mut subscription = transport.subscribe(request).await.unwrap();
+ let SubscriptionNext::Event(observed) = subscription.next().await.unwrap() else {
+ panic!("Expected original live event");
+ };
+ let original = observed.observed().event().raw_json().to_owned();
+ subscription.cancel().await.unwrap();
+ original
+ } else {
+ let request = FetchRequest::new(
+ "original-protected-caller",
+ targets,
+ FetchBounds::new(10, crate::host_time::unix_time_ms() + 5000).unwrap(),
+ )
+ .unwrap();
+ let page = transport.fetch(request).await.unwrap();
+ assert_eq!(page.events().len(), 1);
+ page.events()[0].event().raw_json().to_owned()
+ };
+ transport.shutdown().await;
+ server.await.unwrap();
+ obtained
+}
+
+#[tokio::test]
+async fn ordinary_source_preserves_originals_through_protected_commerce_admission() {
+ use radroots_nostr::{
+ commerce::{self, RecordOpening},
+ key::SecretKey,
+ private_ingress::OpeningError,
+ signing::LocalSigner,
+ };
+ use radroots_signing::provider::ProviderCall;
+ tokio::time::timeout(Duration::from_secs(15), async {
+ let fixture: serde_json::Value =
+ serde_json::from_str(include_str!("../tests/fixtures/source_original.v1.json"))
+ .unwrap();
+ let base: serde_json::Value =
+ serde_json::from_str(fixture["raw_wrap"].as_str().unwrap()).unwrap();
+ let scalar = fixture["recipient_scalar"].as_u64().unwrap();
+ let signer =
+ LocalSigner::with_clock(SecretKey::parse(&format!("{scalar:064x}")).unwrap(), || {
+ Ok(1000)
+ })
+ .unwrap();
+ for (live, extension) in [(false, false), (false, true), (true, false), (true, true)] {
+ let mut body = base.clone();
+ if extension {
+ body["future_transport_extension"] = serde_json::json!(true);
+ }
+ let original = serde_json::to_string_pretty(&body).unwrap();
+ let obtained = observed_wire(original.clone(), live).await;
+ assert!(
+ obtained == original,
+ "Ordinary observed SignedEvent must retain exact original object bytes"
+ );
+ let call = ProviderCall::new(
+ signer.public_key(),
+ core::num::NonZeroU64::new(2000).unwrap(),
+ radroots_signing::request::CancellationSignal::new(),
+ );
+ let result = commerce::open(&signer, call, &obtained).await;
+ if extension {
+ assert_eq!(result.unwrap_err(), OpeningError::InvalidInput);
+ } else {
+ assert!(matches!(result.unwrap(), RecordOpening::Known(_)));
+ }
+ }
+ })
+ .await
+ .unwrap();
+}
+
+#[tokio::test]
+async fn live_fetch_retains_original_signed_outer_object_bytes() {
+ tokio::time::timeout(Duration::from_secs(10), async {
+ let fixture: serde_json::Value =
+ serde_json::from_str(include_str!("../tests/fixtures/source_original.v1.json"))
+ .unwrap();
+ let value: serde_json::Value =
+ serde_json::from_str(fixture["raw_wrap"].as_str().unwrap()).unwrap();
+ let original = serde_json::to_string_pretty(&value).unwrap();
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let url = format!("ws://{}", listener.local_addr().unwrap());
+ let endpoint =
+ crate::RelayEndpoint::new(&url, RelayUrlPolicy::Local, crate::RelayAccess::ReadOnly)
+ .unwrap();
+ let connector = crate::session_socket::SessionWebsocketTransport::new(
+ &[endpoint],
+ Duration::from_secs(1),
+ Arc::new(crate::test_host::LoopbackConnector),
+ );
+ let ingress = connector.ingress.clone();
+ let client = nostr_sdk::client::Client::builder()
+ .websocket_transport(connector)
+ .build();
+ let server_original = original.clone();
+ let server = tokio::spawn(async move {
+ let (tcp, _) = listener.accept().await.unwrap();
+ let mut socket = accept_async(tcp).await.unwrap();
+ while let Some(frame) = socket.next().await {
+ let Ok(frame) = frame else { break };
+ match frame {
+ Message::Text(text) => {
+ let value: serde_json::Value = serde_json::from_str(&text).unwrap();
+ if value[0] == "REQ" {
+ let frame = format!("[\"EVENT\",{},{}]", value[1], server_original);
+ socket.send(Message::Text(frame.into())).await.unwrap();
+ socket
+ .send(Message::Text(
+ serde_json::json!(["EOSE", value[1]]).to_string().into(),
+ ))
+ .await
+ .unwrap();
+ }
+ }
+ Message::Close(_) => break,
+ _ => {
+ socket.flush().await.unwrap();
+ }
+ }
+ }
+ });
+ let source = LiveRelaySourceClient::new(
+ client.clone(),
+ ingress,
+ Arc::new(crate::connections::Connections::new(1)),
+ );
+ let batches = source
+ .fetch(SourceQuery {
+ relays: vec![RelayUrl::parse(&url, RelayUrlPolicy::Local).unwrap()],
+ selector: FetchSelector::all(),
+ until_unix_seconds: None,
+ connect_timeout: Duration::from_secs(1),
+ deadline: crate::host_time::Instant::now() + Duration::from_secs(5),
+ max_connections: 1,
+ })
+ .await;
+ client.shutdown().await;
+ server.await.unwrap();
+ assert_eq!(batches.len(), 1);
+ let RelayFetchResult::Complete(events) = &batches[0].result else {
+ panic!("{:?}", batches[0].result)
+ };
+ assert_eq!(events.len(), 1);
+ assert!(
+ events[0] == original,
+ "The actual source must retain original event bytes before SDK reserialization"
+ );
+ })
+ .await
+ .unwrap();
+}
diff --git a/crates/transport_nostr/src/subscription.rs b/crates/transport_nostr/src/subscription.rs
@@ -64,16 +64,19 @@ pub(crate) trait RelaySubscriptionClient: Send + Sync {
pub(crate) struct LiveRelaySubscriptionClient {
client: nostr_sdk::client::Client,
connections: std::sync::Arc<crate::connections::Connections>,
+ ingress: crate::source_ingress::IngressRegistry,
}
impl LiveRelaySubscriptionClient {
pub(crate) const fn new(
client: nostr_sdk::client::Client,
connections: std::sync::Arc<crate::connections::Connections>,
+ ingress: crate::source_ingress::IngressRegistry,
) -> Self {
Self {
client,
connections,
+ ingress,
}
}
@@ -85,6 +88,7 @@ impl LiveRelaySubscriptionClient {
std::sync::Arc::new(crate::connections::Connections::new(
crate::client::MAX_RELAYS,
)),
+ crate::source_ingress::IngressRegistry::default(),
)
}
}
@@ -100,9 +104,22 @@ impl RelaySubscriptionClient for LiveRelaySubscriptionClient {
let subscription_id = SubscriptionId::new(query.id);
let mut targeted = Vec::with_capacity(query.targets.len());
let mut relay_lookup = BTreeMap::new();
+ let originals = self
+ .ingress
+ .register_live(
+ query
+ .targets
+ .iter()
+ .map(|target| target.relay.as_str().to_owned()),
+ )
+ .ok_or(())?;
+ let mut original_scopes = BTreeMap::new();
for target in query.targets {
let url = target.relay.as_str().to_owned();
+ let original = originals
+ .bind_originals(&url, subscription_id.as_str())
+ .ok_or(())?;
let filter = subscription_filter(&query.selector, target.since_unix_seconds)?;
self.client
.add_relay(url.as_str())
@@ -118,6 +135,7 @@ impl RelaySubscriptionClient for LiveRelaySubscriptionClient {
.await
.map_err(|_| ())?;
relay_lookup.insert(url.clone(), target.relay);
+ original_scopes.insert(url.clone(), original);
targeted.push((url, vec![filter]));
}
@@ -149,6 +167,8 @@ impl RelaySubscriptionClient for LiveRelaySubscriptionClient {
notifications: Some(notifications),
relay_lookup,
cancelled: false,
+ originals: Some(originals),
+ original_scopes,
};
Ok(Box::new(session) as Box<dyn RelaySubscriptionSession>)
})
@@ -161,6 +181,8 @@ struct LiveRelaySubscriptionSession {
notifications: Option<nostr_sdk::stream::NotificationStreamWithGaps<ClientNotification>>,
relay_lookup: BTreeMap<String, RelayUrl>,
cancelled: bool,
+ originals: Option<crate::source_ingress::IngressRegistration>,
+ original_scopes: BTreeMap<String, crate::source_ingress::OriginalSubscription>,
}
impl RelaySubscriptionSession for LiveRelaySubscriptionSession {
@@ -171,13 +193,33 @@ impl RelaySubscriptionSession for LiveRelaySubscriptionSession {
return Ok(RelaySubscriptionItem::Shutdown);
};
loop {
- let notification = match notifications.next().await {
+ if self
+ .originals
+ .as_ref()
+ .is_none_or(|scope| scope.exhausted())
+ {
+ return Err(());
+ }
+ let originals = self.originals.as_ref().ok_or(())?;
+ let received = tokio::select! {
+ biased;
+ _ = originals.wait_exhausted() => return Err(()),
+ received = notifications.next() => received,
+ };
+ let notification = match received {
Some(Ok(notification)) => notification,
Some(Err(_)) => return Err(()),
None => {
return Ok(RelaySubscriptionItem::Shutdown);
}
};
+ if self
+ .originals
+ .as_ref()
+ .is_none_or(|scope| scope.exhausted())
+ {
+ return Err(());
+ }
match notification {
ClientNotification::Message { relay_url, message } => {
let Some(relay) = self.relay_lookup.get(relay_url.as_str()).cloned() else {
@@ -188,10 +230,12 @@ impl RelaySubscriptionSession for LiveRelaySubscriptionSession {
subscription_id,
event,
} if subscription_id.as_ref() == &self.subscription_id => {
- return Ok(RelaySubscriptionItem::Event {
- relay,
- raw: event.as_json(),
- });
+ let raw = self
+ .original_scopes
+ .get(relay_url.as_str())
+ .and_then(|scope| scope.take(&event))
+ .ok_or(())?;
+ return Ok(RelaySubscriptionItem::Event { relay, raw });
}
RelayMessage::Closed {
subscription_id, ..
@@ -233,6 +277,8 @@ impl RelaySubscriptionSession for LiveRelaySubscriptionSession {
}
self.cancelled = true;
self.notifications = None;
+ self.original_scopes.clear();
+ self.originals = None;
}
Ok(())
})
diff --git a/crates/transport_nostr/tests/fixtures/source_original.v1.json b/crates/transport_nostr/tests/fixtures/source_original.v1.json
@@ -0,0 +1,18 @@
+{
+ "schema": "radroots.transport.source.original_fixture.v1",
+ "provenance": {
+ "repository": "https://github.com/radrootslabs/lib",
+ "revision": "21ddcd6755fe7de99ea0284c88729fd6adfc5416",
+ "path": "crates/nostr/tests/fixtures/commerce_envelopes.v1.json",
+ "sha256": "bd59710bedc337b5e4bdcb1c0753de06a74927027b76a0202b251b0e45d02565",
+ "producer": {
+ "library": "nostr-tools",
+ "version": "2.23.5",
+ "revision": "ed47ef8ef73d78c338fbaf530e48be0fd4282194"
+ },
+ "scope": "One projected public synthetic independent NIP59 fixture; no runtime keys or external participant data."
+ },
+ "name": "quote/peer",
+ "recipient_scalar": 2,
+ "raw_wrap": "{\"id\":\"d3197dd91a831135e51824a6aee4afcda60142b14cdc0c9c1cd7745724d2cf72\",\"pubkey\":\"4a5169f673aa632f538aaa128b6348536db2b637fd89073d49b6a23879cdb3ad\",\"created_at\":1699997999,\"kind\":1059,\"tags\":[[\"p\",\"c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5\"]],\"content\":\"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\",\"sig\":\"662b3c9e4c9570bb4a87bb1294cc13abcae9be331fcc55ba70e14b31670a92aa727c7b29d682fb110d2af364c91402f16f1a18f0ccb63af1b636cb511c6b874f\"}"
+}
diff --git a/crates/transport_nostr/tests/package_boundary.rs b/crates/transport_nostr/tests/package_boundary.rs
@@ -14,6 +14,44 @@ const SINK: &str = include_str!("../src/sink.rs");
const SUBSCRIPTION: &str = include_str!("../src/subscription.rs");
#[test]
+fn original_network_contract_preserves_bounded_untrusted_wire_and_standalone_fixture_provenance() {
+ let contract: serde_json::Value = serde_json::from_str(include_str!(
+ "../../../contracts/protocol/source_original.v1.json"
+ ))
+ .unwrap();
+ assert_eq!(
+ contract["original_event_max_utf8_bytes"],
+ radroots_protocol::profile::SIGNED_EVENT_MAX_BYTES
+ );
+ assert_eq!(contract["pending_events_max"], 256);
+ assert_eq!(contract["pending_bytes_max"], 4 * 1024 * 1024);
+ let fixture: serde_json::Value =
+ serde_json::from_str(include_str!("fixtures/source_original.v1.json")).unwrap();
+ assert_eq!(
+ fixture["provenance"]["revision"],
+ "21ddcd6755fe7de99ea0284c88729fd6adfc5416"
+ );
+ assert_eq!(
+ fixture["provenance"]["sha256"],
+ "bd59710bedc337b5e4bdcb1c0753de06a74927027b76a0202b251b0e45d02565"
+ );
+ assert!(
+ !SUBSCRIPTION
+ .split("\n#[cfg(test)]")
+ .next()
+ .unwrap()
+ .contains("raw: event.as_json()")
+ );
+ assert!(
+ !include_str!("../src/source.rs")
+ .split("\n#[cfg(test)]\nmod tests")
+ .next()
+ .unwrap()
+ .contains("let raw = event.as_ref().as_json()")
+ );
+}
+
+#[test]
fn manifest_and_root_match_the_governed_transport_boundary() {
for required in [
"name = \"radroots_transport_nostr\"",
@@ -52,6 +90,7 @@ fn manifest_and_root_match_the_governed_transport_boundary() {
"socket_write",
"source",
"source_ingress",
+ "source_original",
"session_socket",
"test_host",
"status",
@@ -336,6 +375,9 @@ fn adapter_owns_no_storage_outbox_or_orchestration_surface() {
"source.rs".to_owned(),
"source_budget.rs".to_owned(),
"source_ingress.rs".to_owned(),
+ "source_original.rs".to_owned(),
+ "source_original_queue_tests.rs".to_owned(),
+ "source_original_tests.rs".to_owned(),
"source_paging_tests.rs".to_owned(),
"source_window.rs".to_owned(),
"session_socket.rs".to_owned(),