fleetmesh-node 0.2.0__py3-none-any.whl

node/planes/services/video/barter.py

@@ -0,0 +1,407 @@
+"""Automated Cross-Compartment Barter Proof Bridge (node.planes.services.video.barter).
+
+Wires verified work proofs from MeshNode's core service and storage compartments
+into `TransitLedgerStore.credit_barter`:
+- `blob_replication` (`blob_replicated` channel & `ReplicaStore`): 1 byte shored = 1 byte transit credit.
+- `compute` (`job_executed` channel & `receipts_held` store): 1 compute fuel unit = 1 KB transit credit.
+- `dvm` (`job_succeeded` channel & `recent_jobs` ring): 1 NIP-90 DVM job unit = 1 MB transit credit.
+- `mediation` (`messages_drained` / `message_forwarded` channels): 1 mediated message = 4 KB transit credit.
+"""
+from __future__ import annotations
+
+import threading
+import time
+from typing import Any, Callable, Mapping, Optional, TypedDict
+
+from .ledger import BarterCreditRow, TransitLedgerStore
+
+
+class BarterHookResult(TypedDict):
+    credited: bool
+    utility_kind: str
+    debtor: str
+    units: int
+    equivalent_transit_bytes: int
+    proof_ref: str
+    unsettled_bytes_after: int
+    degraded_audio_only_after: bool
+
+
+def normalize_peer_pubkey(raw: str) -> str:
+    """Extract a normalized lowercase peer identifier / pubkey from `peer:<pk>`,
+    `did:nostr:<pk>`, `did:key:<id>`, or a raw hex pubkey.
+    """
+    val = (raw or '').strip()
+    if val.startswith('peer:'):
+        val = val[5:].strip()
+    elif val.startswith('did:nostr:'):
+        val = val[10:].strip()
+    return val.lower()
+
+
+class BarterSettlementBridge:
+    """Listens to `NodeEventBus` channels and reconciles compartment stores to
+    automatically credit bartered network utility against unsettled video transit debt.
+    """
+
+    def __init__(
+        self,
+        ledger: TransitLedgerStore,
+        creditor_pk: str = '',
+        blob_store: Optional[Any] = None,
+        rhio_store: Optional[Any] = None,
+        on_settled: Optional[Callable[[BarterHookResult], None]] = None,
+        clock: Optional[Callable[[], int]] = None,
+    ) -> None:
+        # An injected clock, defaulting to wall time, so a suite can move time
+        # at the boundaries this code decides on. The compartment passes its own.
+        self._clock: Callable[[], int] = clock or (lambda: int(time.time()))
+        # What reconciliation could not credit, by utility kind, with the last
+        # reason for each. These were `except Exception: pass` around whole
+        # loops: a peer that had earned a credit simply never got it, and
+        # nothing anywhere said so.
+        self.skipped: dict[str, int] = {}
+        self.last_skip: dict[str, str] = {}
+        self.ledger = ledger
+        self.creditor_pk = (creditor_pk or ('b' * 64)).lower()
+        self.blob_store = blob_store
+        self.rhio_store = rhio_store
+        self.on_settled = on_settled
+        self._lock = threading.RLock()
+        self._seen_proofs: set[str] = set()
+        self._attached_bus: Optional[Any] = None
+
+    def _lookup_blob_size(self, sha256_hex: str) -> int:
+        clean = (sha256_hex or '').strip().lower()
+        if not clean:
+            return 0
+        if self.rhio_store is not None:
+            if hasattr(self.rhio_store, 'get_blob_meta'):
+                try:
+                    meta = self.rhio_store.get_blob_meta(clean)
+                    if meta and int(meta.get('size', 0)) > 0:
+                        return int(meta['size'])
+                except Exception as e:
+                    self._skipped('blob_lookup', e)
+            if hasattr(self.rhio_store, 'get_blob'):
+                try:
+                    blob = self.rhio_store.get_blob(clean)
+                    if blob is not None:
+                        return len(blob)
+                except Exception as e:
+                    self._skipped('blob_lookup', e)
+        if self.blob_store is not None:
+            if hasattr(self.blob_store, 'get'):
+                try:
+                    blob = self.blob_store.get(clean)
+                    if blob is not None:
+                        return len(blob)
+                except Exception as e:
+                    self._skipped('blob_lookup', e)
+        return 64 * 1024  # fallback 64 KB default when blob metadata is remote-only
+
+    def _apply_credit(
+        self,
+        *,
+        debtor: str,
+        utility_kind: Any,
+        units: int,
+        proof_ref: str,
+        now: Optional[int] = None,
+    ) -> Optional[BarterHookResult]:
+        norm_debtor = normalize_peer_pubkey(debtor)
+        if not norm_debtor or units <= 0 or not proof_ref:
+            return None
+        with self._lock:
+            if proof_ref in self._seen_proofs:
+                return None
+            self._seen_proofs.add(proof_ref)
+
+        row: BarterCreditRow = self.ledger.credit_barter(
+            debtor=norm_debtor,
+            creditor=self.creditor_pk,
+            utility_kind=utility_kind,
+            units=int(units),
+            proof_ref=proof_ref,
+            now=now,
+        )
+        summary = self.ledger.debt_summary(norm_debtor)
+        res: BarterHookResult = {
+            'credited': True,
+            'utility_kind': str(row['utility_kind']),
+            'debtor': norm_debtor,
+            'units': int(row['units']),
+            'equivalent_transit_bytes': int(row['equivalent_transit_bytes']),
+            'proof_ref': proof_ref,
+            'unsettled_bytes_after': int(summary['unsettled_bytes']),
+            'degraded_audio_only_after': bool(summary['degraded_audio_only']),
+        }
+        if self.on_settled is not None:
+            try:
+                self.on_settled(res)
+            except Exception as e:
+                self._skipped('on_settled', e)
+        return res
+
+    # ---- Explicit Proof Handlers --------------------------------------------
+
+    def on_blob_shored(
+        self,
+        peer: str,
+        sha256: str,
+        size_bytes: Optional[int] = None,
+        now: Optional[int] = None,
+    ) -> Optional[BarterHookResult]:
+        """Credit a peer for mirroring/shoring a content-addressed blob replica."""
+        norm_peer = normalize_peer_pubkey(peer)
+        clean_sha = (sha256 or '').strip().lower()
+        if not norm_peer or not clean_sha:
+            return None
+        byte_units = int(size_bytes) if (size_bytes is not None and size_bytes > 0) else self._lookup_blob_size(clean_sha)
+        proof_ref = f'blob_shoring:{norm_peer}:{clean_sha}'
+        return self._apply_credit(
+            debtor=norm_peer,
+            utility_kind='blob_shoring',
+            units=byte_units,
+            proof_ref=proof_ref,
+            now=now,
+        )
+
+    def on_verified_compute(
+        self,
+        peer: str,
+        job_id: str,
+        fuel_units: int = 1,
+        now: Optional[int] = None,
+    ) -> Optional[BarterHookResult]:
+        """Credit a peer for completing a verified compute execution job."""
+        norm_peer = normalize_peer_pubkey(peer)
+        clean_job = (job_id or '').strip()
+        if not norm_peer or not clean_job:
+            return None
+        units = max(1, int(fuel_units))
+        proof_ref = f'verified_compute:{norm_peer}:{clean_job}'
+        return self._apply_credit(
+            debtor=norm_peer,
+            utility_kind='verified_compute',
+            units=units,
+            proof_ref=proof_ref,
+            now=now,
+        )
+
+    def on_dvm_job_completed(
+        self,
+        peer: str,
+        job_id: str,
+        units: int = 1,
+        fuel: int = 0,
+        now: Optional[int] = None,
+    ) -> Optional[BarterHookResult]:
+        """Credit a peer for completing a NIP-90 DVM job."""
+        norm_peer = normalize_peer_pubkey(peer)
+        clean_job = (job_id or '').strip()
+        if not norm_peer or not clean_job:
+            return None
+        effective_units = max(1, int(units) + (int(fuel) // 1000))
+        proof_ref = f'dvm:{norm_peer}:{clean_job}'
+        return self._apply_credit(
+            debtor=norm_peer,
+            utility_kind='dvm',
+            units=effective_units,
+            proof_ref=proof_ref,
+            now=now,
+        )
+
+    def on_mediation_drained(
+        self,
+        peer: str,
+        count: int = 1,
+        batch_id: str = '',
+        now: Optional[int] = None,
+    ) -> Optional[BarterHookResult]:
+        """Credit a peer for DIDComm store-and-forward mediation work."""
+        norm_peer = normalize_peer_pubkey(peer)
+        if not norm_peer or count <= 0:
+            return None
+        now_val = self._clock() if now is None else int(now)
+        ref_suffix = batch_id or str(now_val)
+        proof_ref = f'mediation:{norm_peer}:{ref_suffix}'
+        return self._apply_credit(
+            debtor=norm_peer,
+            utility_kind='mediation',
+            units=int(count),
+            proof_ref=proof_ref,
+            now=now_val,
+        )
+
+    # ---- NodeEventBus Subscription & Compartment Reconciliation -------------
+
+    def attach_event_bus(self, bus: Any) -> None:
+        """Subscribe to `NodeEventBus` topics emitted by `Replication`, `Compute`,
+        `DVMGateway`, and `Mediation` so work events settle transit debt in real time.
+        """
+        if bus is None or not hasattr(bus, 'subscribe') or self._attached_bus is bus:
+            return
+        self._attached_bus = bus
+
+        def _on_blob_replicated(**kw: Any) -> None:
+            server = str(kw.get('server') or kw.get('peer') or '')
+            sha256 = str(kw.get('sha256') or '')
+            size = kw.get('size')
+            size_int = int(size) if isinstance(size, int) and size > 0 else None
+            if server and sha256:
+                self.on_blob_shored(peer=server, sha256=sha256, size_bytes=size_int)
+
+        def _on_job_executed(**kw: Any) -> None:
+            peer = str(kw.get('provider') or kw.get('worker') or kw.get('buyer') or kw.get('peer') or '')
+            job_id = str(kw.get('job_id') or kw.get('id') or '')
+            fuel = int(kw.get('fuel') or kw.get('units') or 1)
+            if peer and job_id:
+                self.on_verified_compute(peer=peer, job_id=job_id, fuel_units=max(1, fuel))
+
+        def _on_dvm_succeeded(**kw: Any) -> None:
+            peer = str(kw.get('provider') or kw.get('worker') or kw.get('peer') or kw.get('pubkey') or '')
+            job_id = str(kw.get('job_id') or '')
+            fuel = int(kw.get('fuel') or 0)
+            if peer and job_id:
+                self.on_dvm_job_completed(peer=peer, job_id=job_id, units=1, fuel=fuel)
+
+        def _on_messages_drained(**kw: Any) -> None:
+            peer = str(kw.get('mediator') or kw.get('peer') or kw.get('leaf') or '')
+            count = int(kw.get('count') or 1)
+            batch_id = str(kw.get('batch_id') or f'drain-{count}-{self._clock()}')
+            if peer and count > 0:
+                self.on_mediation_drained(peer=peer, count=count, batch_id=batch_id)
+
+        bus.subscribe('blob_replicated', _on_blob_replicated)
+        bus.subscribe('job_executed', _on_job_executed)
+        bus.subscribe('job_succeeded', _on_dvm_succeeded)
+        bus.subscribe('messages_drained', _on_messages_drained)
+
+    def _skipped(self, kind: str, exc: BaseException) -> None:
+        """Record a credit this pass could not apply, and why."""
+        self.skipped[kind] = self.skipped.get(kind, 0) + 1
+        self.last_skip[kind] = '%s: %s' % (type(exc).__name__, exc)
+
+    def reconcile_compartments(
+        self,
+        *,
+        blob_replication: Any = None,
+        compute: Any = None,
+        dvm: Any = None,
+        now: Optional[int] = None,
+    ) -> list[BarterHookResult]:
+        """Inspect active MeshNode compartments (`blob_replication`, `compute`, `dvm`)
+        and credit any uncredited work proofs for known peers.
+        """
+        results: list[BarterHookResult] = []
+
+        # 1. Reconcile held blob replicas in Replication.db
+        if blob_replication is not None and hasattr(blob_replication, 'db'):
+            try:
+                wants = blob_replication.db.wants()
+            except Exception as e:
+                wants = []
+                self._skipped('blob_shoring', e)
+            for sha256_hex, _copies in wants:
+                # Per item, not per pass: this whole loop used to sit inside
+                # one `except Exception: pass`, so a single malformed replica
+                # row abandoned every credit after it - silently, and the
+                # peers that had earned them were simply never paid.
+                try:
+                    for rep in blob_replication.db.replicas(sha256_hex):
+                        if rep.get('state') == 'held':
+                            srv = str(rep.get('server') or '')
+                            if srv.startswith('peer:') or len(srv) == 64:
+                                r = self.on_blob_shored(peer=srv, sha256=sha256_hex, now=now)
+                                if r is not None:
+                                    results.append(r)
+                except Exception as e:
+                    self._skipped('blob_shoring', e)
+
+        # 2. Reconcile signed compute receipts in Compute.receipts_held
+        if compute is not None and hasattr(compute, 'receipts_held'):
+            for rec in list(compute.receipts_held):
+                try:
+                    if isinstance(rec, Mapping):
+                        raw_ev = rec.get('receipt')
+                        ev_doc: Mapping[str, Any] = raw_ev if isinstance(raw_ev, Mapping) else {}
+                        raw_payload = rec.get('payload')
+                        payload_doc: Mapping[str, Any] = raw_payload if isinstance(raw_payload, Mapping) else {}
+                        peer = str(
+                            rec.get('pubkey')
+                            or rec.get('provider')
+                            or rec.get('buyer')
+                            or ev_doc.get('pubkey')
+                            or ''
+                        )
+                        if not peer and isinstance(ev_doc.get('tags'), list):
+                            for tag in ev_doc['tags']:
+                                if isinstance(tag, (list, tuple)) and len(tag) >= 2 and tag[0] == 'p':
+                                    peer = str(tag[1])
+                                    break
+                        job_id = str(
+                            rec.get('id')
+                            or rec.get('job_id')
+                            or payload_doc.get('ask')
+                            or ev_doc.get('id')
+                            or ''
+                        )
+                        fuel = int(
+                            rec.get('fuel')
+                            or rec.get('units')
+                            or payload_doc.get('fuel_used')
+                            or payload_doc.get('fuel')
+                            or 1
+                        )
+                        if peer and job_id:
+                            r = self.on_verified_compute(
+                                peer=peer, job_id=job_id, fuel_units=max(1, fuel), now=now
+                            )
+                            if r is not None:
+                                results.append(r)
+                except Exception as e:
+                    self._skipped('verified_compute', e)
+
+        # 3. Reconcile DVM job completions in DVMGateway.recent_jobs
+        if dvm is not None and hasattr(dvm, 'recent_jobs'):
+            for item in list(dvm.recent_jobs):
+                try:
+                    if isinstance(item, tuple) and len(item) >= 3:
+                        first_str = str(item[0])
+                        if first_str in ('ok', 'success', 'succeeded', 'completed'):
+                            status = first_str
+                            job_id = str(item[1])
+                            peer = str(item[2])
+                            fuel = int(item[3]) if len(item) >= 4 and isinstance(item[3], int) else 0
+                        else:
+                            job_id = first_str
+                            status = str(item[1])
+                            if len(item) >= 4:
+                                if isinstance(item[2], int):
+                                    fuel = int(item[2])
+                                    peer = str(item[3])
+                                else:
+                                    peer = str(item[2])
+                                    fuel = int(item[3]) if isinstance(item[3], int) else 0
+                            elif isinstance(item[2], int):
+                                fuel = int(item[2])
+                                peer = ''
+                            else:
+                                fuel = 0
+                                peer = str(item[2])
+                        if status in ('ok', 'success', 'succeeded', 'completed') and peer and job_id:
+                            r = self.on_dvm_job_completed(peer=peer, job_id=job_id, units=1, fuel=fuel, now=now)
+                            if r is not None:
+                                results.append(r)
+                except Exception as e:
+                    self._skipped('dvm', e)
+
+        return results
+
+
+__all__ = [
+    'BarterHookResult',
+    'normalize_peer_pubkey',
+    'BarterSettlementBridge',
+]

node/planes/services/video/cli.py

@@ -0,0 +1,158 @@
+"""CLI commands for video streaming and transit settlement (Phase 5).
+
+Provides the `stream` CLI verb (via plugin CLI hook or standalone provider)
+supporting:
+- `stream start`: create a new stream and genesis manifest in P2PandaLogStore
+- `stream ingest`: package a segment into RhioBlobSync + P2PandaLogStore
+- `stream status`: inspect active streams, manifest heads, and transit IOU debt
+- `stream settle`: credit bartered network utility against unsettled transit debt
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from typing import Optional, Sequence, cast
+
+from .ledger import TransitLedgerStore, UtilityKind
+from .packager import VideoStreamPackager
+
+
+def _open_stores(node_dir: str) -> tuple[VideoStreamPackager, TransitLedgerStore]:
+    os.makedirs(node_dir, exist_ok=True)
+    from node.protocols.p2panda.store import P2PandaLogStore
+    from node.protocols.rhio.store import RhioBlobSync
+
+    p2p_db = os.path.join(node_dir, 'p2panda_v1.db')
+    rhio_db = os.path.join(node_dir, 'rhio_v1.db')
+    rhio_cas = os.path.join(node_dir, 'rhio_cas')
+    ledger_db = os.path.join(node_dir, 'video_transit_v1.db')
+
+    p2p_store = P2PandaLogStore(p2p_db)
+    rhio_store = RhioBlobSync(db_path=rhio_db, cas_dir=rhio_cas)
+    packager = VideoStreamPackager(p2panda_store=p2p_store, rhio_store=rhio_store)
+    ledger = TransitLedgerStore(ledger_db)
+    return packager, ledger
+
+
+def cmd_stream(args: argparse.Namespace) -> int:
+    node_dir = str(getattr(args, 'dir', '.'))
+    action = str(getattr(args, 'stream_action', 'status'))
+    packager, ledger = _open_stores(node_dir)
+    try:
+        if action == 'start':
+            broadcaster = str(getattr(args, 'broadcaster', '') or ('a' * 64))
+            genesis, op = packager.create_stream(
+                stream_id=str(args.stream_id),
+                broadcaster=broadcaster,
+                title=str(getattr(args, 'title', 'Live Stream')),
+                price_msat_per_mb=int(getattr(args, 'price_msat_per_mb', 0)),
+                account_fee_msat=int(getattr(args, 'account_fee_msat', 0)),
+            )
+            out = {
+                'ok': True,
+                'action': 'start',
+                'stream_id': genesis.stream_id,
+                'broadcaster': genesis.broadcaster,
+                'genesis_op_id': op.id,
+                'seq_num': op.seq_num,
+            }
+            print(json.dumps(out, indent=2))
+            return 0
+
+        elif action == 'status':
+            debtor = getattr(args, 'debtor', None)
+            if debtor:
+                summary = ledger.debt_summary(str(debtor))
+                credits = ledger.list_barter_credits(str(debtor))
+                print(json.dumps({'debt': summary, 'barter_credits': credits}, indent=2))
+            else:
+                print(json.dumps({
+                    'p2panda_operations': packager.p2panda_store.count_operations(),
+                    'rhio_blobs': packager.rhio_store.count_blobs(),
+                }, indent=2))
+            return 0
+
+        elif action == 'settle':
+            debtor = str(args.debtor)
+            creditor = str(getattr(args, 'creditor', '') or ('b' * 64))
+            utility = cast(UtilityKind, str(args.utility))
+            units = int(args.units)
+            proof_ref = str(args.proof)
+            row = ledger.credit_barter(
+                debtor=debtor,
+                creditor=creditor,
+                utility_kind=utility,
+                units=units,
+                proof_ref=proof_ref,
+            )
+            summary = ledger.debt_summary(debtor)
+            print(json.dumps({'credited': row, 'debt_summary': summary}, indent=2))
+            return 0
+
+        return 1
+    finally:
+        ledger.close()
+        packager.p2panda_store.close()
+        packager.rhio_store.close()
+
+
+def register_stream_cli(subparsers: argparse._SubParsersAction) -> None:
+    """Register the `stream` command on an argparse subparsers action."""
+    p = subparsers.add_parser(
+        'stream',
+        help='manage live video streams, transit handovers, and bartered IOU settlement',
+    )
+    p.add_argument('dir', metavar='DIR', help='node directory')
+    p.add_argument(
+        'stream_action',
+        choices=('start', 'status', 'settle'),
+        help='stream operation to execute',
+    )
+    p.add_argument('--stream-id', default='live-default', help='stream identifier')
+    p.add_argument('--broadcaster', default='', help='64-char hex broadcaster pubkey')
+    p.add_argument('--title', default='Live Stream', help='human-readable stream title')
+    p.add_argument('--price-msat-per-mb', type=int, default=0, help='operator egress price in msat/MB')
+    p.add_argument('--account-fee-msat', type=int, default=0, help='creator fee in msat per segment')
+    p.add_argument('--debtor', default='', help='debtor pubkey for status or barter settlement')
+    p.add_argument('--creditor', default='', help='creditor operator pubkey for barter settlement')
+    p.add_argument(
+        '--utility',
+        choices=('blob_shoring', 'verified_compute', 'dvm', 'mediation'),
+        default='blob_shoring',
+        help='bartered network utility type',
+    )
+    p.add_argument('--units', type=int, default=0, help='utility units to credit')
+    p.add_argument('--proof', default='', help='cryptographic proof or receipt reference')
+    p.set_defaults(fn=cmd_stream)
+
+
+class VideoStreamCommandProvider:
+    """CommandProvider for video streaming CLI commands."""
+
+    cli = (('stream', register_stream_cli),)
+
+    @classmethod
+    def register(cls, subparsers: argparse._SubParsersAction) -> None:
+        register_stream_cli(subparsers)
+
+
+def run_stream_cli(argv: Optional[Sequence[str]] = None) -> int:
+    """Standalone CLI entrypoint for invoking `stream` commands in tests or scripts."""
+    parser = argparse.ArgumentParser(prog='meshnode')
+    sub = parser.add_subparsers(dest='cmd')
+    register_stream_cli(sub)
+    ns = parser.parse_args(list(argv) if argv is not None else None)
+    fn = getattr(ns, 'fn', None)
+    if fn is None:
+        parser.print_help()
+        return 1
+    return int(fn(ns))
+
+
+__all__ = [
+    'cmd_stream',
+    'register_stream_cli',
+    'VideoStreamCommandProvider',
+    'run_stream_cli',
+]