Source code for fleetmesh_node.protocols.nostr.package

"""fleetmesh-protocol-nostr: Decoupled Nostr & Blossom protocol package.

Conforms to ProtocolPackage (fleetmesh_core.wire.interfaces.ProtocolPackage).
Wraps RelayServer and BlossomServer, allowing them to be mounted onto
ProtocolHostRouter or operated with zero listening overhead when disabled.
"""
from __future__ import annotations

from fleetmesh_core.wire import spelling  # noqa: E402

from typing import Any, Callable, Mapping, Optional

from fleetmesh_core.wire.interfaces import (
    ProtocolHealth,
    ProtocolHostRouter,
    ProtocolIdentityAdapter,
)
from . import relayserver


[docs]class NostrIdentityAdapter: """Identity and assertion adapter for Nostr (secp256k1 / BIP-340)."""
[docs] def __init__(self, keystore: Any) -> None: self.ks = keystore
[docs] def resolve_id(self, uri: str) -> Optional[str]: # Handle npub1... or hex if uri.startswith('npub1'): try: from fleetmesh_core.crypto import bech32 raw = bech32.bech32_decode('npub', uri) if raw is not None: return raw.hex() except Exception: pass elif spelling.is_hex(uri, 64, upper=True): return uri.lower() return None
[docs] def sign_assertion(self, payload: bytes) -> bytes: import hashlib from fleetmesh_core.crypto import crypto msg32 = hashlib.sha256(payload).digest() if len(payload) != 32 else payload sk = getattr(self.ks, 'node_sk', None) sk_hex = sk.hex() if isinstance(sk, (bytes, bytearray)) else str(sk or '') sig = crypto.schnorr_sign(msg32, sk_hex) return bytes.fromhex(sig)
[docs] def verify_assertion(self, payload: bytes, signature: bytes, pubkey: str) -> bool: import hashlib from fleetmesh_core.crypto import crypto msg32 = hashlib.sha256(payload).digest() if len(payload) != 32 else payload try: return crypto.schnorr_verify(msg32, pubkey, signature.hex()) except Exception: return False
[docs]class NostrProtocolPackage: """The Nostr & Blossom protocol suite for Fleetmesh.""" name: str = 'nostr' version: str = '1.0.0' standards: tuple[str, ...] = ( 'NIP-01', 'NIP-11', 'NIP-40', 'NIP-42', 'NIP-44', 'NIP-59', 'NIP-77', 'BUD-01', 'BUD-02', 'BUD-04', )
[docs] def __init__( self, backend: Optional[Any] = None, blob_store: Optional[Any] = None, grants: Optional[Any] = None, node: Optional[Any] = None, clock: Optional[Callable[[], int]] = None, name: str = 'meshnode', pubkey: Optional[str] = None, ) -> None: self.backend = backend self.blob_store = blob_store self.grants = grants self.node = node self.clock = clock self.node_name = name self.pubkey = pubkey self.config: Mapping[str, Any] = {} self.relay_server: Optional[relayserver.RelayServer] = None self._host: Optional[ProtocolHostRouter] = None self._enabled: bool = True
[docs] def configure(self, config: Mapping[str, Any]) -> None: self.config = dict(config) self._enabled = self.config.get('enabled', True)
[docs] def identity_adapter(self, keystore: Any) -> Optional[ProtocolIdentityAdapter]: if keystore is None: return None return NostrIdentityAdapter(keystore)
[docs] def mount_ingress(self, host: ProtocolHostRouter) -> None: if not self._enabled: return self._host = host if self.relay_server is None: self.relay_server = relayserver.RelayServer( backend=self.backend, blob_store=self.blob_store, grants=self.grants, node=self.node, clock=self.clock, name=self.node_name, pubkey=self.pubkey, future_seconds=self.config.get('future_seconds', 900), require_auth=self.config.get('require_auth', False), host_router=host, ) self.relay_server.mount_ingress(host, owner='nostr')
[docs] def transport_rung(self, context: Any) -> Optional[Any]: # Outbound RelayRung for TransportRouter if not self._enabled: return None from fleetmesh_node.transport.relay_rung import RelayRung from fleetmesh_node.transport.rung import RelayRungAdapter if context is not None and hasattr(context, 'nostr'): return RelayRungAdapter(context) if context is not None and hasattr(context, 'ks') and hasattr(context, 'peers'): return RelayRung( keystore=context.ks, peers=context.peers, relay_urls=self.config.get('relays', ()), clock=context.clock, ) return None
[docs] def compartments(self) -> tuple[type[Any], ...]: # Background compartments associated with Nostr return ()
[docs] def start(self) -> None: if not self._enabled: return if self.relay_server is not None: self.relay_server.start()
[docs] def stop(self) -> None: if self.relay_server is not None: self.relay_server.stop()
[docs] def health(self) -> ProtocolHealth: if not self._enabled: return ProtocolHealth( healthy=True, status="disabled", connections_active=0, messages_in=0, messages_out=0, errors=(), ) if self.relay_server is not None: return ProtocolHealth( healthy=True, status="serving", connections_active=len(getattr(self.relay_server, '_conns', {})), messages_in=self.relay_server.accepted, messages_out=0, errors=(), ) return ProtocolHealth( healthy=True, status="configured", connections_active=0, messages_in=0, messages_out=0, errors=(), )
[docs] def descriptor_capabilities(self) -> tuple[tuple[str, str], ...]: if not self._enabled: return () return (('c', 'relay'), ('c', 'negentropy'))