Source code for fleetmesh_node.planes.transport.bridge.compartment

"""Universal Nostr Relay Bridge for fleetmesh.

Bridges external standard Nostr relays (strfry, nostr-rs-relay, khatru, coracle, damus)
with the local fleetmesh node:
1. Ingress Engine: Connects to designated external relays over WebSocket (via Relay/ws),
   subscribes to shard topics (#t), mesh control kinds (11801, 11803, 30803, etc.) or
   user content kinds (0, 1, 3, 7, 1059, etc.), cryptographically verifies BIP-340 signatures,
   enforces future timestamp and expiry limits, deduplicates, and ingests into the local
   NodeStore with origin recorded.
2. Egress Engine: Queues and publishes verified events (produced locally or across the mesh)
   out to designated external relays, tracking acceptance, handling NIP-42 auth challenges,
   and retrying on transient errors.
3. Flow Control & Capacity: Sliding-window rate limiting per relay to protect node
   memory and disk from upstream relay flooding, integrated with the Compartment refusal
   and trouble reporting interfaces.
"""
from __future__ import annotations

import json
import threading
import time
from typing import Any, Callable, cast, Mapping, Optional, Sequence, Union
from fleetmesh_core.storage import store  # noqa: E402
from fleetmesh_node import channels as ch_mod  # noqa: E402
from fleetmesh_node import compartment as compartment_mod  # noqa: E402
from fleetmesh_node.compartment import Command, Compartment, Need  # noqa: E402
from fleetmesh_node.config.parameter import Parameter  # noqa: E402
from fleetmesh_node import metrics as mx_mod  # noqa: E402
from fleetmesh_node.protocols.nostr import client as relay  # noqa: E402
from fleetmesh_core.crypto import giftwrap  # noqa: E402
from fleetmesh_core.wire.interfaces import NostrEvent  # noqa: E402
from fleetmesh_node.config import BridgeConfig  # noqa: E402
from fleetmesh_node.config import compartments as cfgblocks  # noqa: E402
from fleetmesh_node.compartment import stores as st  # noqa: E402
from fleetmesh_node.planes.transport.bridge.ratelimit import RateLimiter  # noqa: E402  (shared, audit D4)

# The defaults live on the config block (fleetmesh_node/config/compartments.py) so the
# check and the compartment cannot disagree; re-exported here for callers.
DEFAULT_INGRESS_KINDS = cfgblocks.DEFAULT_INGRESS_KINDS
DEFAULT_EGRESS_KINDS = cfgblocks.DEFAULT_EGRESS_KINDS
DEFAULT_INGRESS_FILTERS = cfgblocks.DEFAULT_INGRESS_FILTERS
DEFAULT_RATE_LIMIT_PER_MIN = cfgblocks.DEFAULT_RATE_LIMIT_PER_MIN
DEFAULT_MAX_FUTURE_SECONDS = cfgblocks.DEFAULT_MAX_FUTURE_SECONDS
DEFAULT_MAX_EVENT_BYTES = cfgblocks.DEFAULT_MAX_EVENT_BYTES


from .types import (
    RelayWorkerStats,
    BridgeStateReport,
)

[docs]class BridgeError(Exception): pass
[docs]class RelayBridgeWorker: """Manages an active subscription and streaming connection to a single external Nostr relay."""
[docs] def __init__( self, url: str, filters: Sequence[Mapping[str, Any]], on_event: Callable[[NostrEvent, str], Any], auth_signer: Optional[Callable[[str, str], Optional[Mapping[str, Any]]]] = None, timeout: float = 15.0, stop_event: Optional[threading.Event] = None, ) -> None: self.url: str = url self.filters: list[Mapping[str, Any]] = list(filters) self.on_event: Callable[[NostrEvent, str], Any] = on_event self.auth_signer: Optional[Callable[[str, str], Optional[Mapping[str, Any]]]] = auth_signer self.timeout: float = timeout self.connected: bool = False self.last_connected_at: Optional[int] = None self.ingress_count: int = 0 self.egress_count: int = 0 self.errors_count: int = 0 self.last_error: Optional[str] = None # Exceptions raised by on_event; the subscription outlives them. self.handler_errors: int = 0 self.last_handler_error: Optional[str] = None self.last_event_at: Optional[int] = None self._stop_event: threading.Event = threading.Event() self._bridge_stop_event: Optional[threading.Event] = stop_event self._thread: Optional[threading.Thread] = None self._relay: Optional[relay.Relay] = None self._lock: threading.Lock = threading.Lock()
def _is_stopped(self) -> bool: return self._stop_event.is_set() or (self._bridge_stop_event is not None and self._bridge_stop_event.is_set())
[docs] def start(self) -> None: with self._lock: if self._thread is not None and self._thread.is_alive(): return self._stop_event.clear() self._thread = threading.Thread(target=self._run, name=f'relay-bridge-{self.url}', daemon=True) self._thread.start()
[docs] def stop(self) -> None: self._stop_event.set() with self._lock: if self._relay is not None: try: self._relay.close() except Exception: pass self._relay = None self.connected = False if self._thread is not None and self._thread.is_alive(): self._thread.join(timeout=1.0) self._thread = None
def _run(self) -> None: consecutive_errors = 0 while not self._is_stopped(): try: r = relay.Relay(self.url, timeout=self.timeout, auth_signer=self.auth_signer) r.connect() with self._lock: self._relay = r self.connected = True self.last_connected_at = int(time.time()) self.last_error = None consecutive_errors = 0 sid = r.subscribe(self.filters, ready=False) for ev in r.events(sid): if self._is_stopped(): break self.ingress_count += 1 self.last_event_at = int(time.time()) try: self.on_event(ev, self.url) except Exception as e: # A handler bug (or one poisoned event) costs that # event, not the subscription: tearing the socket # down and reconnecting would replay the same # event and fail the same way, forever. self.handler_errors += 1 self.last_handler_error = '%s: %s' % (type(e).__name__, str(e)[:200]) except Exception as e: consecutive_errors += 1 self.errors_count += 1 self.last_error = f'{type(e).__name__}: {e}' with self._lock: self.connected = False if self._relay is not None: try: self._relay.close() except Exception: pass self._relay = None finally: with self._lock: self.connected = False if self._relay is not None: try: self._relay.close() except Exception: pass self._relay = None if not self._is_stopped(): backoff = min(30.0, 1.0 * (2 ** min(consecutive_errors, 5))) self._stop_event.wait(backoff)
[docs] def publish(self, ev: NostrEvent) -> tuple[bool, str]: """Publish one event directly to this relay, returning (accepted, reason).""" pub_client = relay.Relay(self.url, timeout=self.timeout, auth_signer=self.auth_signer) try: pub_client.connect() accepted, reason = pub_client.publish(ev) if accepted: self.egress_count += 1 return accepted, reason except Exception as e: self.errors_count += 1 self.last_error = f'publish: {type(e).__name__}: {e}' return False, str(e) finally: pub_client.close()
[docs] def stats(self) -> RelayWorkerStats: return { 'url': self.url, 'connected': self.connected, 'last_connected_at': self.last_connected_at, 'ingress_count': self.ingress_count, 'egress_count': self.egress_count, 'errors_count': self.errors_count, 'last_error': self.last_error, 'handler_errors': self.handler_errors, 'last_handler_error': self.last_handler_error, 'last_event_at': self.last_event_at, }
[docs]class RelayBridge(Compartment): optional: bool = True enabled_by: Optional[str] = 'bridge' """The Universal Nostr Relay Bridge compartment.""" name: str = 'bridge' uses: tuple[str, ...] = ('p2p',) # external ingress is re-broadcast on the P2P gossip when it is on reads: tuple[str, ...] = ('bridge', 'relays') config_cls = BridgeConfig live: tuple[str, ...] = ('bridge',) NEEDS = ( Need('store_backend', 'stores.events'), Need('face', 'face'), Need('relays', 'relays'), Need('cfg', block=BridgeConfig), Need('p2p', 'p2p'), ) STORES = ( st.Store( key='egress_queue', description='events queued for broadcast to external relays', kind=st.RING, bound=1000, ), ) egress_queue: st.Ring[tuple[Any, ...]] CHANNELS = ( ch_mod.Channel('ingress_stored', 'An event received from an external relay was verified and stored', level=ch_mod.NOTE, say='bridge stored event {id} from {relay}', tags=('bridge', 'ingress')), ch_mod.Channel('ingress_refused', 'An event received from an external relay was refused', level=ch_mod.TROUBLE, say='bridge refused event from {relay}: {reason}', tags=('bridge', 'ingress', 'refused')), ch_mod.Channel('egress_sent', 'An event was published to external relays', level=ch_mod.NOTE, say='bridge published event {id} to {relay}', tags=('bridge', 'egress')), ch_mod.Channel('egress_failed', 'Failed to publish event to an external relay', level=ch_mod.TROUBLE, say='bridge failed to publish to {relay}: {reason}', tags=('bridge', 'egress', 'failed')), ) METRICS = ( mx_mod.Metric(name='bridge_ingress_stored', description='Events received from external relays and stored.', kind=mx_mod.COUNTER, counts='ingress_stored', tags=('bridge', 'ingress')), mx_mod.Metric(name='bridge_ingress_refused', description='Events received from external relays and refused.', kind=mx_mod.COUNTER, counts='ingress_refused', tags=('bridge', 'ingress')), mx_mod.Metric(name='bridge_egress_sent', description='Events published to external relays.', kind=mx_mod.COUNTER, counts='egress_sent', tags=('bridge', 'egress')), mx_mod.Metric(name='bridge_egress_failed', description='Events that failed publication to external relays.', kind=mx_mod.COUNTER, counts='egress_failed', tags=('bridge', 'egress')), ) COMMANDS = ( Command( key='show', name='Bridge Status', description='display bridge status and connected relays', tags=('bridge', 'status'), permission='bridge/show', run='state', reply='dict', ), Command( key='publish', name='Publish Event', description='publish a nostr event to external relays', tags=('bridge', 'publish'), parameters=( Parameter(key='event', name='event', description='nostr event object', type=dict, default=dict, required=True), Parameter(key='relays', name='relays', description='target relays list', type=list, default=None, required=False), ), permission='bridge/publish', run='publish_cmd', reply='dict', ), Command( key='sync', name='Sync Query', description='query external relays for matching events', tags=('bridge', 'sync'), parameters=( Parameter(key='filter', name='filter', description='subscription filter', type=object, default=None, required=False), Parameter(key='relay', name='relay', description='target relay URL', type=str, default=None, required=False), ), permission='bridge/sync', run='sync_cmd', reply='dict', ), Command( key='reconcile', name='Reconcile With Relay', description='reconcile events with a target relay', tags=('bridge', 'reconcile'), parameters=( Parameter(key='relay', name='relay', description='target relay URL', type=str, default=None, required=False), Parameter(key='filter', name='filter', description='subscription filter', type=object, default=None, required=False), Parameter(key='since', name='since', description='start timestamp', type=int, default=None, required=False), Parameter(key='until', name='until', description='end timestamp', type=int, default=None, required=False), Parameter(key='limit', name='limit', description='max events', type=int, default=500, required=False), ), permission='bridge/reconcile', run='reconcile_cmd', reply='dict', ), Command( key='add_relay', name='Add Relay', description='add an external relay URL to bridge', tags=('bridge', 'relay'), parameters=( Parameter(key='url', name='url', description='relay ws:// or wss:// URL', type=str, default='', required=True), ), permission='bridge/add_relay', run='add_relay_cmd', reply='dict', ), Command( key='remove_relay', name='Remove Relay', description='remove an external relay URL from bridge', tags=('bridge', 'relay'), parameters=( Parameter(key='url', name='url', description='relay URL to remove', type=str, default='', required=True), ), permission='bridge/remove_relay', run='remove_relay_cmd', reply='dict', ), Command( key='cursor', name='Bridge Cursors', description='query persistent relay checkpoint cursors', tags=('bridge', 'cursor'), permission='bridge/cursor', run='cursor_cmd', reply='list', ), Command( key='cursors', name='Bridge Cursors Alias', description='query persistent relay checkpoint cursors (alias)', tags=('bridge', 'cursor'), permission='bridge/cursor', run='cursor_cmd', reply='list', ), ) TROUBLE_WINDOW: int = 1800
[docs] def __init__( self, store_backend: Any, face: Optional[Any] = None, relays: Optional[Sequence[str]] = None, cfg: Optional[Union[BridgeConfig, Mapping[str, Any]]] = None, clock: Optional[Callable[[], int]] = None, node: Optional[Any] = None, p2p: Optional[Any] = None, ) -> None: super().__init__(node, clock) self.store: Any = store_backend self.face: Optional[Any] = face # The P2P compartment when the node built it (declared in `uses`, # resolved once by from_context); None on a node without p2p. self.p2p: Optional[Any] = p2p # Tests hand a dict; the node hands the typed block. The block is the shape. c = cfg if isinstance(cfg, BridgeConfig) else BridgeConfig.from_dict(cfg or {}) self.enabled: bool = c.enabled self.relays: list[str] = [str(u) for u in c.relays] if c.relays is not None else list(relays or []) # not a store: the configured relays self.ingress_enabled: bool = c.ingress.enabled self.ingress_filters: list[Mapping[str, Any]] = list(c.ingress.filters) # not a store: ingress filters from config self.rate_limit_per_min: int = c.ingress.rate_limit self.future_max_seconds: int = c.ingress.max_future_seconds self.max_event_bytes: int = c.ingress.max_bytes self.egress_enabled: bool = c.egress.enabled self.egress_kinds: set[int] = set(c.egress.kinds) # not a store: egress kinds from config self.auto_egress: bool = c.egress.auto self.workers: dict[str, RelayBridgeWorker] = {} # not a store: active worker threads per relay self.rate_limiters: dict[str, RateLimiter] = {} # not a store: rate limiters per relay self._global_rate_limiter: RateLimiter = RateLimiter(self.rate_limit_per_min * max(1, len(self.relays))) self._egress_queue = self.egress_queue self._lock: threading.Lock = threading.Lock() # Operational metrics self.ingress_stored: int = 0 self.ingress_duplicates: int = 0 self.p2p_forward_failures: int = 0 self.ingress_refused: int = 0 self.egress_sent: int = 0 self.egress_failed: int = 0 self.last_ingress_at: Optional[int] = None self.last_egress_at: Optional[int] = None # Wire auto-egress from local face if available if self.face is not None and hasattr(self.face, 'on_event_handlers'): self.face.on_event_handlers.append(self._on_local_face_event) # Initialize workers for r_url in self.relays: self._add_worker(r_url)
# The strfry relay bridge is a plugin now (fleetmesh-strfry, # `fleetmesh_strfry.plugin:StrfryBridgePlugin`), not a part of this one. def _add_worker(self, url: str) -> RelayBridgeWorker: if url in self.workers: return self.workers[url] # No NIP-42 signer: the bridge speaks to the external relays # unauthenticated. The node has no `auth_signer`, so the previous # `getattr(self.node, 'auth_signer')` was always None; a bridge that # authenticates is a feature, declared here when it exists. worker = RelayBridgeWorker( url=url, filters=self.ingress_filters, on_event=self.handle_ingress_event, stop_event=self._stop_event, ) self.workers[url] = worker self.rate_limiters[url] = RateLimiter(self.rate_limit_per_min) if self.enabled and self.ingress_enabled: worker.start() return worker def _remove_worker(self, url: str) -> None: worker = self.workers.pop(url, None) self.rate_limiters.pop(url, None) if worker is not None: worker.stop() def _on_local_face_event(self, ev: NostrEvent) -> None: """Triggered whenever the local node's relay face accepts an event.""" if not self.enabled or not self.egress_enabled or not self.auto_egress: return if ev.get('kind') in self.egress_kinds: self.enqueue_egress(ev)
[docs] def handle_ingress_event(self, ev: Any, relay_url: str) -> str: """Ingest, validate, and store an event received from an external relay. Returns one of: stored, duplicate, rate_limited, invalid, future_skew, expired. """ now = self.clock() eid = ev.get('id', '') if isinstance(ev, dict) else '' # Rate limiting: relay and global relay_limiter = self.rate_limiters.setdefault(relay_url, RateLimiter(self.rate_limit_per_min)) if not relay_limiter.allow(now) or not self._global_rate_limiter.allow(now): self.ingress_refused += 1 self.say('ingress_refused', relay=relay_url, reason='rate limit exceeded') self.refusals.refuse('ingress', 'rate limit exceeded', subject=eid[:16] or None, detail={'relay': relay_url, 'rate_limit': self.rate_limit_per_min}) return 'rate_limited' if not isinstance(ev, dict) or not isinstance(eid, str) or not eid: self.ingress_refused += 1 self.say('ingress_refused', relay=relay_url, reason='malformed event') self.refusals.refuse('ingress', 'malformed event object', subject=None, detail={'relay': relay_url}) return 'invalid' # Check payload size raw_size = len(json.dumps(ev, separators=(',', ':'))) if raw_size > self.max_event_bytes: self.ingress_refused += 1 self.say('ingress_refused', relay=relay_url, reason='event exceeds max size') self.refusals.refuse('ingress', 'event exceeds max size', subject=eid[:16], detail={'relay': relay_url, 'size': raw_size, 'limit': self.max_event_bytes}) return 'invalid' # Check cryptographic signature & ID if not giftwrap.verify_event(ev): self.ingress_refused += 1 self.say('ingress_refused', relay=relay_url, reason='signature verification failed') self.refusals.refuse('ingress', 'signature or id does not verify', subject=eid[:16], detail={'relay': relay_url, 'pubkey': ev.get('pubkey')}) return 'invalid' # Timestamp sanity check (clock skew) created_at = ev.get('created_at') if isinstance(created_at, int) and created_at > now + self.future_max_seconds: self.ingress_refused += 1 self.say('ingress_refused', relay=relay_url, reason='future timestamp') self.refusals.refuse('ingress', 'created_at too far in future', subject=eid[:16], detail={'relay': relay_url, 'skew': created_at - now, 'limit': self.future_max_seconds}) return 'future_skew' # Expiration check (NIP-40) exp = store.expiration(ev) if exp is not None and exp <= now: return 'expired' # Ephemeral check if store.is_ephemeral(ev.get('kind', 0)): if self.face is not None and hasattr(self.face, '_fanout'): self.face._fanout(ev) return 'ephemeral' # Deduplication check if hasattr(self.store, 'has_event') and self.store.has_event(eid): self.ingress_duplicates += 1 return 'duplicate' # Insert into store result = self.store.insert_event(ev, now) if result == 'stored': self.ingress_stored += 1 self.last_ingress_at = now self.say('ingress_stored', id=eid[:16], relay=relay_url) if hasattr(self.store, 'note_origin'): self.store.note_origin(eid, getattr(self.store, 'LOCAL', 'local')) if self.face is not None and hasattr(self.face, '_fanout'): self.face._fanout(ev) # P2P cross-forwarding: external ingress goes out on the local # gossip too. A failure there is the p2p compartment's to report; # here it is counted so the bridge's own status says it happened. if self.p2p is not None: try: self.p2p.broadcast(ev) except Exception as e: self.p2p_forward_failures += 1 self.refusals.refuse('p2p forward', 'raised', subject=ev.get('id'), detail=compartment_mod.why_detail(e)) # Persistent checkpoint tracking if hasattr(self.store, 'set_bridge_cursor') and relay_url: try: self.store.set_bridge_cursor(relay_url, last_event_at=ev.get('created_at', now), count_increment=1) except Exception: pass elif result == 'duplicate': self.ingress_duplicates += 1 return result
[docs] def publish( self, ev: NostrEvent, target_relays: Optional[Sequence[str]] = None, ) -> dict[str, tuple[bool, str]]: """Publish an event to external relays. Returns {relay_url: (accepted, reason)}. """ targets = list(target_relays) if target_relays else list(self.workers.keys()) out: dict[str, tuple[bool, str]] = {} for r_url in targets: worker = self.workers.get(r_url) if worker is None: worker = self._add_worker(r_url) accepted, reason = worker.publish(ev) out[r_url] = (accepted, reason) if accepted: self.egress_sent += 1 self.say('egress_sent', id=ev.get('id', '')[:16], relay=r_url) else: self.egress_failed += 1 self.say('egress_failed', relay=r_url, reason=reason[:32]) self.refusals.refuse('egress', f'relay rejected: {reason[:32]}', subject=ev.get('id', '')[:16], detail={'relay': r_url, 'reason': reason}) if out: self.last_egress_at = self.clock() return out
[docs] def enqueue_egress(self, ev: NostrEvent, target_relays: Optional[Sequence[str]] = None) -> None: """Enqueue an event to be published out to external relays asynchronously.""" with self._lock: targets = list(target_relays) if target_relays else None self.egress_queue.append((ev, targets))
[docs] def flush_egress(self) -> int: """Process and send all queued egress events. Returns count of processed items.""" items: list[tuple[NostrEvent, Optional[list[str]]]] = [] with self._lock: items = list(self.egress_queue) self.egress_queue.clear() for ev, targets in items: self.publish(ev, targets) return len(items)
[docs] def sync_query( self, filters: Sequence[Mapping[str, Any]], target_relays: Optional[Sequence[str]] = None, timeout: float = 15.0, ) -> Mapping[str, Any]: """Perform an ad-hoc query against external relays and ingest matching events.""" targets = list(target_relays) if target_relays else list(self.workers.keys()) results = relay.query_all(targets, filters, timeout=timeout) ingested = 0 duplicates = 0 for ev in results: outcome = self.handle_ingress_event(ev, 'query_sync') if outcome == 'stored': ingested += 1 elif outcome == 'duplicate': duplicates += 1 return { 'queried_relays': targets, 'events_found': len(results), 'ingested': ingested, 'duplicates': duplicates, }
[docs] def reconcile_with_relay( self, relay_url: str, filter_spec: Optional[Mapping[str, Any]] = None, since: Optional[int] = None, until: Optional[int] = None, limit: int = 500, ) -> Mapping[str, Any]: """Perform a range-bounded reconciliation against an external relay to backfill historical events.""" base_filter = dict(filter_spec or {}) if 'kinds' not in base_filter: base_filter['kinds'] = list(DEFAULT_INGRESS_KINDS) if since is None and hasattr(self.store, 'get_bridge_cursor'): try: cur = self.store.get_bridge_cursor(relay_url) if cur and cur.get('last_reconciled_at'): since = cur['last_reconciled_at'] except Exception: pass if since is not None: base_filter['since'] = since if until is not None: base_filter['until'] = until base_filter['limit'] = limit results = relay.query_all([relay_url], [base_filter], timeout=15.0) examined = len(results) stored_count = 0 duplicate_count = 0 for ev in results: outcome = self.handle_ingress_event(ev, relay_url) if outcome == 'stored': stored_count += 1 elif outcome == 'duplicate': duplicate_count += 1 target_until = until if until is not None else self.clock() if hasattr(self.store, 'set_bridge_cursor'): try: self.store.set_bridge_cursor(relay_url, last_reconciled_at=target_until, count_increment=0) except Exception: pass return { 'relay': relay_url, 'filter': base_filter, 'examined': examined, 'stored': stored_count, 'duplicates': duplicate_count, 'cursor': target_until, }
# ---- Compartment lifecycle & control -------------------------------------------
[docs] def start(self) -> None: super().start() if not self.enabled: return for worker in self.workers.values(): if self.ingress_enabled: worker.start()
[docs] def stop(self) -> list[tuple[str, str]]: super().stop() for worker in list(self.workers.values()): worker.stop() self.flush_egress() return [('stopped bridge', f'{len(self.workers)} workers stopped')]
[docs] def tick(self, now: int) -> list[tuple[Any, ...]]: did: list[tuple[Any, ...]] = [] if not self.enabled: return did # Health check on workers connected_count = sum(1 for w in self.workers.values() if w.connected) for url, worker in list(self.workers.items()): if self.ingress_enabled and not worker.connected: # Ensure thread is alive or restart worker.start() # Flush any queued egress items sent_count = self.flush_egress() if sent_count > 0: did.append(('bridge', f'flushed {sent_count} egress events')) did.append(('bridge', f'{connected_count}/{len(self.workers)} relays connected', f'ingress={self.ingress_stored} egress={self.egress_sent}')) return did
[docs] def state(self) -> BridgeStateReport: with self._lock: pending_egress = len(self.egress_queue) res: BridgeStateReport = { 'enabled': self.enabled, 'relays_configured': len(self.relays), 'relays_connected': sum(1 for w in self.workers.values() if w.connected), 'ingress': { 'enabled': self.ingress_enabled, 'stored': self.ingress_stored, 'duplicates': self.ingress_duplicates, 'p2p_forward_failures': self.p2p_forward_failures, 'refused': self.ingress_refused, 'last_event_at': self.last_ingress_at, }, 'egress': { 'enabled': self.egress_enabled, 'sent': self.egress_sent, 'failed': self.egress_failed, 'pending': pending_egress, 'last_event_at': self.last_egress_at, }, 'relays': { url: w.stats() for url, w in self.workers.items() }, } return res
[docs] def trouble(self) -> list[str]: out: list[str] = [] if not self.enabled: return out now = self.clock() if self.relays and not any(w.connected for w in self.workers.values()): out.append(f'all {len(self.relays)} bridge relays are disconnected') recent_refusals = self.refusals.within(self.TROUBLE_WINDOW, now, kind='ingress') if len(recent_refusals) > 20: out.append(f'{len(recent_refusals)} ingress events refused in the last 30 minutes') return out
[docs] def publish_cmd(self, args: Mapping[str, Any]) -> Any: ev = args.get('event') if not isinstance(ev, dict) or not isinstance(ev.get('id'), str): raise BridgeError('event must be a valid nostr event object') relays = args.get('relays') return self.publish(cast(NostrEvent, ev), target_relays=relays)
[docs] def sync_cmd(self, args: Mapping[str, Any]) -> Any: filt = args.get('filter') filters = [filt] if isinstance(filt, dict) else (filt if isinstance(filt, list) else self.ingress_filters) target_relay = args.get('relay') targets = [str(target_relay)] if target_relay else None return self.sync_query(filters, target_relays=targets)
[docs] def reconcile_cmd(self, args: Mapping[str, Any]) -> Any: url = args.get('relay') or (self.relays[0] if self.relays else None) if not url: raise BridgeError('no target relay specified for reconcile') filter_spec = args.get('filter') since = args.get('since') until = args.get('until') limit = args.get('limit') or 500 return self.reconcile_with_relay(str(url), filter_spec=filter_spec, since=since, until=until, limit=int(limit))
[docs] def add_relay_cmd(self, args: Mapping[str, Any]) -> Mapping[str, Any]: url = args.get('url') if not isinstance(url, str) or not url.startswith(('ws://', 'wss://')): raise BridgeError('url must be a ws:// or wss:// URL') if url not in self.relays: self.relays.append(url) worker = self._add_worker(url) return {'added': url, 'connected': worker.connected}
[docs] def remove_relay_cmd(self, args: Mapping[str, Any]) -> Mapping[str, Any]: url = args.get('url') if not isinstance(url, str): raise BridgeError('url must be a string') if url in self.relays: self.relays.remove(url) self._remove_worker(url) return {'removed': url}
[docs] def cursor_cmd(self) -> Any: if hasattr(self.store, 'all_bridge_cursors'): return self.store.all_bridge_cursors() return []