fleetmesh-node 0.2.0__py3-none-any.whl

node/planes/services/compute/market.py

@@ -0,0 +1,433 @@
+"""Compute market events: offers (11803), asks (30810), order-book parsing and matching.
+
+Separate because the market layer is pure event construction and matching and shares nothing with execution.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any, Mapping, Optional, Sequence
+
+from fleetmesh_core.accounting import market
+from fleetmesh_core.storage import store
+from fleetmesh_core.wire.interfaces import NostrEvent
+from node import keystore
+from .common import ComputeError, OFFER_KIND, ASK_KIND, DEFAULT_EXPIRATION
+
+# -------------------------------------------------------------------------
+# Kind 11803: Compute Offer
+# -------------------------------------------------------------------------
+def build_offer(
+    ks: keystore.Keystore,
+    executors: Sequence[Sequence[str]],
+    limits: Optional[Sequence[Sequence[str]]] = None,
+    runtimes: Optional[Sequence[Sequence[str]]] = None,
+    pay: Optional[Sequence[Sequence[str]]] = None,
+    expiration: Optional[int] = None,
+    now: Optional[int] = None,
+) -> NostrEvent:
+    """Build a signed kind 11803 compute offer event.
+
+    Content MUST be empty. At least one executor tag is required.
+    """
+    now_val = int(now if now is not None else time.time())
+    exp_val = int(expiration if expiration is not None else now_val + DEFAULT_EXPIRATION)
+
+    if not executors:
+        raise ComputeError('at least one executor tag is required')
+
+    tags: list[list[str]] = []
+    for ex in executors:
+        tags.append(['executor'] + list(ex))
+
+    for lim in limits or []:
+        tags.append(['limit'] + list(lim))
+
+    for rt in runtimes or []:
+        tags.append(['runtime'] + list(rt))
+
+    for p in pay or []:
+        tags.append(['pay'] + list(p))
+
+    tags.append(['expiration', str(exp_val)])
+
+    ev = store.make_signed_event(ks.node_sk, now_val, OFFER_KIND, tags, '')
+    return ev
+
+
+def validate_offer(offer: NostrEvent | Mapping[str, Any]) -> list[str]:
+    """Validate that an offer complies with kind 11803 constraints."""
+    problems: list[str] = []
+    if offer.get('kind') != OFFER_KIND:
+        problems.append('not a kind 11803')
+    if offer.get('content') != '':
+        problems.append('compute offer content must be empty')
+
+    tags = offer.get('tags', [])
+    has_exec = any(t and t[0] == 'executor' and len(t) >= 2 for t in tags)
+    if not has_exec:
+        problems.append('missing required executor tag')
+
+    has_exp = any(t and t[0] == 'expiration' and len(t) == 2 for t in tags)
+    if not has_exp:
+        problems.append('missing required expiration tag')
+
+    return problems
+
+
+# -------------------------------------------------------------------------
+# Kind 30810: Compute Ask
+# -------------------------------------------------------------------------
+def build_ask(
+    buyer_sk: str,
+    ask_id: str,
+    job_payload: Mapping[str, Any],
+    executor: str,
+    bid_currency: str,
+    bid_price: int,
+    deadline: int,
+    fuel_max: int,
+    verify_mode: str,
+    expiration: Optional[int] = None,
+    verify_param: Optional[str] = None,
+    extra_tags: Optional[Sequence[Sequence[str]]] = None,
+    now: Optional[int] = None,
+) -> NostrEvent:
+    """Build a signed kind 30810 compute ask event.
+
+    Content MUST be empty. Module and input MUST NOT be named in tags to preserve
+    job confidentiality on public relays.
+    """
+    now_val = int(now if now is not None else time.time())
+    exp_val = int(expiration if expiration is not None else now_val + DEFAULT_EXPIRATION)
+
+    if verify_mode not in market.MODES:
+        raise ComputeError('unknown verify mode: %r' % (verify_mode,))
+
+    commit = market.ask_commitment(job_payload)
+
+    tags: list[list[str]] = [
+        ['d', ask_id],
+        ['commit', commit],
+        ['executor', executor],
+        ['bid', bid_currency, str(int(bid_price))],
+        ['deadline', str(int(deadline))],
+        ['fuel_max', str(int(fuel_max))],
+    ]
+
+    if verify_param:
+        tags.append(['verify', verify_mode, verify_param])
+    else:
+        tags.append(['verify', verify_mode])
+
+    tags.append(['expiration', str(exp_val)])
+
+    for extra in extra_tags or []:
+        if extra and extra[0] in ('module', 'input'):
+            raise ComputeError('ask must not leak module or input in tags')
+        tags.append(list(extra))
+
+    ev = store.make_signed_event(buyer_sk, now_val, ASK_KIND, tags, '')
+    return ev
+
+
+def verify_ask(ask: NostrEvent | Mapping[str, Any], job_payload: Mapping[str, Any]) -> bool:
+    """Check that a received job payload matches the commitment in the ask."""
+    if ask.get('kind') != ASK_KIND:
+        return False
+    # market.* take a concrete dict; copying a Mapping into one is cheap and
+    # keeps the read-only contract this function advertises to callers.
+    ask_dict = dict(ask)
+    if market.leaks_job(ask_dict):
+        return False
+    return market.commitment_holds(ask_dict, job_payload)
+
+
+# -------------------------------------------------------------------------
+# Order-Book Parsing & Matching Engine
+# -------------------------------------------------------------------------
+def parse_offer(offer: NostrEvent | Mapping[str, Any]) -> Mapping[str, Any]:
+    """Extract structured offer parameters from a kind 11803 event."""
+    tags = offer.get('tags', [])
+    executors = []
+    limits: dict[str, int] = {}
+    runtimes: list[dict[str, str]] = []
+    pay: list[str] = []
+    expiration: int = 0
+
+    for t in tags:
+        if not t or not isinstance(t, (list, tuple)):
+            continue
+        # Each arm binds the tag's positional fields by shape; a tag that is
+        # too short for its name simply falls through and is ignored, as the
+        # spec allows unknown or malformed tags on an offer.
+        match list(t):
+            case ['executor', engine, *rest]:
+                unit = str(rest[0]) if rest else 'msat_per_mfuel'
+                try:
+                    rate = int(rest[1]) if len(rest) > 1 else 0
+                except ValueError:
+                    rate = 0
+                executors.append({'engine': str(engine), 'unit': unit, 'rate': rate})
+            case ['limit', key, val, *_]:
+                try:
+                    limits[str(key)] = int(val)
+                except ValueError:
+                    pass
+            case ['runtime', engine, version, digest, *_]:
+                runtimes.append({
+                    'engine': str(engine),
+                    'version': str(version),
+                    'wasi_profile_digest': str(digest),
+                })
+            case ['pay', method, *_]:
+                pay.append(str(method))
+            case ['expiration', raw, *_]:
+                try:
+                    expiration = int(raw)
+                except ValueError:
+                    expiration = 0
+            case _:
+                pass
+
+    return {
+        'id': offer.get('id', ''),
+        'pubkey': offer.get('pubkey', ''),
+        'created_at': offer.get('created_at', 0),
+        'executors': executors,
+        'limits': limits,
+        'runtimes': runtimes,
+        'pay': pay,
+        'expiration': expiration,
+    }
+
+
+def parse_ask(ask: NostrEvent | Mapping[str, Any]) -> Mapping[str, Any]:
+    """Extract structured ask parameters from a kind 30810 event."""
+    tags = ask.get('tags', [])
+    ask_id: str = ''
+    commit: str = ''
+    executor: str = ''
+    bid_currency: str = 'msat_per_mfuel'
+    bid_price: int = 0
+    deadline: int = 0
+    fuel_max: int = 0
+    verify_mode: str = 'none'
+    verify_param: Optional[str] = None
+    expiration: int = 0
+    runtime_digest: Optional[str] = None
+
+    for t in tags:
+        if not t or not isinstance(t, (list, tuple)):
+            continue
+        # Shape-matched like parse_offer: a too-short tag falls through.
+        match list(t):
+            case ['d', raw, *_]:
+                ask_id = str(raw)
+            case ['commit', raw, *_]:
+                commit = str(raw)
+            case ['executor', raw, *_]:
+                executor = str(raw)
+            case ['bid', currency, price, *_]:
+                bid_currency = str(currency)
+                try:
+                    bid_price = int(price)
+                except ValueError:
+                    bid_price = 0
+            case ['deadline', raw, *_]:
+                try:
+                    deadline = int(raw)
+                except ValueError:
+                    deadline = 0
+            case ['fuel_max', raw, *_]:
+                try:
+                    fuel_max = int(raw)
+                except ValueError:
+                    fuel_max = 0
+            case ['verify', mode, *rest]:
+                verify_mode = str(mode)
+                if rest:
+                    verify_param = str(rest[0])
+            case ['runtime', _, _, digest, *_]:
+                runtime_digest = str(digest)
+            case ['expiration', raw, *_]:
+                try:
+                    expiration = int(raw)
+                except ValueError:
+                    expiration = 0
+            case _:
+                pass
+
+    return {
+        'id': ask.get('id', ''),
+        'pubkey': ask.get('pubkey', ''),
+        'created_at': ask.get('created_at', 0),
+        'ask_id': ask_id,
+        'commit': commit,
+        'executor': executor,
+        'bid_currency': bid_currency,
+        'bid_price': bid_price,
+        'deadline': deadline,
+        'fuel_max': fuel_max,
+        'verify_mode': verify_mode,
+        'verify_param': verify_param,
+        'runtime_digest': runtime_digest,
+        'expiration': expiration,
+    }
+
+
+def match_ask_to_offers(
+    ask: NostrEvent | Mapping[str, Any],
+    offers: Sequence[NostrEvent | Mapping[str, Any]],
+    trust_weights: Optional[Mapping[str, float]] = None,
+    now: Optional[int] = None,
+) -> list[Mapping[str, Any]]:
+    """Match a compute ask against candidate compute offers in the order book.
+
+    Returns candidate matches ranked by:
+    1. Zero-cost / free offers first (volunteer / spare cycles),
+    2. Lowest rate amount (msat_per_mfuel),
+    3. Lowest reported CPU load percentage (cpu_load_pct),
+    4. Highest trust weight / reputation standing,
+    5. Furthest expiration deadline.
+    """
+    now_val = int(now if now is not None else time.time())
+    ask_p = parse_ask(ask)
+    matches: list[Mapping[str, Any]] = []
+
+    for off in offers:
+        off_p = parse_offer(off)
+        # 1. Expiration check
+        if off_p['expiration'] and off_p['expiration'] < now_val:
+            continue
+        if ask_p['deadline'] and off_p['expiration'] and off_p['expiration'] < ask_p['deadline']:
+            continue
+
+        # 2. Fuel limit and CPU/slot headroom check
+        if 'fuel_max' in off_p['limits'] and off_p['limits']['fuel_max'] < ask_p['fuel_max']:
+            continue
+        if 'free_slots' in off_p['limits'] and int(off_p['limits']['free_slots']) <= 0:
+            continue
+        if 'cpu_load_pct' in off_p['limits'] and int(off_p['limits']['cpu_load_pct']) >= 85:
+            continue
+
+        # 3. Match executor engine
+        matched_exec = None
+        for ex in off_p['executors']:
+            if ex['engine'] == ask_p['executor'] or (
+                ask_p['executor'] == 'wasm' and ex['engine'] in ('wasm', 'wasmtime', 'wasmer')
+            ) or (
+                ask_p['executor'] in ('ffmpeg', 'media-transcode', 'video-transcode', 'transcode')
+                and ex['engine'] in ('ffmpeg', 'media-transcode', 'video-transcode', 'transcode')
+            ):
+                matched_exec = ex
+                break
+        if not matched_exec:
+            continue
+
+        # 4. Price check: offer rate must not exceed ask bid (or offer is free: rate == 0)
+        offer_rate = matched_exec['rate']
+        if offer_rate > ask_p['bid_price'] and offer_rate != 0:
+            continue
+
+        # 5. Runtime digest check if specified in both
+        if ask_p['runtime_digest']:
+            has_matching_rt = any(
+                rt.get('wasi_profile_digest') == ask_p['runtime_digest']
+                for rt in off_p['runtimes']
+            )
+            if off_p['runtimes'] and not has_matching_rt:
+                continue
+
+        # Price estimation
+        fuel = ask_p['fuel_max'] or 1000000
+        est_cost_msat = (fuel * offer_rate) // 1000000 if offer_rate > 0 else 0
+
+        seller_pk = off_p['pubkey']
+        seller_trust = float(trust_weights.get(seller_pk, 0.0)) if trust_weights else 0.0
+        cpu_load_pct = int(off_p['limits'].get('cpu_load_pct', 0))
+        free_slots = int(off_p['limits'].get('free_slots', 1))
+
+        matches.append({
+            'offer_id': off_p['id'],
+            'seller_pubkey': seller_pk,
+            'executor': matched_exec['engine'],
+            'rate_unit': matched_exec['unit'],
+            'rate': offer_rate,
+            'estimated_cost_msat': est_cost_msat,
+            'is_free': (offer_rate == 0),
+            'cpu_load_pct': cpu_load_pct,
+            'free_slots': free_slots,
+            'seller_trust': seller_trust,
+            'expiration': off_p['expiration'],
+            'offer_event': off,
+        })
+
+    # Sort matches: free offers first (0 vs 1), lowest rate, lowest CPU load, highest trust, furthest expiration
+    matches.sort(
+        key=lambda m: (
+            0 if m['is_free'] else 1,
+            m['rate'],
+            m['cpu_load_pct'],
+            -m['seller_trust'],
+            -m['expiration'],
+        )
+    )
+    return matches
+
+
+def match_offer_to_asks(
+    offer: NostrEvent | Mapping[str, Any],
+    asks: Sequence[NostrEvent | Mapping[str, Any]],
+    now: Optional[int] = None,
+) -> list[Mapping[str, Any]]:
+    """Match a compute offer against pending compute asks in the order book."""
+    now_val = int(now if now is not None else time.time())
+    off_p = parse_offer(offer)
+    if off_p['expiration'] and off_p['expiration'] < now_val:
+        return []
+
+    matches: list[Mapping[str, Any]] = []
+    for ask in asks:
+        ask_p = parse_ask(ask)
+        if ask_p['expiration'] and ask_p['expiration'] < now_val:
+            continue
+        if ask_p['deadline'] and off_p['expiration'] and off_p['expiration'] < ask_p['deadline']:
+            continue
+        if 'fuel_max' in off_p['limits'] and off_p['limits']['fuel_max'] < ask_p['fuel_max']:
+            continue
+
+        matched_exec = None
+        for ex in off_p['executors']:
+            if ex['engine'] == ask_p['executor'] or (
+                ask_p['executor'] == 'wasm' and ex['engine'] in ('wasm', 'wasmtime', 'wasmer')
+            ) or (
+                ask_p['executor'] in ('ffmpeg', 'media-transcode', 'video-transcode', 'transcode')
+                and ex['engine'] in ('ffmpeg', 'media-transcode', 'video-transcode', 'transcode')
+            ):
+                matched_exec = ex
+                break
+        if not matched_exec:
+            continue
+
+        offer_rate = matched_exec['rate']
+        if offer_rate > ask_p['bid_price'] and offer_rate != 0:
+            continue
+
+        fuel = ask_p['fuel_max'] or 1000000
+        est_cost_msat = (fuel * offer_rate) // 1000000 if offer_rate > 0 else 0
+
+        matches.append({
+            'ask_id': ask_p['ask_id'],
+            'buyer_pubkey': ask_p['pubkey'],
+            'executor': matched_exec['engine'],
+            'bid_price': ask_p['bid_price'],
+            'rate': offer_rate,
+            'estimated_revenue_msat': est_cost_msat,
+            'is_free': (offer_rate == 0),
+            'deadline': ask_p['deadline'],
+            'ask_event': ask,
+        })
+
+    # Sort asks: highest bid first, nearest deadline
+    matches.sort(key=lambda m: (-m['bid_price'], m['deadline']))
+    return matches