fleetmesh-node 0.2.0__py3-none-any.whl

node/planes/services/compute_wire/verify.py

@@ -0,0 +1,331 @@
+"""Dispute automation: trusted-vk checks, job-evidence evaluation and dispute reports.
+
+Separate because verification re-runs jobs through compute.executors/jobs and must not depend on the session or the Compute subsystem.
+"""
+from __future__ import annotations
+
+import json
+import re
+import time
+from typing import Any, Callable, Collection, Mapping, Optional, Sequence
+
+from fleetmesh_core.accounting import market
+from fleetmesh_core.crypto import crypto, zk
+from fleetmesh_core.peering import reports
+from fleetmesh_core.wire.interfaces import NostrEvent
+from node.planes.services.compute import executors as compute_executors, jobs as compute_jobs
+from .messages import ComputeWireError
+
+
+from .types import EvidenceDetail
+
+# -------------------------------------------------------------------------
+# Independent Verification & Finding Evaluation
+# -------------------------------------------------------------------------
+def vk_is_trusted(vk_sha256: str, pinned: Optional[Collection[str]] = None) -> bool:
+    """Whether a verification-key digest may be used to judge a proof.
+
+    Trust comes from this node, never from the job: the digest must be in
+    zk.VK_REGISTRY (keys registered in-process) or in the operator's pinned
+    set. Matching an inline vk to the digest the requester wrote in the same
+    payload proves only self-consistency, so that alone is not enough.
+    """
+    h = str(vk_sha256 or '').lower()
+    if not h:
+        return False
+    if h in zk.VK_REGISTRY:
+        return True
+    return any(str(p).lower() == h for p in (pinned or ()))
+
+
+def evaluate_job_evidence(
+    declared_mode: str,
+    sealed_body: Mapping[str, Any],
+    decrypted_output: bytes,
+    job_payload: Mapping[str, Any],
+    registry: Optional[compute_executors.ExecutorRegistry] = None,
+    pinned_vk_digests: Optional[Collection[str]] = None,
+    resolve_blob: Optional[Callable[..., Optional[bytes]]] = None,
+) -> tuple[bool, Optional[str], Optional[EvidenceDetail]]:
+    """Evaluate whether job output satisfies the verify mode declared in the ask.
+
+    ``pinned_vk_digests`` is the operator's configured set of trusted
+    verification-key digests (compute.zk_pinned_vks in config); it extends
+    zk.VK_REGISTRY when deciding whether an inline vk may be used.
+
+    Returns (valid, failure_kind, failure_detail).
+    Failure kinds match fleetmesh_core/market.py admissible findings:
+      - 'rerun-divergence' under sample / dual
+      - 'proof-invalid' or 'commitment-mismatch' under proof
+    """
+    if declared_mode not in market.MODES:
+        raise ComputeWireError('unknown verify mode: %r' % declared_mode)
+
+    claimed_result = sealed_body.get('result', '')
+
+    if declared_mode in ('sample', 'dual'):
+        reg = registry or compute_executors.DEFAULT_REGISTRY
+        rerun_res = compute_jobs.run_job(job_payload, registry=reg)
+        actual_result = rerun_res['result_hash']
+        if actual_result != claimed_result:
+            return False, 'rerun-divergence', {
+                'claimed_result': claimed_result,
+                'actual_result': actual_result,
+                'wasi_profile_digest': rerun_res.get('wasi_profile_digest', ''),
+                'engine': rerun_res.get('engine', ''),
+                'engine_version': '1.0',
+            }
+        return True, None, None
+
+    if declared_mode == 'proof':
+        verify_spec = sealed_body.get('verify', {})
+        input_spec = job_payload.get('input', {})
+        proof_system = str(verify_spec.get('proof_system') or (input_spec.get('proof_system') if isinstance(input_spec, dict) else '') or 'zk-verify-groth16').lower()
+
+        # zkVM STARK / Groth16 receipt verification
+        if proof_system in ('zkvm', 'zkvm-risc0', 'zkvm-sp1', 'risc0-groth16', 'sp1-groth16', 'risc0-stark', 'sp1-stark'):
+            from node.planes.services.compute.executors.zk import ZkVmReceiptVerifier
+            pinned_list = list(pinned_vk_digests) if pinned_vk_digests is not None else None
+            verifier = ZkVmReceiptVerifier(pinned_control_ids=pinned_list)
+            image_id = str(input_spec.get('image_id') if isinstance(input_spec, dict) else '') or str(verify_spec.get('image_id') or '')
+            raw_seal = verify_spec.get('proof') or verify_spec.get('seal') or (input_spec.get('proof') if isinstance(input_spec, dict) else '') or b''
+            seal: bytes | Mapping[str, Any] = raw_seal if isinstance(raw_seal, (bytes, Mapping)) else str(raw_seal).encode('utf-8')
+            res = verifier.verify_receipt(
+                image_id=image_id,
+                journal=decrypted_output,
+                seal=seal,
+                proof_system=proof_system,
+            )
+            if not res.valid:
+                return False, 'proof-invalid', {
+                    'proof_system': proof_system,
+                    'reason': res.error or 'invalid-zkvm-receipt',
+                }
+            return True, None, None
+
+        # A verification key travelling with the job is only trusted when the
+        # ask committed to it: its canonical digest must equal
+        # input_spec['vk_sha256'] AND that digest must be one this node
+        # already trusts (zk.VK_REGISTRY, or the operator's pinned set).
+        # Otherwise a prover can ship a vk of their own making and any proof
+        # under it verifies -- the pairing check would then prove nothing
+        # about the statement the requester paid for.
+        custom_vk = None
+        vk_sha = str(input_spec.get('vk_sha256') or '').lower() if isinstance(input_spec, dict) else ''
+        if isinstance(input_spec, dict) and 'vk' in input_spec:
+            mismatch: EvidenceDetail = {
+                'proof_system': verify_spec.get('proof_system', 'zk-verify-groth16'),
+                'reason': 'commitment-mismatch',
+            }
+            refusal: tuple[bool, Optional[str], Optional[EvidenceDetail]] = (False, 'commitment-mismatch', mismatch)
+            if not isinstance(input_spec['vk'], dict) or not vk_sha:
+                return refusal
+            try:
+                candidate = zk.VerificationKey.from_dict(input_spec['vk'])
+            except Exception:
+                return refusal
+            if candidate.digest() != vk_sha or not vk_is_trusted(vk_sha, pinned_vk_digests):
+                return refusal
+            custom_vk = candidate
+
+        # Check proof verification
+        proof_payload = dict(input_spec)
+        if 'proof' in verify_spec:
+            proof_payload['proof'] = verify_spec['proof']
+
+        try:
+            verif_res = zk.verify_groth16_job(proof_payload, custom_vk=custom_vk)
+            if not verif_res.get('valid', False):
+                return False, 'proof-invalid', {
+                    'proof_system': verify_spec.get('proof_system', 'zk-verify-groth16'),
+                    'reason': 'invalid-proof',
+                }
+        except Exception:
+            return False, 'proof-invalid', {
+                'proof_system': verify_spec.get('proof_system', 'zk-verify-groth16'),
+                'reason': 'invalid-proof',
+            }
+
+        return True, None, None
+
+    if declared_mode == 'schema-bounds':
+        try:
+            output_text = decrypted_output.decode('utf-8')
+        except Exception as e:
+            return False, 'schema-validation-failure', {
+                'reason': 'output-failed-json-schema-bounds',
+                'detail': f'output is not valid utf-8: {e}',
+                'error': f'output is not valid utf-8: {e}',
+            }
+
+        raw_grammar = job_payload.get('grammar')
+        grammar: Mapping[str, Any] = raw_grammar if isinstance(raw_grammar, Mapping) else {}
+        grammar_type = str(grammar.get('type') or ('regex' if grammar.get('guided_regex') else 'json_schema')).lower()
+        regex_pattern = grammar.get('guided_regex') or (grammar.get('definition') if grammar_type == 'regex' else None)
+
+        if regex_pattern:
+            try:
+                if not re.search(regex_pattern, output_text):
+                    return False, 'grammar-constraint-violation', {
+                        'reason': 'regex-match-failure',
+                        'pattern': str(regex_pattern),
+                        'detail': f'output does not match regex pattern {regex_pattern}',
+                        'error': f'output does not match regex pattern {regex_pattern}',
+                    }
+            except re.error as e:
+                return False, 'grammar-constraint-violation', {
+                    'reason': 'regex-syntax-error',
+                    'pattern': str(regex_pattern),
+                    'error': str(e),
+                    'detail': str(e),
+                }
+
+        # Resolve schema specification if present (inline or via Blossom CAS CID)
+        schema_spec = (
+            job_payload.get('schema')
+            or grammar.get('json_schema')
+            or (grammar.get('definition') if grammar_type == 'json_schema' else None)
+            or (job_payload.get('verification') or {}).get('target_schema')
+        )
+        schema_cid = (
+            grammar.get('schema_cid')
+            or job_payload.get('schema_cid')
+            or (job_payload.get('verification') or {}).get('target_schema_cid')
+        )
+
+        has_schema = bool(schema_spec or schema_cid or grammar_type == 'json_schema')
+
+        # If a schema is required, validate JSON syntax and schema bounds
+        if has_schema:
+            try:
+                output_json = json.loads(output_text)
+            except Exception as e:
+                return False, 'schema-validation-failure', {
+                    'reason': 'output-failed-json-schema-bounds',
+                    'detail': f'invalid json: {e}',
+                    'error': f'invalid json: {e}',
+                }
+
+            if not schema_spec and schema_cid:
+                blob_store = job_payload.get('blob_store') or (registry.blob_store if registry else None)
+                blossom_servers = job_payload.get('blossom_servers')
+                resolve_fn = resolve_blob
+                if resolve_fn is None:
+                    try:
+                        from fleetmesh_core.storage.cas import resolve_blob as _default_res
+                        resolve_fn = _default_res
+                    except ImportError:
+                        resolve_fn = None
+                if resolve_fn is not None:
+                    try:
+                        schema_bytes = resolve_fn({'sha256': schema_cid}, blob_store=blob_store, blossom_servers=blossom_servers)
+                    except TypeError:
+                        schema_bytes = resolve_fn(schema_cid)
+                    if schema_bytes:
+                        try:
+                            schema_spec = json.loads(schema_bytes.decode('utf-8'))
+                        except Exception:
+                            pass
+
+            if isinstance(schema_spec, str) and schema_spec.strip().startswith('{'):
+                try:
+                    schema_spec = json.loads(schema_spec)
+                except Exception:
+                    pass
+
+            if isinstance(schema_spec, Mapping):
+                try:
+                    import jsonschema
+                    validator_cls = getattr(jsonschema, 'Draft202012Validator', jsonschema.Draft7Validator)
+                    validator = validator_cls(schema_spec)
+                    errors = list(validator.iter_errors(output_json))
+                    if errors:
+                        first_err = errors[0]
+                        return False, 'schema-validation-failure', {
+                            'reason': 'schema-validation-failure',
+                            'detail': first_err.message,
+                            'error': first_err.message,
+                            'path': [str(p) for p in first_err.path],
+                            'schema_path': [str(p) for p in first_err.schema_path],
+                        }
+                except Exception as e:
+                    return False, 'schema-validation-failure', {
+                        'reason': 'schema-validation-error',
+                        'detail': str(e),
+                        'error': str(e),
+                    }
+
+        return True, None, None
+
+    return True, None, None
+
+
+# -------------------------------------------------------------------------
+# Automated Dispute & Report Generation (Kind 30802)
+# -------------------------------------------------------------------------
+def build_compute_dispute_report(
+    reporter_sk: str,
+    seller_pk: str,
+    grant_id: str,
+    windows: tuple[int, int] | Sequence[int],
+    evidence_kind: str,
+    receipt_event: NostrEvent,
+    sealed_message: Optional[Mapping[str, Any]] = None,
+    evidence_detail: Optional[EvidenceDetail] = None,
+    grant_envelope: Optional[NostrEvent] = None,
+    now: Optional[int] = None,
+    ttl_seconds: int = 86400 * 7,
+) -> NostrEvent:
+    """Build a signed Kind 30802 conformance report citing compute violation evidence.
+
+    Assigns severity:
+      - S3: for delivery fraud ('sealed-key-does-not-open', 'result-hash-mismatch-after-decrypt')
+      - S2: for computational divergence ('rerun-divergence', 'proof-invalid', 'commitment-mismatch')
+    Carries signed inline evidence per fleetmesh_core/reports.py.
+    """
+    now_val = int(now if now is not None else time.time())
+    reporter_pk = crypto.pubkey(reporter_sk)
+
+    delivery_frauds = {'sealed-key-does-not-open', 'result-hash-mismatch-after-decrypt'}
+    if evidence_kind in delivery_frauds:
+        severity = 'S3'
+    else:
+        severity = 'S2'
+
+    # Evidence list: Kind 30811 receipt signed by seller
+    ev_list: list[tuple[str, str, Any] | tuple[str, str]] = []
+    receipt_id = receipt_event.get('id', '')
+    if receipt_event:
+        # Cited as public event reference
+        ev_list.append(('event', receipt_id))
+
+    claimed = None
+    observed = None
+    if evidence_detail:
+        if 'claimed_result' in evidence_detail and 'actual_result' in evidence_detail:
+            claimed = ('result', evidence_detail['claimed_result'])
+            observed = ('result', evidence_detail['actual_result'], evidence_detail.get('limit', ''))
+
+    note_text = f"compute/1.0 dispute: {evidence_kind} against receipt {receipt_id[:16]}"
+    if sealed_message:
+        note_text += f" (sealed payment_hash {sealed_message.get('body', {}).get('payment_hash', '')[:16]})"
+
+    unsigned = reports.build(
+        reporter_pubkey=reporter_pk,
+        subject_pubkey=seller_pk,
+        severity=severity,
+        grant_id=grant_id,
+        windows=windows,
+        evidence=ev_list,
+        now=now_val,
+        ttl_seconds=ttl_seconds,
+        observed=observed,
+        claimed=claimed,
+        content=note_text,
+        grant_envelope=grant_envelope,
+    )
+    # Sign report with reporter's secret key. reports.build returns the
+    # unsigned shape; adding 'sig' is what turns it into a NostrEvent.
+    report_event: NostrEvent = {**unsigned,
+                                'sig': crypto.schnorr_sign(bytes.fromhex(unsigned['id']), reporter_sk)}
+    return report_event

node/planes/services/dvm/__init__.py

@@ -0,0 +1,24 @@
+"""NIP-90 Data Vending Machine (DVM) compute gateway for fleetmesh.
+
+Translates client-facing NIP-90 compute job requests (kinds 5000-5999) into
+deterministic fleetmesh compute jobs, runs them, and emits kind 6000-6999
+results with kind 7000 feedback. Three seams:
+
+    protocol.py    the kinds, parsing a request, building feedback/result events
+    translate.py   one function per executor turning a request into a job
+    gateway.py     the compartment: process, delegate, fan out, commands
+"""
+from .protocol import (DEFAULT_SUPPORTED_KINDS, FEEDBACK_KIND, DVMError, build_dvm_feedback, build_dvm_response,
+                       dvm_response_kind, is_dvm_request, is_dvm_response, parse_dvm_request)
+from .translate import (agent_job, bacalhau_job, dvm_request_to_mesh_job, is_agent, is_bacalhau, is_llm, is_zk,
+                        llm_job, wasm_job, zk_job)
+from .gateway import DVMGateway
+from .types import DVMDelegationResult, DVMStateReport
+
+__all__ = [
+    'DEFAULT_SUPPORTED_KINDS', 'FEEDBACK_KIND', 'DVMError', 'build_dvm_feedback', 'build_dvm_response',
+    'dvm_response_kind', 'is_dvm_request', 'is_dvm_response', 'parse_dvm_request',
+    'agent_job', 'bacalhau_job', 'dvm_request_to_mesh_job', 'is_agent', 'is_bacalhau', 'is_llm', 'is_zk',
+    'llm_job', 'wasm_job', 'zk_job',
+    'DVMGateway', 'DVMDelegationResult', 'DVMStateReport',
+]