fleetmesh-node 0.2.0__py3-none-any.whl

node/planes/services/compute_wire/session.py

@@ -0,0 +1,572 @@
+"""ComputeSession: the per-job state machine driving quote/accept/sealed/settled/refute.
+
+Separate because it is the largest piece of compute/wire and the only one with per-job mutable state.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import time
+from typing import Any, Callable, Collection, Mapping, Optional, Sequence, Union, cast
+
+from fleetmesh_core.accounting import market
+from fleetmesh_core.crypto import crypto
+from fleetmesh_core.wire.interfaces import NostrEvent
+from fleetmesh_core.wire.wire_types import (
+    ComputeAcceptBody, ComputeCancelBody, ComputeProgressBody, ComputeQuoteBody,
+    ComputeRefuteBody, ComputeSealedBody, ComputeSettledBody, ComputeStreamBody,
+    Message, ProgressState, ProofFailure, SealedVerify,
+)
+from node.planes.services.compute import executors as compute_executors, jobs as compute_jobs
+from fleetmesh_core.identity.did import did_nostr as did_of
+from .messages import (
+    ComputeWireError,
+    make_quote,
+    make_accept,
+    make_sealed,
+    make_settled,
+    make_refute,
+    make_stream_chunk,
+    make_progress,
+    make_cancel,
+)
+from .sealing import seal_result, open_sealed, encrypt_stream_frame, decrypt_stream_frame
+from .verify import evaluate_job_evidence
+
+# -------------------------------------------------------------------------
+# Bilateral Compute State Machine (Sessions)
+# -------------------------------------------------------------------------
+class ComputeSession:
+    """Manages the bilateral state machine for a compute job."""
+
+    def __init__(
+        self,
+        role: str,  # 'buyer' or 'seller'
+        my_sk: str,
+        peer_pk: str,
+        ask_id: str,
+        job_payload: Optional[Mapping[str, Any]] = None,
+        encrypted: bool = False,
+    ) -> None:
+        self.role = role
+        self.my_sk = my_sk
+        self.my_pk = crypto.pubkey(my_sk)
+        self.peer_pk = peer_pk
+        self.ask_id = ask_id
+        self.thid = ask_id
+        self.job_payload = dict(job_payload) if job_payload else None
+        self.state = 'INITIAL'
+        self.encrypted = encrypted
+        self._session_key: Optional[bytes] = None
+
+        # Negotiation parameters
+        # ours as built, or the peer's as received: either way read, not edited
+        self.quote_msg: Optional[Mapping[str, Any]] = None
+        self.accept_msg: Optional[Mapping[str, Any]] = None
+        self.sealed_msg: Optional[Mapping[str, Any]] = None
+        self.settled_msg: Optional[Mapping[str, Any]] = None
+        self.refute_msg: Optional[Message[ComputeRefuteBody]] = None
+        self.receipt_event: Optional[NostrEvent] = None
+
+        # Cryptographic keys
+        self.payment_preimage: Optional[str] = None
+        self.payment_hash: Optional[str] = None
+        self.raw_output: Optional[bytes] = None
+        self.result_hash: Optional[str] = None
+        self.fuel_used: int = 0
+        self._engine: str = 'wasmtime'
+        self._wasi_profile_digest: str = '0' * 64
+
+        # Streaming and progress tracking (compute/1.1)
+        self.stream_chunks: list[Mapping[str, Any]] = []
+        self.stream_buffer: list[str] = []
+        self.progress_history: list[Mapping[str, Any]] = []
+        self.cancel_msg: Optional[Message[ComputeCancelBody]] = None
+        self._cancellation_hooks: list[Callable[[str], None]] = []
+        self.last_seq: int = -1
+
+    def session_key(self) -> bytes:
+        """Derive the 32-byte ChaCha20Poly1305 symmetric session key via HKDF over ECDH."""
+        if self._session_key is None:
+            shared_x = crypto.ecdh_x(self.my_sk, self.peer_pk)
+            self._session_key = crypto.hkdf(
+                bytes.fromhex(shared_x),
+                info=b'fleetmesh/compute/session-stream/1',
+                salt=b'fleetmesh/compute/1',
+                length=32,
+            )
+        return self._session_key
+
+    # Seller methods
+    def seller_quote(
+        self,
+        price_msat: int,
+        invoice: str,
+        payment_hash: Optional[str] = None,
+        preimage_hex: Optional[str] = None,
+        estimated_duration_s: int = 10,
+    ) -> Message[ComputeQuoteBody]:
+        if self.role != 'seller':
+            raise ComputeWireError('not a seller')
+        if preimage_hex is not None:
+            self.payment_preimage = preimage_hex
+            self.payment_hash = hashlib.sha256(bytes.fromhex(preimage_hex)).hexdigest()
+        elif payment_hash is not None:
+            self.payment_hash = payment_hash
+        else:
+            self.payment_preimage = os.urandom(32).hex()
+            self.payment_hash = hashlib.sha256(bytes.fromhex(self.payment_preimage)).hexdigest()
+
+        q = make_quote(
+            from_did=did_of(self.my_pk),
+            to_did=did_of(self.peer_pk),
+            ask_id=self.ask_id,
+            price_msat=price_msat,
+            invoice=invoice,
+            payment_hash=self.payment_hash,
+            thid=self.thid,
+            estimated_duration_s=estimated_duration_s,
+        )
+        self.quote_msg = q
+        self.state = 'QUOTED'
+        return q
+
+    def seller_receive_accept(
+        self,
+        accept_msg: Mapping[str, Any],
+        ask_event: Optional[NostrEvent] = None,
+        registry: Optional[compute_executors.ExecutorRegistry] = None,
+    ) -> Message[ComputeSealedBody]:
+        if self.role != 'seller':
+            raise ComputeWireError('not a seller')
+        self.accept_msg = dict(accept_msg)
+        body = accept_msg['body']
+        job = body['job']
+        self.job_payload = job
+
+        if ask_event and not market.commitment_holds(ask_event, job):
+            raise ComputeWireError('accept job payload does not match ask commitment')
+
+        # Execute the job
+        reg = registry or compute_executors.DEFAULT_REGISTRY
+        exec_res = compute_jobs.run_job(job, registry=reg)
+        self.raw_output = exec_res['raw_output']
+        self.result_hash = exec_res['result_hash']
+        self.fuel_used = exec_res['fuel_used']
+        self._engine = str(exec_res.get('engine') or job.get('executor') or 'wasmtime')
+        self._wasi_profile_digest = str(exec_res.get('wasi_profile_digest') or ('0' * 64))
+
+        # Seal the result under preimage
+        seal_data = seal_result(self.raw_output, preimage_hex=self.payment_preimage)
+        self.payment_preimage = seal_data['payment_preimage']
+        self.payment_hash = seal_data['payment_hash']
+
+        verify_meta: Optional[SealedVerify] = None
+        verify_decl = job.get('verify', {})
+        if verify_decl.get('mode') == 'proof':
+            verify_meta = {
+                'mode': 'proof',
+                'proof_system': 'zk-verify-groth16',
+                'proof': job.get('input', {}).get('proof', ''),
+            }
+
+        sealed = make_sealed(
+            from_did=did_of(self.my_pk),
+            to_did=did_of(self.peer_pk),
+            thid=self.thid,
+            ciphertext=seal_data['ciphertext'],
+            payment_hash=self.payment_hash,
+            result=self.result_hash,
+            fuel_used=self.fuel_used,
+            verify=verify_meta,
+        )
+        self.sealed_msg = sealed
+        self.state = 'SEALED'
+        return sealed
+
+    def seller_receive_settled(
+        self,
+        settled_msg: Mapping[str, Any],
+        blinding: Optional[str] = None,
+    ) -> NostrEvent:
+        if self.role != 'seller':
+            raise ComputeWireError('not a seller')
+        self.settled_msg = dict(settled_msg)
+        preimage = settled_msg['body']['payment_preimage']
+
+        # Verify preimage settles invoice
+        expected_hash = hashlib.sha256(bytes.fromhex(preimage)).hexdigest()
+        if expected_hash != self.payment_hash:
+            raise ComputeWireError('disclosed preimage does not hash to payment_hash')
+
+        # Issue Kind 30811 Job Receipt
+        if self.job_payload is None:
+            raise ComputeWireError('no job payload accepted; nothing to receipt')
+        job_payload = self.job_payload
+        blind = blinding or crypto.sha256(os.urandom(32))
+        receipt_payload = {
+            'ask': self.ask_id,
+            'module': job_payload.get('module', {}).get('sha256', '0' * 64),
+            'input': job_payload.get('input', {}).get('sha256', '0' * 64),
+            'result': self.result_hash,
+            'fuel_used': self.fuel_used,
+            'paid_msat': self.quote_msg.get('body', {}).get('price_msat', 0) if self.quote_msg else 0,
+            'payment_hash': self.payment_hash,
+            'executor': {
+                'engine': self._engine,
+                'wasi_profile_digest': self._wasi_profile_digest,
+            },
+            'verify': job_payload.get('verify', {'mode': 'none'}),
+            'blinding': blind,
+        }
+        rec_ev = compute_jobs.build_receipt(
+            seller_sk=self.my_sk,
+            buyer_pk=self.peer_pk,
+            receipt_payload=receipt_payload,
+            blinding=blind,
+        )
+        self.receipt_event = rec_ev
+        self.state = 'RECEIPT_ISSUED'
+        return rec_ev
+
+    # Buyer methods
+    def buyer_accept_quote(
+        self,
+        quote_msg: Mapping[str, Any],
+        job_payload: Mapping[str, Any],
+        input_key: Optional[str] = None,
+    ) -> Message[ComputeAcceptBody]:
+        if self.role != 'buyer':
+            raise ComputeWireError('not a buyer')
+        self.quote_msg = dict(quote_msg)
+        self.payment_hash = quote_msg['body']['payment_hash']
+        self.job_payload = dict(job_payload)
+
+        acc = make_accept(
+            from_did=did_of(self.my_pk),
+            to_did=did_of(self.peer_pk),
+            thid=self.thid,
+            payment_hash=self.payment_hash,
+            job_payload=self.job_payload,
+            input_key=input_key,
+        )
+        self.accept_msg = acc
+        self.state = 'ACCEPTED'
+        return acc
+
+    def buyer_receive_sealed(
+        self,
+        sealed_msg: Mapping[str, Any],
+        preimage_hex: str,
+    ) -> Message[ComputeSettledBody]:
+        if self.role != 'buyer':
+            raise ComputeWireError('not a buyer')
+        self.sealed_msg = dict(sealed_msg)
+        self.payment_preimage = preimage_hex
+
+        settled = make_settled(
+            from_did=did_of(self.my_pk),
+            to_did=did_of(self.peer_pk),
+            thid=self.thid,
+            payment_preimage=preimage_hex,
+        )
+        self.settled_msg = settled
+        self.state = 'SETTLED'
+        return settled
+
+    def buyer_verify_and_settle(
+        self,
+        receipt_event: NostrEvent,
+        registry: Optional[compute_executors.ExecutorRegistry] = None,
+        pinned_vk_digests: Optional[Collection[str]] = None,
+    ) -> tuple[bool, Optional[Message[ComputeRefuteBody]]]:
+        """Verify delivery and result integrity. If invalid, returns (False, refute_msg)."""
+        if self.role != 'buyer':
+            raise ComputeWireError('not a buyer')
+        if self.job_payload is None:
+            # A buyer always carries the job it asked for; without it there is
+            # no declared verify mode to check the receipt against.
+            raise ComputeWireError('buyer has no job payload to verify against')
+        job_payload = self.job_payload
+        self.receipt_event = receipt_event
+
+        sealed_body = self.sealed_msg['body'] if self.sealed_msg else {}
+        ciphertext = sealed_body.get('ciphertext', '')
+        claimed_result = sealed_body.get('result', '')
+
+        # 1. Unseal ciphertext with preimage
+        ok_open, dec_bytes, fail_reason = open_sealed(
+            ciphertext=ciphertext,
+            preimage_hex=self.payment_preimage or '',
+            expected_payment_hash=self.payment_hash,
+            expected_result=claimed_result,
+        )
+
+        if not ok_open or dec_bytes is None:
+            # Delivery violation! (S3)
+            refute = make_refute(
+                from_did=did_of(self.my_pk),
+                to_did=did_of(self.peer_pk),
+                thid=self.thid,
+                job_receipt=receipt_event['id'],
+                mode=job_payload.get('verify', {}).get('mode', 'none'),
+                claimed_result=claimed_result,
+                actual_result='',
+            )
+            self.refute_msg = refute
+            self.state = 'REFUTED'
+            return False, refute
+
+        # 2. Verify according to declared mode
+        decl_mode = job_payload.get('verify', {}).get('mode', 'none')
+        valid, fail_kind, fail_detail = evaluate_job_evidence(
+            declared_mode=decl_mode,
+            sealed_body=sealed_body,
+            decrypted_output=dec_bytes,
+            job_payload=job_payload,
+            registry=registry,
+            pinned_vk_digests=pinned_vk_digests,
+        )
+
+        if not valid:
+            refute = make_refute(
+                from_did=did_of(self.my_pk),
+                to_did=did_of(self.peer_pk),
+                thid=self.thid,
+                job_receipt=receipt_event['id'],
+                mode=decl_mode,
+                claimed_result=claimed_result,
+                actual_result=fail_detail.get('actual_result') if fail_detail else '',
+                wasi_profile_digest=fail_detail.get('wasi_profile_digest') if fail_detail else '',
+                engine=fail_detail.get('engine') if fail_detail else '',
+                # Under proof the detail IS the verifier's rejection (proof_system,
+                # reason). It used to be looked up under a key it never had, so the
+                # refute's proof_failure slot went out empty on every disputed proof.
+                proof_failure=cast(ProofFailure, dict(fail_detail)) if fail_detail and fail_kind in ('proof-invalid', 'commitment-mismatch') else None,
+            )
+            self.refute_msg = refute
+            self.state = 'REFUTED'
+            return False, refute
+
+        self.state = 'COMPLETED'
+        return True, None
+
+    # compute/1.1 Streaming & Progress Extensions
+    def seller_send_stream_chunk(
+        self,
+        seq: int,
+        delta: str,
+        is_final: bool = False,
+        counters: Optional[Mapping[str, Any]] = None,
+        encrypted: Optional[bool] = None,
+    ) -> Message[ComputeStreamBody]:
+        """Produce and emit sequential compute/1.1/stream chunk frame."""
+        if self.role != 'seller':
+            raise ComputeWireError('not a seller')
+        if seq < 0:
+            raise ComputeWireError(f'stream seq negative ({seq})')
+        if seq <= self.last_seq and self.last_seq != -1:
+            raise ComputeWireError(f'stream seq out of order ({seq} <= {self.last_seq})')
+        self.last_seq = seq
+
+        do_encrypt = self.encrypted if encrypted is None else encrypted
+        frame_delta = delta
+        if do_encrypt:
+            frame_delta = encrypt_stream_frame(self.session_key(), seq, delta)
+
+        msg = make_stream_chunk(
+            from_did=did_of(self.my_pk),
+            to_did=did_of(self.peer_pk),
+            thid=self.thid,
+            seq=seq,
+            delta=frame_delta,
+            is_final=is_final,
+            counters=counters,
+        )
+        self.stream_chunks.append(msg)
+        self.stream_buffer.append(delta)
+        if not is_final:
+            self.state = 'STREAMING'
+        else:
+            self.state = 'STREAM_COMPLETED'
+        return msg
+
+    def buyer_receive_stream_chunk(
+        self,
+        stream_msg: Mapping[str, Any],
+        encrypted: Optional[bool] = None,
+    ) -> Mapping[str, Any]:
+        """Process incoming sequential stream chunk and reassemble output."""
+        if self.role != 'buyer':
+            raise ComputeWireError('not a buyer')
+        body = stream_msg.get('body', {})
+        seq = int(body.get('seq', 0))
+        raw_delta = str(body.get('delta', ''))
+        is_final = bool(body.get('is_final', False))
+
+        if seq < 0:
+            raise ComputeWireError(f'stream seq negative ({seq})')
+        if seq <= self.last_seq and self.last_seq != -1:
+            raise ComputeWireError(f'stream seq out of order ({seq} <= {self.last_seq})')
+        self.last_seq = seq
+
+        do_encrypt = self.encrypted if encrypted is None else encrypted
+        if do_encrypt:
+            delta = decrypt_stream_frame(self.session_key(), seq, raw_delta)
+        else:
+            delta = raw_delta
+
+        self.stream_chunks.append(dict(stream_msg))
+        self.stream_buffer.append(delta)
+        if not is_final:
+            self.state = 'STREAMING'
+        else:
+            self.state = 'STREAM_COMPLETED'
+        return {
+            'seq': seq,
+            'delta': delta,
+            'is_final': is_final,
+            'cumulative_text': ''.join(self.stream_buffer),
+            'counters': body.get('counters', {}),
+        }
+
+    def seller_send_progress(
+        self,
+        state: ProgressState,
+        progress: Optional[float] = None,
+        elapsed_seconds: Optional[int] = None,
+        logs_tail: Optional[str] = None,
+    ) -> Message[ComputeProgressBody]:
+        """Emit compute/1.1/progress status update for long-running batch work."""
+        if self.role != 'seller':
+            raise ComputeWireError('not a seller')
+        msg = make_progress(
+            from_did=did_of(self.my_pk),
+            to_did=did_of(self.peer_pk),
+            thid=self.thid,
+            state=state,
+            progress=progress,
+            elapsed_seconds=elapsed_seconds,
+            logs_tail=logs_tail,
+        )
+        self.progress_history.append(msg)
+        return msg
+
+    def buyer_receive_progress(
+        self,
+        progress_msg: Mapping[str, Any],
+    ) -> Mapping[str, Any]:
+        """Record progress telemetry from seller."""
+        if self.role != 'buyer':
+            raise ComputeWireError('not a buyer')
+        self.progress_history.append(dict(progress_msg))
+        return dict(progress_msg.get('body', {}))
+
+    def create_progress_tracker(self) -> Callable[[str, float, Mapping[str, Any]], None]:
+        """Return a ProgressCallback that forwards telemetry updates to seller_send_progress."""
+        start_time = time.time()
+
+        def _tracker(state: str, progress: float, metadata: Mapping[str, Any]) -> None:
+            elapsed = int(time.time() - start_time)
+            logs_tail = str(metadata.get('logs_tail') or metadata.get('status') or '')
+            self.seller_send_progress(
+                state=cast(ProgressState, state),
+                progress=progress,
+                elapsed_seconds=elapsed,
+                logs_tail=logs_tail,
+            )
+
+        return _tracker
+
+    def register_cancellation_hook(self, hook: Callable[[str], None]) -> None:
+        """Register a callback to be invoked when the session is cancelled."""
+        self._cancellation_hooks.append(hook)
+
+    def cancel_session(
+        self,
+        reason: str,
+        penalty_msat: int = 0,
+    ) -> Message[ComputeCancelBody]:
+        """Abort ongoing compute session with reason and penalty terms."""
+        msg = make_cancel(
+            from_did=did_of(self.my_pk),
+            to_did=did_of(self.peer_pk),
+            thid=self.thid,
+            reason=reason,
+            penalty_msat=penalty_msat,
+        )
+        self.cancel_msg = msg
+        self.state = 'CANCELLED'
+        for hook in self._cancellation_hooks:
+            try:
+                hook(reason)
+            except Exception:
+                pass
+        return msg
+
+    def stream_over_quic(
+        self,
+        quic_engine: Any,
+        conn: Any,
+        chunks: Sequence[str],
+        encrypted: Optional[bool] = None,
+    ) -> list[Message[ComputeStreamBody]]:
+        """Stream a sequence of tokens directly over an active QUIC connection."""
+        sent_messages: list[Message[ComputeStreamBody]] = []
+        for i, delta in enumerate(chunks):
+            is_final = (i == len(chunks) - 1)
+            msg = self.seller_send_stream_chunk(seq=i, delta=delta, is_final=is_final, encrypted=encrypted)
+            if hasattr(quic_engine, 'send_stream') and conn is not None:
+                payload = json.dumps(msg).encode('utf-8')
+                quic_engine.send_stream(conn, payload)
+            sent_messages.append(msg)
+        return sent_messages
+
+    def stream_over_fips(
+        self,
+        flow_sock: Any,
+        chunks: Sequence[str],
+        fips_client: Optional[Any] = None,
+        encrypted: Optional[bool] = None,
+    ) -> list[Message[ComputeStreamBody]]:
+        """Stream sequential token frames directly over an active FIPS FSP datagram flow."""
+        sent_messages: list[Message[ComputeStreamBody]] = []
+        for i, delta in enumerate(chunks):
+            is_final = (i == len(chunks) - 1)
+            msg = self.seller_send_stream_chunk(seq=i, delta=delta, is_final=is_final, encrypted=encrypted)
+            if flow_sock is not None:
+                if fips_client is not None and hasattr(fips_client, 'send_framed'):
+                    fips_client.send_framed(flow_sock, payload=msg, seq=i, is_final=is_final)
+                elif hasattr(flow_sock, 'send'):
+                    from node.transport import fips_rung as fips_transport
+                    packet = fips_transport.encode_frame(
+                        seq=i,
+                        payload=json.dumps(msg, sort_keys=True).encode('utf-8'),
+                        is_final=is_final,
+                        is_didcomm=True,
+                    )
+                    flow_sock.send(packet)
+            sent_messages.append(msg)
+        return sent_messages
+
+    @property
+    def cumulative_text(self) -> str:
+        """Assembled stream content received/sent so far."""
+        return "".join(self.stream_buffer)
+
+    def buyer_receive_fips_chunk(
+        self,
+        raw_frame: Union[bytes, Mapping[str, Any]],
+    ) -> Mapping[str, Any]:
+        """Receive and decode a binary-framed FSP datagram chunk or payload."""
+        if isinstance(raw_frame, Mapping):
+            msg = raw_frame
+        else:
+            from node.transport import fips_rung as fips_transport
+            try:
+                seq, flags, payload = fips_transport.decode_frame(raw_frame)
+                msg = json.loads(payload.decode('utf-8'))
+            except Exception:
+                msg = json.loads(raw_frame.decode('utf-8'))
+        return self.buyer_receive_stream_chunk(msg)

node/planes/services/compute_wire/types.py

@@ -0,0 +1,49 @@
+"""Types and records for the ComputeWire transport compartment."""
+from __future__ import annotations
+
+from typing import Any, TypedDict
+
+
+class ComputeDisputeRecord(TypedDict):
+    """Refute received from a peer, stored in the disputes ring."""
+    peer: str
+    refute: Any
+
+
+class ComputeSessionSummary(TypedDict):
+    """Summary of an active bilateral compute session."""
+    role: str
+    peer: str
+    state: str
+
+
+class ComputeWireStateReport(TypedDict):
+    """State report for operator status and telemetry."""
+    active_sessions: int
+    disputes_filed: int
+    refusals: int
+
+
+class EvidenceDetail(TypedDict, total=False):
+    """Why evaluate_job_evidence said no, keyed by failure kind."""
+    claimed_result: str
+    actual_result: str
+    wasi_profile_digest: str
+    engine: str
+    engine_version: str
+    proof_system: str
+    reason: str
+    detail: str
+    path: list[str]
+    schema_path: list[str]
+    pattern: str
+    error: str
+
+
+class SealedResult(TypedDict, total=False):
+    """Result of sealing a compute job output under a preimage."""
+    ciphertext: str
+    payment_hash: str
+    payment_preimage: str
+    result: str
+    result_hash: str