"""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 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'))