weed-cli 0.1.0__py3-none-any.whl

dht.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+dht.py — real Kademlia DHT discovery, no relay involved.
+
+Uses the real `kademlia` library (pip install kademlia) rather than
+reimplementing Kademlia's node-ID/k-bucket/RPC machinery — that's exactly
+the kind of already-solved distributed-systems problem worth reusing, not
+rebuilding, especially for a PoC.
+
+Scoped deliberately: this answers "how do two nodes find each other
+without a shared relay" — announce(content_hash, host_addr) /
+lookup(content_hash) — not the richer signed-event system (publish/like/
+subscribe/attestation) discovery_relay.py already handles. Merging that
+into DHT value storage is a separate, bigger design question (Kademlia's
+plain key→value store isn't naturally an append-only event log); kept out
+of this file on purpose. Every DHT node is a full peer — there's no
+separate "relay" role here, only who happened to join first.
+"""
+import asyncio
+import json
+import threading
+
+from kademlia.network import Server
+
+
+async def _announce(server, content_hash, host_addr, title=None):
+    """Merge this announcer into the existing list under content_hash
+    instead of overwriting it — multiple peers can host the same content,
+    and a blind set() would silently drop everyone else's announcement.
+    Not race-free under concurrent announces to the same key (last write
+    still wins on a true conflict) — a real CRDT merge is out of scope."""
+    existing_raw = await server.get(content_hash)
+    entries = json.loads(existing_raw) if existing_raw else []
+    entries = [e for e in entries if e.get('host') != host_addr]  # replace any stale self-entry
+    entries.append({'host': host_addr, 'title': title})
+    await server.set(content_hash, json.dumps(entries))
+
+
+async def _lookup(server, content_hash):
+    raw = await server.get(content_hash)
+    return json.loads(raw) if raw else []
+
+
+class DHTNode:
+    """Runs a real kademlia.network.Server in its own thread with its own
+    asyncio event loop, and exposes plain synchronous announce()/lookup()
+    methods any other thread (the shell, a CLI command) can call directly
+    — kademlia's Server is asyncio-only, but nothing else in this repo's
+    background-thread model (relay/host/web UI) is, so this is the
+    adapter, not a rewrite of everything else to asyncio."""
+
+    def __init__(self, port, bootstrap_nodes=None, quiet=False):
+        self.port = port
+        self.bootstrap_nodes = bootstrap_nodes or []
+        self.quiet = quiet
+        self.loop = None
+        self.server = None
+        self._ready = threading.Event()
+        self._error = None
+
+    def start(self):
+        t = threading.Thread(target=self._run, daemon=True)
+        t.start()
+        if not self._ready.wait(timeout=15):
+            raise RuntimeError('DHT node did not finish starting within 15s')
+        if self._error:
+            raise self._error
+        return t
+
+    def _run(self):
+        try:
+            self.loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self.loop)
+            self.server = Server()
+            self.loop.run_until_complete(self._setup())
+        except Exception as e:
+            self._error = e
+            self._ready.set()
+            return
+        self._ready.set()
+        self.loop.run_forever()
+
+    async def _setup(self):
+        await self.server.listen(self.port)
+        if self.bootstrap_nodes:
+            await self.server.bootstrap(self.bootstrap_nodes)
+        if not self.quiet:
+            joined = f', bootstrapped via {self.bootstrap_nodes}' if self.bootstrap_nodes else \
+                     ' (first node in a new swarm)'
+            print(f'[dht:{self.port}] node listening{joined}', flush=True)
+
+    def announce(self, content_hash, host_addr, title=None, timeout=15):
+        fut = asyncio.run_coroutine_threadsafe(
+            _announce(self.server, content_hash, host_addr, title), self.loop)
+        return fut.result(timeout=timeout)
+
+    def lookup(self, content_hash, timeout=15):
+        fut = asyncio.run_coroutine_threadsafe(_lookup(self.server, content_hash), self.loop)
+        return fut.result(timeout=timeout)
+
+    def stop(self):
+        if self.loop and self.server:
+            self.loop.call_soon_threadsafe(self.server.stop)
+            self.loop.call_soon_threadsafe(self.loop.stop)
+
+
+def run_dht_node(port, bootstrap_nodes=None, quiet=False):
+    """Blocking entry point, same contract as run_relay_server/
+    run_host_server — call this directly for a foreground CLI process, or
+    hand it to threading.Thread(target=...) to run in the background."""
+    node = DHTNode(port, bootstrap_nodes=bootstrap_nodes, quiet=quiet)
+    t = threading.Thread(target=node._run, daemon=True)
+    t.start()
+    t.join()
+
+
+def _parse_bootstrap(spec):
+    """'host:port' or 'host:port,host:port' -> [(host, port), ...], or
+    None if spec is falsy."""
+    if not spec:
+        return None
+    out = []
+    for part in spec.split(','):
+        host, port_s = part.rsplit(':', 1)
+        out.append((host, int(port_s)))
+    return out
+
+
+def main():
+    import sys
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 8468
+    bootstrap = _parse_bootstrap(sys.argv[2]) if len(sys.argv) > 2 else None
+    run_dht_node(port, bootstrap_nodes=bootstrap)
+
+
+if __name__ == '__main__':
+    main()

discovery_relay.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+Roadmap item 8: discovery. The design from the brainstorm was "no single
+canonical index — gossiped signed events, any number of independent
+replaceable relays, personalized ranking client-side," Nostr-style. This is
+that, actually built and running, not just described.
+
+A relay here is deliberately dumb: real stdlib HTTP server, verifies a
+posted event's signature (cheap, uncontroversial — garbage in doesn't get
+stored) but has NO opinion on content quality, no ranking, no single
+"trending" list. It just stores what it's given and serves it back on
+request. That's the whole point: any number of these can run independently,
+none of them are load-bearing on their own, and a client is expected to
+query several and merge — see poc_discovery.py for the client side.
+
+Event shapes (all just signed JSON blobs, reusing poc_reputation.py's
+Ed25519 signing):
+  publish    {content_hash, title}                — a creator announces content
+  like       {content_hash}                        — a viewer signals approval
+  subscribe  {target_pubkey}                        — a viewer follows a creator/signer
+"""
+import json
+import sys
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlparse, parse_qs
+
+sys.path.insert(0, __import__('os').path.dirname(__import__('os').path.abspath(__file__)))
+from poc_reputation import verify_attestation, attestation_id
+
+_events = []  # in-memory store — a real relay would use a real DB; irrelevant to the design
+
+
+class RelayHandler(BaseHTTPRequestHandler):
+    def log_message(self, fmt, *args):
+        pass  # quiet — poc_discovery.py prints what matters
+
+    def do_POST(self):
+        if self.path != '/event':
+            self.send_response(404); self.end_headers(); return
+        length = int(self.headers.get('Content-Length', 0))
+        try:
+            event = json.loads(self.rfile.read(length))
+            ok, reason = verify_attestation(event)  # generic: works on any {payload, signature} blob
+        except Exception as e:
+            ok, reason = False, f'malformed request: {e}'
+        if not ok:
+            self.send_response(400)
+            self.send_header('Content-Type', 'application/json')
+            self.end_headers()
+            self.wfile.write(json.dumps({'ok': False, 'reason': reason}).encode())
+            return
+        eid = attestation_id(event)
+        if not any(attestation_id(e) == eid for e in _events):
+            _events.append(event)
+        self.send_response(200)
+        self.send_header('Content-Type', 'application/json')
+        self.end_headers()
+        self.wfile.write(json.dumps({'ok': True, 'event_id': eid}).encode())
+
+    def do_GET(self):
+        if self.path.split('?')[0] != '/events':
+            self.send_response(404); self.end_headers(); return
+        qs = parse_qs(urlparse(self.path).query)
+        out = _events
+        if 'type' in qs:
+            out = [e for e in out if e['payload'].get('type') == qs['type'][0]]
+        self.send_response(200)
+        self.send_header('Content-Type', 'application/json')
+        self.end_headers()
+        self.wfile.write(json.dumps(out).encode())
+
+
+def run_relay_server(port, quiet=False):
+    """Split out from main() so shell.py can run a relay in a background
+    thread — same pattern as node.run_host_server. quiet=True for the shell:
+    a background thread's print() races with cmd.Cmd's input()-driven
+    prompt on the same stdout with no coordination between them — readline
+    doesn't know to redraw the prompt when unrelated output shows up mid-
+    read, so the two interleave and the prompt looks like it "disappeared."
+    The shell already prints its own equivalent confirmation line, so this
+    fixes it at the source instead of patching the visual symptom."""
+    srv = ThreadingHTTPServer(('0.0.0.0', port), RelayHandler)
+    if not quiet:
+        print(f"[relay:{port}] up, no opinion on content, just store-and-forward", flush=True)
+    srv.serve_forever()
+
+
+def main():
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 9101
+    run_relay_server(port)
+
+
+if __name__ == '__main__':
+    main()

lightning_settle.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+Real Lightning HTLC settlement, replacing poc_challenge_auction.py's mock
+"settlement: mock Lightning HTLC held until delivery confirms" print.
+
+Talks to two real LND nodes (lnd-alice, lnd-bob — see lightning/docker-compose.yml)
+over a real channel on regtest via `docker exec ... lncli`. Not simulated:
+real BOLT11 invoices, real onion-routed HTLCs, real preimage reveal on
+settlement — same protocol code LND runs on mainnet, just against a private
+regtest chain instead of waiting on public testnet sync/faucets (same
+reasoning as using a real remote box over SSH for the WAN latency test
+rather than a fabricated one).
+
+Requires the compose stack in lightning/ to be up with a funded, active
+channel between alice and bob (see lightning/README.md for the one-time
+setup: fund alice on-chain, open channel, confirm).
+"""
+import hashlib
+import json
+import subprocess
+
+ALICE_CONTAINER = 'lightning-lnd-alice-1'  # payer — stands in for the requester/viewer
+BOB_CONTAINER = 'lightning-lnd-bob-1'      # payee — stands in for the auction winner
+LNDDIR = '/home/lnd/.lnd'
+
+
+class SettlementError(RuntimeError):
+    pass
+
+
+def _lncli(container, *args):
+    cmd = ['docker', 'exec', container, 'lncli', '--network=regtest', f'--lnddir={LNDDIR}', *args]
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+    if result.returncode != 0:
+        raise SettlementError(f'lncli {args[0]} failed: {result.stderr.strip()}')
+    return json.loads(result.stdout)
+
+
+def channel_active():
+    try:
+        chans = _lncli(ALICE_CONTAINER, 'listchannels')
+    except (SettlementError, FileNotFoundError):
+        return False
+    return any(c.get('active') for c in chans.get('channels', []))
+
+
+def settle(amount_sat, memo):
+    """Real HTLC settlement for one auction round's winning bid.
+
+    Bob (payee/winner) creates a real BOLT11 invoice; Alice (payer/
+    requester) pays it over the real channel. Returns a dict with the real
+    payment_hash, the real revealed preimage, and independently re-verifies
+    sha256(preimage) == payment_hash locally rather than trusting LND's own
+    claim of success — same "verify, don't just trust the tool's own report"
+    standard the rest of this project has used throughout.
+    """
+    amount_sat = max(1, int(round(amount_sat)))
+    invoice = _lncli(BOB_CONTAINER, 'addinvoice', f'--amt={amount_sat}', f'--memo={memo}')
+    payment_request = invoice['payment_request']
+    expected_hash = invoice['r_hash']
+
+    payment = _lncli(ALICE_CONTAINER, 'payinvoice', '--force', '--json', payment_request)
+    if payment.get('status') != 'SUCCEEDED':
+        raise SettlementError(f'payment did not succeed: {payment.get("status")}')
+
+    preimage = payment['payment_preimage']
+    recomputed_hash = hashlib.sha256(bytes.fromhex(preimage)).hexdigest()
+    if recomputed_hash != expected_hash:
+        raise SettlementError(
+            f'preimage does not match invoice payment_hash — '
+            f'got {recomputed_hash}, expected {expected_hash}')
+
+    return {
+        'amount_sat': amount_sat,
+        'payment_hash': expected_hash,
+        'preimage': preimage,
+        'fee_sat': int(payment.get('fee_sat', 0)),
+        'verified_locally': True,
+    }
+
+
+if __name__ == '__main__':
+    # smoke test — run directly to confirm the channel is up before wiring
+    # it into the auction
+    if not channel_active():
+        print('no active channel found — bring up lightning/docker-compose.yml first')
+        raise SystemExit(1)
+    result = settle(1234, 'lightning_settle.py smoke test')
+    print(json.dumps(result, indent=2))
+    print('\npreimage independently re-hashed and matched the invoice payment_hash — real HTLC, verified.')