fleetmesh-node 0.2.0__py3-none-any.whl

node/planes/services/settle/gateways.py

@@ -0,0 +1,541 @@
+"""Live Payment Gateways: NIP-47 (Nostr Wallet Connect / NWC) & Cashu HTTP Mint Client.
+
+Integrates real external settlement rails with MeshNode:
+1. NIP-47 Nostr Wallet Connect (NWC):
+   - URI parser: nostr+walletconnect://<wallet_pubkey>?relay=<url>&secret=<secret_hex>&lud16=<lud16>
+   - Dual-mode encryption: NIP-04 (AES-256-CBC) and NIP-44 v2 (ChaCha20-Poly1305).
+   - Methods: pay_invoice, make_invoice, lookup_invoice, get_balance.
+   - `NWCLightningPaymentRail`: Implements PaymentRail for automated compute settlement via Lightning.
+2. Cashu Mint HTTP Client (NUT-00, NUT-03, NUT-04, NUT-05):
+   - Standard library urllib client for v1 Cashu mint REST API.
+   - Quote generation, token minting, token melting (ecash-to-Lightning), and token swapping (NUT-03).
+   - `LiveCashuPaymentRail`: Extends CashuPaymentRail with live mint validation and atomic swaps.
+"""
+from __future__ import annotations
+
+from fleetmesh_core.wire import spelling  # noqa: E402
+
+import base64
+import json
+import os
+import threading
+import time
+from typing import Any, Mapping, Optional, Sequence, TypedDict, cast
+from urllib.parse import parse_qs, urlparse
+
+from cryptography.hazmat.primitives import padding
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+from fleetmesh_core.accounting.cashu import (
+    BlindedMessage, CashuProof, CheckStateResult,
+    MeltQuoteResult, MintQuoteResult, SwapResult,
+    hash_to_curve, point_to_hex,
+)
+from fleetmesh_core.crypto import crypto, curve, nip44
+from fleetmesh_core.storage import store as store_mod
+from fleetmesh_core.wire.interfaces import NostrEvent
+from . import payment
+from node.transport import netfetch
+from node.protocols.nostr import client as relay
+
+DEFAULT_MINT_URL: str = 'https://mint.example.org'
+DEFAULT_RELAY_URL: str = 'wss://relay.example.org'
+# A Cashu mint reply is JSON of a few KiB; 4 MiB leaves room for large
+# keyset listings while bounding what a broken mint can push at us.
+MINT_MAX_RESPONSE_BYTES: int = 4 * 1024 * 1024
+
+# NIP-47 Kind Numbers
+NWC_REQUEST_KIND: int = 23194
+NWC_RESPONSE_KIND: int = 23195
+
+
+class NwcPayResult(TypedDict, total=False):
+    preimage: str
+    fees_paid: int
+
+
+class NwcMakeInvoiceResult(TypedDict, total=False):
+    invoice: str
+    payment_hash: str
+    amount: int
+    expiry: int
+
+
+class NwcLookupInvoiceResult(TypedDict, total=False):
+    type: str
+    invoice: str
+    description: str
+    description_hash: Optional[str]
+    preimage: Optional[str]
+    payment_hash: str
+    amount: int
+    fees_paid: int
+    created_at: int
+    expires_at: int
+    settled_at: Optional[int]
+
+
+class NwcBalanceResult(TypedDict, total=False):
+    balance: int
+
+
+class MintKeyset(TypedDict, total=False):
+    id: str
+    unit: str
+    active: bool
+    keys: dict[str, str]
+
+
+class MintKeysResult(TypedDict, total=False):
+    keysets: list[MintKeyset]
+
+
+class MintInfoResult(TypedDict, total=False):
+    name: str
+    pubkey: str
+    version: str
+    description: str
+    description_long: str
+    contact: list[list[str]]
+    nuts: Mapping[str, Any]
+
+
+class NwcPayParams(TypedDict, total=False):
+    invoice: str
+    amount: int
+
+
+class NwcLookupParams(TypedDict, total=False):
+    payment_hash: str
+    invoice: str
+
+
+# ---------------------------------------------------------------------------
+# NIP-04 / NIP-44 Encryption Utilities
+# ---------------------------------------------------------------------------
+
+def nip04_encrypt(plaintext: str | bytes, sec_hex: str, pub_hex: str) -> str:
+    """Encrypt payload using standard NIP-04 (AES-256-CBC with PKCS#7 padding)."""
+    shared_x = bytes.fromhex(curve.ecdh_x(sec_hex, pub_hex))
+    iv = os.urandom(16)
+    data = plaintext.encode('utf-8') if isinstance(plaintext, str) else plaintext
+
+    padder = padding.PKCS7(128).padder()
+    padded_data = padder.update(data) + padder.finalize()
+
+    cipher = Cipher(algorithms.AES(shared_x), modes.CBC(iv))
+    encryptor = cipher.encryptor()
+    ct = encryptor.update(padded_data) + encryptor.finalize()
+
+    ct_b64 = base64.b64encode(ct).decode('ascii')
+    iv_b64 = base64.b64encode(iv).decode('ascii')
+    return f"{ct_b64}?iv={iv_b64}"
+
+
+def nip04_decrypt(payload: str, sec_hex: str, pub_hex: str) -> str:
+    """Decrypt payload using standard NIP-04 (AES-256-CBC with PKCS#7 unpadding)."""
+    parts = payload.split('?iv=')
+    if len(parts) != 2:
+        raise ValueError("invalid NIP-04 payload: missing ?iv= delimiter")
+
+    ct = base64.b64decode(parts[0])
+    iv = base64.b64decode(parts[1])
+
+    shared_x = bytes.fromhex(curve.ecdh_x(sec_hex, pub_hex))
+    cipher = Cipher(algorithms.AES(shared_x), modes.CBC(iv))
+    decryptor = cipher.decryptor()
+    padded_data = decryptor.update(ct) + decryptor.finalize()
+
+    unpadder = padding.PKCS7(128).unpadder()
+    data = unpadder.update(padded_data) + unpadder.finalize()
+    return data.decode('utf-8')
+
+
+# ---------------------------------------------------------------------------
+# NIP-47 (NWC) Client
+# ---------------------------------------------------------------------------
+
+class NWCError(Exception):
+    pass
+
+
+class NWCUri:
+    """NIP-47 nostr+walletconnect:// URI representation."""
+
+    def __init__(self, uri: str) -> None:
+        raw = uri.strip()
+        if raw.startswith('nostrwalletconnect://'):
+            raw = 'nostr+walletconnect://' + raw[len('nostrwalletconnect://'):]
+        if not raw.startswith('nostr+walletconnect://'):
+            raise ValueError("URI must begin with nostr+walletconnect://")
+
+        parsed = urlparse(raw)
+        self.wallet_pubkey: str = (parsed.netloc or parsed.path.lstrip('/')).lower()
+        if not spelling.is_hex(self.wallet_pubkey, 64):
+            raise ValueError(f"invalid 64-hex wallet pubkey: {self.wallet_pubkey}")
+
+        qs = parse_qs(parsed.query)
+        self.relay: str = qs.get('relay', [''])[0]
+        self.secret: str = qs.get('secret', [''])[0].lower()
+        self.lud16: str = qs.get('lud16', [''])[0]
+
+        if not spelling.is_hex(self.secret, 64):
+            raise ValueError("secret must be a 64-hex secp256k1 private key")
+
+        self.client_pubkey: str = crypto.pubkey(self.secret)
+
+
+class NWCClient:
+    """NIP-47 Nostr Wallet Connect client."""
+
+    def __init__(
+        self,
+        uri: str,
+        timeout: float = 10.0,
+        encryption_mode: str = 'nip04',  # 'nip04' or 'nip44'
+    ) -> None:
+        self.uri_info: NWCUri = NWCUri(uri)
+        self.timeout: float = timeout
+        self.encryption_mode: str = encryption_mode
+        self._lock: threading.RLock = threading.RLock()
+
+    @property
+    def wallet_pubkey(self) -> str:
+        return self.uri_info.wallet_pubkey
+
+    @property
+    def client_pubkey(self) -> str:
+        return self.uri_info.client_pubkey
+
+    @property
+    def secret(self) -> str:
+        return self.uri_info.secret
+
+    @property
+    def relay_url(self) -> str:
+        return self.uri_info.relay
+
+    def _encrypt(self, plaintext: str) -> str:
+        if self.encryption_mode == 'nip44':
+            conv = nip44.conversation_key(self.secret, self.wallet_pubkey)
+            return nip44.encrypt(plaintext, conv)
+        return nip04_encrypt(plaintext, self.secret, self.wallet_pubkey)
+
+    def _decrypt(self, ciphertext: str) -> str:
+        if self.encryption_mode == 'nip44':
+            conv = nip44.conversation_key(self.secret, self.wallet_pubkey)
+            return nip44.decrypt(ciphertext, conv)
+        return nip04_decrypt(ciphertext, self.secret, self.wallet_pubkey)
+
+    def call_method(self, method: str, params: Optional[Mapping[str, Any]] = None) -> Mapping[str, Any]:
+        """Send NIP-47 request (Kind 23194) and wait for response (Kind 23195)."""
+        req_payload = {
+            'method': method,
+            'params': params or {},
+        }
+        json_body = json.dumps(req_payload, separators=(',', ':'))
+        ciphertext = self._encrypt(json_body)
+
+        now = int(time.time())
+        tags = [['p', self.wallet_pubkey]]
+        req_event = store_mod.make_signed_event(
+            self.secret,
+            now,
+            NWC_REQUEST_KIND,
+            tags,
+            ciphertext,
+        )
+        req_id = req_event['id']
+
+        if not self.relay_url:
+            raise NWCError("no relay URL configured in NWC URI")
+
+        # Publish request to relay and listen for response
+        r = relay.Relay(self.relay_url, timeout=self.timeout)
+        try:
+            r.connect()
+
+            # Subscribe to response first so ephemeral response is never missed
+            f = {
+                'kinds': [NWC_RESPONSE_KIND],
+                'authors': [self.wallet_pubkey],
+                '#p': [self.client_pubkey],
+                '#e': [req_id],
+            }
+            sub_id = r.subscribe([f], ready=True)
+
+            # Publish request to relay
+            r.publish(req_event)
+
+            resp_event: Optional[NostrEvent] = None
+            deadline = time.time() + self.timeout
+
+            for ev in r.events(sub_id, until=deadline):
+                if ev.get('kind') == NWC_RESPONSE_KIND:
+                    tags_map = {t[0]: t[1] for t in ev.get('tags', []) if len(t) > 1}
+                    if tags_map.get('e') == req_id:
+                        resp_event = ev
+                        break
+
+            if resp_event is None:
+                raise NWCError(f"timeout waiting for NWC response (method {method!r})")
+
+            # Decrypt response content
+            raw_resp = self._decrypt(resp_event.get('content', ''))
+            resp_data = json.loads(raw_resp)
+
+            if resp_data.get('error'):
+                err = resp_data['error']
+                msg_err = err.get('message') or err.get('code') or str(err)
+                raise NWCError(f"NWC error: {msg_err}")
+
+            return resp_data.get('result', {})
+
+        finally:
+            try:
+                r.close()
+            except OSError:
+                pass  # best-effort close of a relay socket that may already be gone
+
+    def pay_invoice(self, invoice: str, amount_msat: Optional[int] = None) -> NwcPayResult:
+        """Pay a Bolt11 Lightning invoice via NWC. Returns {'preimage': '...', 'fees_paid': ...}."""
+        params: NwcPayParams = {'invoice': invoice}
+        if amount_msat:
+            params['amount'] = amount_msat
+        return cast(NwcPayResult, self.call_method('pay_invoice', params))
+
+    def make_invoice(self, amount_msat: int, description: str = '', expiry: int = 3600) -> NwcMakeInvoiceResult:
+        """Generate a Bolt11 Lightning invoice via NWC. Returns {'invoice': '...', 'payment_hash': '...'}."""
+        params = {
+            'amount': amount_msat,
+            'description': description,
+            'expiry': expiry,
+        }
+        return cast(NwcMakeInvoiceResult, self.call_method('make_invoice', params))
+
+    def lookup_invoice(self, payment_hash: Optional[str] = None, invoice: Optional[str] = None) -> NwcLookupInvoiceResult:
+        """Check status of invoice via payment_hash or bolt11 string."""
+        params: NwcLookupParams = {}
+        if payment_hash:
+            params['payment_hash'] = payment_hash
+        if invoice:
+            params['invoice'] = invoice
+        return cast(NwcLookupInvoiceResult, self.call_method('lookup_invoice', params))
+
+    def get_balance(self) -> NwcBalanceResult:
+        """Query wallet balance in msats. Returns {'balance': int}."""
+        return cast(NwcBalanceResult, self.call_method('get_balance'))
+
+
+# ---------------------------------------------------------------------------
+# NWC Payment Rail Adapter
+# ---------------------------------------------------------------------------
+
+class NWCLightningPaymentRail(payment.PaymentRail):
+    """PaymentRail adapter backed by a live Nostr Wallet Connect (NWC) gateway.
+    The escrow state machine is the base class's; this rail's own I/O is
+    asking the wallet for an invoice and paying out over NWC."""
+
+    rail_id: str = 'nwc'
+
+    def __init__(self, nwc_client: NWCClient) -> None:
+        super().__init__()
+        self.client: NWCClient = nwc_client
+
+    def create_hold_invoice(
+        self,
+        amount_msat: int,
+        payment_hash: str,
+        expiry: int = 3600,
+        description: str = 'fleetmesh-nwc-compute',
+    ) -> payment.HoldInvoice:
+        """Request a wallet invoice and register the hold escrow keyed to payment_hash.
+
+        A wallet failure raises NWCError and registers nothing: an escrow
+        nobody can pay must not sit in CREATED looking like one awaiting
+        payment (the old code swallowed the error and stored invoice=None).
+        """
+        inv = self._new_invoice(amount_msat, payment_hash, expiry, description)
+        try:
+            res = self.client.make_invoice(amount_msat=amount_msat, description=description, expiry=expiry)
+        except NWCError:
+            raise
+        except Exception as e:
+            raise NWCError(f'make_invoice failed: {e}') from e
+        if not res.get('invoice'):
+            raise NWCError('make_invoice returned no invoice')
+        inv.invoice = res.get('invoice')
+        if res.get('payment_hash'):
+            inv.wallet_payment_hash = res['payment_hash'].lower()
+        return self._register(inv)
+
+    def pay_and_settle(self, payment_hash: str, bolt11: str) -> NwcPayResult:
+        """Trigger outbound Lightning payment via NWC and unlock escrow with returned preimage."""
+        h = payment_hash.lower()
+        res = self.client.pay_invoice(bolt11)
+        preimage = res.get('preimage', '')
+        if preimage:
+            self.settle_payment(h, preimage)
+        return res
+
+
+# ---------------------------------------------------------------------------
+# Cashu HTTP Mint REST Client (NUT-00, NUT-03, NUT-04, NUT-05)
+# ---------------------------------------------------------------------------
+
+class CashuMintError(Exception):
+    pass
+
+
+class CashuHttpClient:
+    """REST Client for standard Cashu mints (v1 API)."""
+
+    def __init__(self, mint_url: str = DEFAULT_MINT_URL, timeout: float = 10.0) -> None:
+        self.mint_url: str = mint_url.rstrip('/')
+        self.timeout: float = timeout
+
+    def _request(self, method: str, endpoint: str, body: Optional[Mapping[str, Any]] = None) -> Mapping[str, Any]:
+        url = f"{self.mint_url}{endpoint}"
+        data = json.dumps(body).encode('utf-8') if body is not None else None
+        headers = {'Content-Type': 'application/json'} if body is not None else {}
+
+        # The mint URL is operator configuration, never taken from a peer or
+        # a job, so the address policy is off (allow_private=True): many
+        # operators run their own mint on loopback or a LAN box. The byte cap
+        # and scheme check still apply -- a mint answer is small JSON.
+        try:
+            resp_bytes, _ = netfetch.fetch(
+                url,
+                max_bytes=MINT_MAX_RESPONSE_BYTES,
+                timeout=self.timeout,
+                method=method,
+                data=data,
+                headers=headers,
+                allow_private=True,
+            )
+        except netfetch.FetchHTTPError as e:
+            err_text = e.body.decode('utf-8', errors='replace')
+            try:
+                err_json = json.loads(err_text)
+                detail = err_json.get('detail') or err_json.get('error') or err_text
+            except Exception:
+                detail = err_text
+            raise CashuMintError(f"mint HTTP {e.code}: {detail}")
+        except netfetch.FetchError as e:
+            raise CashuMintError(f"mint connection error: {e}")
+        if not resp_bytes:
+            return {}
+        try:
+            return json.loads(resp_bytes.decode('utf-8'))
+        except (ValueError, UnicodeDecodeError) as e:
+            raise CashuMintError(f"mint returned malformed JSON: {e}")
+
+    def get_info(self) -> MintInfoResult:
+        """GET /v1/info: Mint capabilities and supported NUTs."""
+        return cast(MintInfoResult, self._request('GET', '/v1/info'))
+
+    def get_keys(self) -> MintKeysResult:
+        """GET /v1/keys: Mint active keysets."""
+        return cast(MintKeysResult, self._request('GET', '/v1/keys'))
+
+    def request_mint_quote(self, amount_sat: int, unit: str = 'sat') -> MintQuoteResult:
+        """POST /v1/mint/quote/bolt11: Request quote to deposit satoshis."""
+        return cast(MintQuoteResult, self._request('POST', '/v1/mint/quote/bolt11', {'amount': amount_sat, 'unit': unit}))
+
+    def check_mint_quote(self, quote_id: str) -> MintQuoteResult:
+        """GET /v1/mint/quote/bolt11/{quote_id}: Check if quote was paid."""
+        return cast(MintQuoteResult, self._request('GET', f"/v1/mint/quote/bolt11/{quote_id}"))
+
+    def mint_tokens(self, quote_id: str, outputs: Sequence[BlindedMessage]) -> SwapResult:
+        """POST /v1/mint/bolt11: Issue blinded signatures after quote payment."""
+        return cast(SwapResult, self._request('POST', '/v1/mint/bolt11', {'quote': quote_id, 'outputs': list(outputs)}))
+
+    def request_melt_quote(self, invoice: str, unit: str = 'sat') -> MeltQuoteResult:
+        """POST /v1/melt/quote/bolt11: Quote to melt ecash into paying a Lightning invoice."""
+        return cast(MeltQuoteResult, self._request('POST', '/v1/melt/quote/bolt11', {'request': invoice, 'unit': unit}))
+
+    def melt_tokens(self, quote_id: str, inputs: Sequence[CashuProof]) -> MeltQuoteResult:
+        """POST /v1/melt/bolt11: Spend ecash proofs to pay a Lightning invoice."""
+        return cast(MeltQuoteResult, self._request('POST', '/v1/melt/bolt11', {'quote': quote_id, 'inputs': list(inputs)}))
+
+    def swap_tokens(self, inputs: Sequence[CashuProof], outputs: Sequence[BlindedMessage]) -> SwapResult:
+        """POST /v1/swap: Atomic swap of input proofs for fresh output blinded secrets."""
+        return cast(SwapResult, self._request('POST', '/v1/swap', {'inputs': list(inputs), 'outputs': list(outputs)}))
+
+    def check_state(self, ys: Sequence[str]) -> CheckStateResult:
+        """POST /v1/checkstate (NUT-07): the mint's own word on whether each
+        proof, named by Y = hash_to_curve(secret), is UNSPENT, PENDING or SPENT.
+        A proof the mint does not know is reported SPENT-equivalent by most
+        implementations; either way it is not UNSPENT and is not payment."""
+        return cast(CheckStateResult, self._request('POST', '/v1/checkstate', {'Ys': list(ys)}))
+
+    def proofs_unspent(self, proofs: Sequence[CashuProof]) -> bool:
+        """`ProofVerifier` for `verify_nutzap_event`: every proof is UNSPENT at the mint."""
+        ys = [point_to_hex(hash_to_curve(p['secret'])) for p in proofs]
+        res = self.check_state(ys)
+        states = {s.get('Y'): s.get('state') for s in res.get('states', []) if isinstance(s, dict)}
+        return all(states.get(y) == 'UNSPENT' for y in ys)
+
+
+# ---------------------------------------------------------------------------
+# Live Cashu Payment Rail Adapter
+# ---------------------------------------------------------------------------
+
+class LiveCashuPaymentRail(payment.CashuPaymentRail):
+    """CashuPaymentRail with live HTTP mint verification and token swaps."""
+
+    def __init__(
+        self,
+        mint_url: str = DEFAULT_MINT_URL,
+        mint_privkey_hex: Optional[str] = None,
+        http_client: Optional[CashuHttpClient] = None,
+        spent: Optional[payment.SpentProofs] = None,
+    ) -> None:
+        self.http: CashuHttpClient = http_client or CashuHttpClient(mint_url=mint_url)
+        # Not being the mint, this rail's proof policy is "ask the mint"
+        # (NUT-07 check-state) - never "take the payer's word".
+        super().__init__(mint_url=mint_url, mint_privkey_hex=mint_privkey_hex, spent=spent,
+                         proof_verifier=self.http.proofs_unspent)
+
+    def swap_and_settle(self, payment_hash: str, new_outputs: Sequence[BlindedMessage]) -> SwapResult:
+        """Swap held proofs for newly blinded proofs at the live mint to prevent double-spending.
+        HELD -> SETTLED through the base state machine; raises IllegalTransition
+        (a ValueError) for any other state, and the escrow stays HELD if the
+        mint refuses the swap."""
+        with self._lock:
+            inv = self._escrow_for(payment_hash, 'SETTLED')
+            self._check_transition(inv, ('HELD',), 'SETTLED')
+            proofs = inv.proofs
+            if not proofs:
+                raise payment.PaymentError("no proofs held in escrow")
+
+            # Execute live swap
+            swap_res = self.http.swap_tokens(inputs=proofs, outputs=new_outputs)
+            self._settle_io(inv, '')
+            self._transition(inv, ('HELD',), 'SETTLED')
+            inv.swapped_at = inv.settled_at
+            inv.new_signatures = list(swap_res.get('signatures', []))
+            return swap_res
+
+    def melt_to_lightning(self, payment_hash: str, bolt11: str) -> MeltQuoteResult:
+        """Melt held ecash proofs to pay an external Lightning invoice.
+        HELD -> SETTLED only when the mint reports the invoice paid."""
+        with self._lock:
+            inv = self._escrow_for(payment_hash, 'SETTLED')
+            self._check_transition(inv, ('HELD',), 'SETTLED')
+
+            proofs = inv.proofs
+            quote_res = self.http.request_melt_quote(invoice=bolt11)
+            quote_id = quote_res.get('quote')
+            if not isinstance(quote_id, str) or not quote_id:
+                # A melt without a quote id would be a blind spend; refuse rather
+                # than send the mint an empty reference.
+                raise payment.PaymentError('mint melt quote response carried no quote id')
+
+            melt_res = self.http.melt_tokens(quote_id=quote_id, inputs=proofs)
+            if melt_res.get('paid'):
+                preimage = str(melt_res.get('payment_preimage', ''))
+                self._settle_io(inv, preimage)
+                self._transition(inv, ('HELD',), 'SETTLED')
+                inv.preimage = preimage
+            return melt_res