fleetmesh-node 0.2.0__py3-none-any.whl

node/transport/relay_rung/types.py

@@ -0,0 +1,58 @@
+"""The records the relay rung keeps, named so a reader of ledger.py or
+inbound.py knows what a row holds without opening the code that filled it.
+"""
+from __future__ import annotations
+
+from typing import Any, Literal, Mapping, Optional, TypedDict
+
+
+class AwaitingEntry(TypedDict):
+    """A stored message sent with please_ack and not yet answered."""
+    peer: str
+    type: str
+    at: int
+    relays: list[str]            # relays that took the wrap
+    heard_at: Optional[int]      # when the peer was first heard after the send, once it was
+
+
+Verdict = Literal['unacknowledged', 'expired']
+
+
+class AckVerdict(AwaitingEntry):
+    """An AwaitingEntry the sweep has judged."""
+    mid: str
+    verdict: Verdict
+    at_verdict: int
+
+
+class Fragment(TypedDict):
+    """One piece of an envelope too large for a single wrap."""
+    frag: str                    # fragment id, shared by the pieces
+    i: int
+    n: int
+    data: str
+
+
+class Partial(TypedDict):
+    """The pieces of one fragmented envelope collected so far."""
+    n: int
+    parts: dict[int, str]
+    at: float
+
+
+__all__ = ['AwaitingEntry', 'AckVerdict', 'Fragment', 'Partial', 'Verdict']
+
+
+# The DIDComm plaintext as the rung addresses it: what the caller gave, plus
+# the sender, recipient and time the rung fills in and the ack it asks for.
+# Functional form because 'from' is a keyword.
+OutboundMessage = TypedDict('OutboundMessage', {
+    'id': str,
+    'type': str,
+    'body': Mapping[str, Any],     # each protocol types its own body
+    'from': str,
+    'to': list[str],
+    'created_time': int,
+    'please_ack': list[str],
+    'thid': str,
+}, total=False)

node/transport/relay_rung/wire.py

@@ -0,0 +1,63 @@
+"""Wrap policy for the relay rung: what a message becomes on a relay.
+
+Pure functions. The kind (live 21059 or stored 1059), the fragmenting of an
+envelope that does not fit one wrap, and the NIP-42 auth event are decided
+here, so the rest of the rung moves bytes and never asks what a wrap is.
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Mapping
+
+from fleetmesh_core.crypto import giftwrap
+from fleetmesh_core.storage import store
+from fleetmesh_core.wire.interfaces import NostrEvent, NostrFilter
+
+from .. import const
+from ..const import TransportError
+from .types import Fragment
+
+
+def wrap_kind(stored: bool) -> int:
+    """Stored wraps are kept by relays for an offline peer; live wraps are
+    gone if nobody is listening, which is the point."""
+    return giftwrap.WRAP_STORED if stored else const.WRAP_KIND
+
+
+def make_wrap(payload: Any, sender_sk: str, to_pubkey: str, now: int, stored: bool) -> NostrEvent:
+    """One payload (a JWE or a fragment of one) as a wrap addressed to the peer."""
+    return giftwrap.wrap(payload, sender_sk, to_pubkey, now, kind=wrap_kind(stored))
+
+
+def fragments(jwe: Mapping[str, Any]) -> list[Any]:
+    """The JWE itself when it fits a wrap, else its pieces under one fragment id."""
+    text = json.dumps(jwe, separators=(',', ':'), sort_keys=True)
+    if len(text) <= const.FRAGMENT_BYTES:
+        return [jwe]
+    if len(text) > const.ENVELOPE_MAX:
+        raise TransportError('an envelope of %d bytes needs %d fragments and the receiver refuses '
+                             'more than %d; send less in one message'
+                             % (len(text), -(-len(text) // const.FRAGMENT_BYTES), const.MAX_FRAGMENTS))
+    fid = os.urandom(8).hex()
+    parts = [text[i:i + const.FRAGMENT_BYTES] for i in range(0, len(text), const.FRAGMENT_BYTES)]
+    out: list[Fragment] = [Fragment(frag=fid, i=i, n=len(parts), data=part) for i, part in enumerate(parts)]
+    return list(out)
+
+
+def auth_event(node_sk: str, now: int, relay_url: str, challenge: str) -> NostrEvent:
+    """NIP-42: a kind 22242 event signed by the node key answering a relay's challenge."""
+    tags = [['relay', relay_url], ['challenge', challenge]]
+    return store.make_signed_event(node_sk, now, 22242, tags, '')
+
+
+def subscription(node_pk: str, since: int) -> NostrFilter:
+    """The one filter this node holds on every relay: wraps of either kind
+    addressed to its node key."""
+    return {'kinds': [giftwrap.WRAP_LIVE, giftwrap.WRAP_STORED], '#p': [node_pk], 'since': since}
+
+
+def since_floor(now: int) -> int:
+    """How far back a subscription must reach: a wrap's created_at may be
+    skewed up to two days into the past."""
+    return now - giftwrap.TWO_DAYS