deadman-fm 0.1.4 → 0.1.5

package/dist/commands/create.d.ts

@@ -12,6 +12,10 @@ interface CreateOptions {
     genre: string;
     music: string;
     watch?: boolean;
+    /** On-chain station ID — required to ping the heartbeat contract. */
+    stationId?: number;
+    /** Hex private key (0x-prefixed) for the station creator wallet. */
+    privateKey?: string;
 }
 export declare function createStation(opts: CreateOptions): Promise<void>;
 export {};

package/dist/commands/create.js

@@ -15,6 +15,7 @@ import { homedir } from "node:os";
 import { mkdirSync, writeFileSync } from "node:fs";
 import Hypercore from "hypercore";
 import Hyperswarm from "hyperswarm";
+import { pingHeartbeat } from "../node/heartbeat.js";
 const AUDIO_EXTS = new Set([
     ".mp3",
     ".wav",
@@ -88,6 +89,14 @@ export async function createStation(opts) {
     console.log(`   Feed key: ${core.key.toString("hex")}`);
     console.log(`   ${totalSegments} segments on the network`);
     console.log(`\n   Press Ctrl+C to stop seeding`);
+    // Ping the on-chain heartbeat to reset the 7-day dead man's switch
+    if (opts.stationId !== undefined) {
+        await pingHeartbeat(opts.stationId, totalSegments, opts.privateKey);
+    }
+    else {
+        console.warn("\n   ⚠️  Heartbeat NOT pinged — no stationId provided.");
+        console.warn("      Pass --station-id <ID> to auto-ping after syncing.");
+    }
     // Watch mode
     if (opts.watch) {
         console.log(`   👁  Watching ${musicPath} for new files...`);
@@ -106,6 +115,10 @@ export async function createStation(opts) {
             meta.totalSegments = totalSegments;
             writeFileSync(join(stationDir, "station.json"), JSON.stringify(meta, null, 2));
             console.log(`      → ${segments} segments (total: ${totalSegments})`);
+            // Re-ping heartbeat whenever new content is synced
+            if (opts.stationId !== undefined) {
+                await pingHeartbeat(opts.stationId, totalSegments, opts.privateKey);
+            }
         });
     }
     // Keep alive

package/dist/commands/interactive.js

@@ -110,6 +110,44 @@ function loadLocalStations() {
     }
     return results;
 }
+async function fetchMyStationsFromChain(walletAddress) {
+    const { createPublicClient, http, parseAbiItem } = await import("viem");
+    const { base } = await import("viem/chains");
+    const REGISTRY = "0x3b9b6c9BBa15173ba4EF544c17Cb2Ba969d8b585";
+    const DEPLOY_BLOCK = 43856547n;
+    const client = createPublicClient({
+        chain: base,
+        transport: http("https://mainnet.base.org"),
+    });
+    const event = parseAbiItem("event StationCreated(uint256 indexed stationId, address indexed creator, string name, bytes32 genre, bytes32 hypercorePubKey, address curve)");
+    const CHUNK = 9500n;
+    const currentBlock = await client.getBlockNumber();
+    const allLogs = [];
+    let from = DEPLOY_BLOCK;
+    while (from <= currentBlock) {
+        const to = from + CHUNK > currentBlock ? currentBlock : from + CHUNK;
+        const chunk = await client.getLogs({
+            address: REGISTRY,
+            event,
+            fromBlock: from,
+            toBlock: to,
+        });
+        allLogs.push(...chunk);
+        from = to + 1n;
+    }
+    return allLogs
+        .filter((log) => log.args.creator?.toLowerCase() === walletAddress.toLowerCase())
+        .map((log) => ({
+        id: log.args.stationId?.toString() ?? "0",
+        name: log.args.name ?? "Unnamed",
+        genre: log.args.genre
+            ? Buffer.from(log.args.genre.replace(/^0x/, ""), "hex")
+                .toString("utf8")
+                .replace(/\0/g, "")
+            : "Other",
+        creator: log.args.creator ?? "0x0",
+    }));
+}
 // ---------------------------------------------------------------------------
 // Keychain helpers
 // ---------------------------------------------------------------------------
@@ -206,6 +244,16 @@ function checkRelay() {
         return false;
     }
 }
+function checkDaemon() {
+    try {
+        const out = execSync("curl -sf http://localhost:9999/health --max-time 2 2>/dev/null", { encoding: "utf8" }).trim();
+        const data = JSON.parse(out);
+        return { up: data.ok, stations: data.stations, block: data.block };
+    }
+    catch {
+        return { up: false };
+    }
+}
 function checkLocalLink() {
     try {
         const out = execSync("pgrep -f 'deadman' 2>/dev/null || true", {
@@ -251,12 +299,12 @@ export async function interactive() {
                 {
                     value: "create",
                     label: "Start Mining",
-                    hint: "point to your music, start earning $FM",
+                    hint: "sync music to your station, start earning $FM",
                 },
                 {
-                    value: "sync",
-                    label: "Sync Music",
-                    hint: "add or update tracks on your station",
+                    value: "node",
+                    label: "Run Node",
+                    hint: "serve the heartbeat API, earn $FM",
                 },
                 {
                     value: "connect",
@@ -267,7 +315,7 @@ export async function interactive() {
                 {
                     value: "status",
                     label: "Check status",
-                    hint: "relay, speaker, wallet",
+                    hint: "node, speaker, wallet",
                 },
                 { value: "exit", label: "Exit" },
             ],
@@ -280,8 +328,8 @@ export async function interactive() {
             case "create":
                 await handleCreate();
                 break;
-            case "sync":
-                await handleSync();
+            case "node":
+                await handleNode();
                 break;
             case "connect":
                 await handleConnect();
@@ -299,9 +347,50 @@ export async function interactive() {
 // Option 1 — Create a station
 // ---------------------------------------------------------------------------
 async function handleCreate() {
-    const stations = loadLocalStations();
-    if (stations.length === 0) {
-        p.log.warn("You don't own a station yet.");
+    // First check: do we have a saved wallet?
+    let wallet = loadSavedWallet();
+    if (!wallet) {
+        const rawWallet = await p.text({
+            message: "Your wallet address (the one that created your stations)",
+            placeholder: "0x...",
+            validate: (val) => {
+                if (!val?.match(/^0x[a-fA-F0-9]{40}$/))
+                    return "Must be a valid Ethereum address";
+            },
+        });
+        guardCancel(rawWallet);
+        wallet = rawWallet.trim();
+        // Save for next time
+        const configDir = join(homedir(), ".deadman-fm");
+        const configPath = join(configDir, "config.json");
+        try {
+            const { mkdirSync, writeFileSync } = await import("node:fs");
+            mkdirSync(configDir, { recursive: true });
+            const existing = existsSync(configPath)
+                ? JSON.parse(readFileSync(configPath, "utf8"))
+                : {};
+            existing.walletAddress = wallet;
+            writeFileSync(configPath, JSON.stringify(existing, null, 2));
+        }
+        catch {
+            /* non-critical */
+        }
+    }
+    // Check chain for stations owned by this wallet
+    const chainSpinner = p.spinner();
+    chainSpinner.start("Checking Base chain for your stations...");
+    let chainStations = [];
+    try {
+        chainStations = await fetchMyStationsFromChain(wallet);
+    }
+    catch (err) {
+        chainSpinner.stop("Chain query failed");
+        p.log.error(`Could not reach Base chain: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    chainSpinner.stop(`Found ${chainStations.length} station${chainStations.length === 1 ? "" : "s"} on chain`);
+    if (chainStations.length === 0) {
+        p.log.warn("No stations found for this wallet.");
         p.log.info("Win one in the daily emoji auction at deadman.fm");
         const openAuction = await p.confirm({
             message: "Open the auction page?",
@@ -324,50 +413,36 @@ async function handleCreate() {
         }
         return;
     }
-    // Has stations — go straight to sync
-    p.log.success(`You own ${stations.length} station${stations.length === 1 ? "" : "s"}. Let's sync music.`);
-    await handleSync();
-}
-// ---------------------------------------------------------------------------
-// Option 2 — Sync music (standalone entry point)
-// ---------------------------------------------------------------------------
-async function handleSync() {
-    const stations = loadLocalStations();
-    if (stations.length === 0) {
-        p.log.warn("You don't own a station yet.");
-        p.log.info("Win one in the daily auction at deadman.fm");
-        return;
-    }
+    // Has stations on chain — pick one and sync
     let stationName;
-    let stationId = null;
-    if (stations.length === 1) {
-        stationName = stations[0].meta.name;
-        stationId = stations[0].meta.stationId ?? null;
-        p.log.info(`Using station: ${stationName}`);
+    let stationId;
+    let genre;
+    if (chainStations.length === 1) {
+        stationName = chainStations[0].name;
+        stationId = parseInt(chainStations[0].id, 10);
+        genre = chainStations[0].genre;
+        p.log.info(`Using station: ${stationName} (#${stationId})`);
     }
     else {
         const selected = await p.select({
             message: "Which station?",
-            options: stations.map(({ meta }) => ({
-                value: meta.name,
-                label: meta.name,
-                hint: meta.stationId !== undefined
-                    ? `#${meta.stationId} · ${meta.genre}`
-                    : meta.genre,
+            options: chainStations.map((s) => ({
+                value: s.id,
+                label: s.name,
+                hint: `#${s.id} · ${s.genre}`,
             })),
         });
         guardCancel(selected);
-        const found = stations.find((s) => s.meta.name === selected);
-        stationName = found?.meta.name ?? selected;
-        stationId = found?.meta.stationId ?? null;
+        const found = chainStations.find((s) => s.id === selected);
+        stationName = found.name;
+        stationId = parseInt(found.id, 10);
+        genre = found.genre;
     }
-    await handleSyncForStation(stationName, stationId);
+    // Go straight to sync with the selected chain station
+    await handleSyncForStation(stationName, stationId, genre);
 }
-// ---------------------------------------------------------------------------
-// Shared sync logic
-// ---------------------------------------------------------------------------
-async function handleSyncForStation(stationName, stationId) {
-    const idLabel = stationId !== null ? `#${stationId}` : `"${stationName}"`;
+async function handleSyncForStation(stationName, stationId, genre) {
+    const idLabel = `#${stationId}`;
     const rawPath = await p.text({
         message: "Path to music folder",
         placeholder: "~/Music",
@@ -418,10 +493,6 @@ async function handleSyncForStation(stationName, stationId) {
     const syncSpinner = p.spinner();
     syncSpinner.start(`Syncing ${tracks.length} tracks to ${idLabel}...`);
     const { createStation } = await import("./create.js");
-    const stations = loadLocalStations();
-    const found = stations.find((s) => s.meta.name === stationName ||
-        (stationId !== null && s.meta.stationId === stationId));
-    const genre = found?.meta.genre ?? "Electronic";
     const originalLog = console.log;
     let totalSegments = 0;
     let currentTrackIdx = 0;
@@ -463,7 +534,34 @@ async function handleSyncForStation(stationName, stationId) {
     await new Promise(() => { });
 }
 // ---------------------------------------------------------------------------
-// Option 3 — Connect to speaker
+// Option 3 — Run Node (daemon with heartbeat API)
+// ---------------------------------------------------------------------------
+async function handleNode() {
+    p.note("Your machine becomes a deadman.fm node.\nIt indexes the chain, serves the heartbeat API,\nand shares content with the P2P network.\n\nMiners who run nodes earn bonus $FM.", "Run Node");
+    const portInput = await p.text({
+        message: "API port",
+        placeholder: "9999",
+        initialValue: "9999",
+        validate: (val) => {
+            const n = parseInt(val ?? "", 10);
+            if (isNaN(n) || n < 1024 || n > 65535)
+                return "Port must be 1024-65535";
+        },
+    });
+    guardCancel(portInput);
+    const servePublic = await p.confirm({
+        message: "Serve to the public network? (peers can query your node)",
+        initialValue: false,
+    });
+    guardCancel(servePublic);
+    const port = parseInt(portInput, 10);
+    const bind = servePublic ? "0.0.0.0" : "127.0.0.1";
+    p.log.info(`Starting node on ${bind}:${port}...`);
+    const { startDaemon } = await import("../node/daemon.js");
+    await startDaemon({ port, public: servePublic });
+}
+// ---------------------------------------------------------------------------
+// Option 4 — Connect to speaker
 // ---------------------------------------------------------------------------
 async function handleConnect() {
     p.note('This links your Mac to your OpenHome speaker over WebSocket.\nOnce connected, say "deadman radio" on your speaker to control stations.', "Connect speaker");
@@ -573,12 +671,16 @@ async function handleList() {
 async function handleStatus() {
     const statusSpinner = p.spinner();
     statusSpinner.start("Checking status...");
+    const daemon = checkDaemon();
     const relayUp = checkRelay();
     const linkUp = checkLocalLink();
     const stations = loadLocalStations();
     const wallet = loadSavedWallet();
     const apiKey = await loadApiKey();
     statusSpinner.stop("Status");
+    const daemonLine = daemon.up
+        ? `Node daemon (:9999)      running (${daemon.stations ?? 0} stations, block ${daemon.block ?? 0})`
+        : "Node daemon (:9999)      not running — run 'Run Node' to start";
     const relayLine = `Relay (localhost:4040)   ${relayUp ? "running" : "not running"}`;
     const linkLine = `Speaker bridge          ${linkUp ? "connected" : "not running"}`;
     let stationLines;
@@ -598,5 +700,5 @@ async function handleStatus() {
         ? `Wallet                   ${wallet.slice(0, 6)}…${wallet.slice(-4)}`
         : "Wallet                   not saved";
     const apiLine = `OpenHome API key         ${apiKey ? "saved" : "not saved"}`;
-    p.note([relayLine, linkLine, stationLines, walletLine, apiLine].join("\n"), "System status");
+    p.note([daemonLine, relayLine, linkLine, stationLines, walletLine, apiLine].join("\n"), "System status");
 }

package/dist/index.js

@@ -47,6 +47,18 @@ program
     rl.close();
     await startLocalLink(key.trim());
 });
+program
+    .command("daemon")
+    .description("Run the deadman.fm node daemon (API + content serving)")
+    .option("--port <port>", "HTTP port", "9999")
+    .option("--public", "Bind to 0.0.0.0 (serve peers)")
+    .action(async (opts) => {
+    const { startDaemon } = await import("./node/daemon.js");
+    await startDaemon({
+        port: parseInt(opts.port, 10),
+        public: opts.public ?? false,
+    });
+});
 // No arguments = interactive mode
 if (process.argv.length <= 2) {
     interactive();

package/dist/node/daemon.d.ts

@@ -0,0 +1,29 @@
+/**
+ * deadman.fm — Cross-platform Node Daemon
+ *
+ * The actual protocol participant. YOUR MACHINE is the network.
+ *
+ * Replaces background.py with a single Node.js process that:
+ *   - Seeds content via Hypercore/Hyperswarm (P2P)
+ *   - Indexes chain events (stations, heartbeats)
+ *   - Serves the heartbeat API (decentralized, miner-hosted)
+ *   - Serves segments to peers and the OpenHome speaker
+ *   - Handles key exchange (on-chain verification)
+ *
+ * Cross-platform: Mac, Windows, Linux — anywhere Node.js runs.
+ * Zero Python dependency. Zero relay dependency.
+ *
+ * Usage:
+ *   import { startDaemon } from "./node/daemon.js";
+ *   await startDaemon({ port: 9999, stationId: "0" });
+ *
+ * Or via CLI:
+ *   deadman-fm --daemon --port 9999
+ */
+interface DaemonOptions {
+    port?: number;
+    public?: boolean;
+    stationId?: string;
+}
+export declare function startDaemon(opts?: DaemonOptions): Promise<void>;
+export {};

package/dist/node/daemon.js

@@ -0,0 +1,648 @@
+/**
+ * deadman.fm — Cross-platform Node Daemon
+ *
+ * The actual protocol participant. YOUR MACHINE is the network.
+ *
+ * Replaces background.py with a single Node.js process that:
+ *   - Seeds content via Hypercore/Hyperswarm (P2P)
+ *   - Indexes chain events (stations, heartbeats)
+ *   - Serves the heartbeat API (decentralized, miner-hosted)
+ *   - Serves segments to peers and the OpenHome speaker
+ *   - Handles key exchange (on-chain verification)
+ *
+ * Cross-platform: Mac, Windows, Linux — anywhere Node.js runs.
+ * Zero Python dependency. Zero relay dependency.
+ *
+ * Usage:
+ *   import { startDaemon } from "./node/daemon.js";
+ *   await startDaemon({ port: 9999, stationId: "0" });
+ *
+ * Or via CLI:
+ *   deadman-fm --daemon --port 9999
+ */
+import { createServer } from "node:http";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, } from "node:fs";
+import { createPublicClient, http, parseAbiItem } from "viem";
+import { base } from "viem/chains";
+// ─── Config ──────────────────────────────────────────────────────────────────
+const BASE_RPC = "https://mainnet.base.org";
+const REGISTRY_ADDRESS = "0x3b9b6c9BBa15173ba4EF544c17Cb2Ba969d8b585";
+const HEARTBEAT_ADDRESS = "0xB3D6f8FEeC79De2Bf4A1F6bF48f95e5B98D42163";
+const DEPLOY_BLOCK = 43856547n;
+const BLOCKS_PER_SEGMENT = 3;
+// Cross-platform data directory
+const DATA_DIR = join(homedir(), ".deadman-fm");
+const KEYS_DIR = join(DATA_DIR, "keys");
+const SEGMENTS_DIR = join(DATA_DIR, "segments");
+const CACHE_DIR = join(DATA_DIR, "cache");
+// Ensure directories exist
+for (const dir of [DATA_DIR, KEYS_DIR, SEGMENTS_DIR, CACHE_DIR]) {
+    mkdirSync(dir, { recursive: true });
+}
+// ─── Chain Client ────────────────────────────────────────────────────────────
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let client;
+function getClient() {
+    if (!client) {
+        client = createPublicClient({
+            chain: base,
+            transport: http(BASE_RPC),
+        });
+    }
+    return client;
+}
+// ─── Station Discovery (from chain) ─────────────────────────────────────────
+const stationCreatedEvent = parseAbiItem("event StationCreated(uint256 indexed stationId, address indexed creator, string name, bytes32 genre, bytes32 hypercorePubKey, address curve)");
+async function discoverStations() {
+    const c = getClient();
+    const currentBlock = await c.getBlockNumber();
+    const CHUNK = 9500n;
+    const stations = [];
+    let from = DEPLOY_BLOCK;
+    while (from <= currentBlock) {
+        const to = from + CHUNK > currentBlock ? currentBlock : from + CHUNK;
+        try {
+            const logs = await c.getLogs({
+                address: REGISTRY_ADDRESS,
+                event: stationCreatedEvent,
+                fromBlock: from,
+                toBlock: to,
+            });
+            for (const log of logs) {
+                const args = log.args;
+                const genre = args.genre
+                    ? Buffer.from(args.genre.replace(/^0x/, ""), "hex")
+                        .toString("utf8")
+                        .replace(/\0/g, "")
+                    : "Other";
+                stations.push({
+                    id: args.stationId?.toString() ?? "0",
+                    creator: args.creator ?? "0x0",
+                    name: args.name ?? "Unnamed",
+                    genre,
+                    blockNumber: Number(log.blockNumber),
+                });
+            }
+        }
+        catch {
+            // RPC error on chunk — skip and continue
+        }
+        from = to + 1n;
+    }
+    return stations;
+}
+// ─── Heartbeat Reads (from chain) ────────────────────────────────────────────
+const heartbeatABI = [
+    {
+        name: "isAlive",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "stationId", type: "uint256" }],
+        outputs: [{ name: "", type: "bool" }],
+    },
+    {
+        name: "isDead",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "stationId", type: "uint256" }],
+        outputs: [{ name: "", type: "bool" }],
+    },
+    {
+        name: "daysRemaining",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "stationId", type: "uint256" }],
+        outputs: [{ name: "", type: "uint256" }],
+    },
+    {
+        name: "daysUntilDeath",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "stationId", type: "uint256" }],
+        outputs: [{ name: "", type: "uint256" }],
+    },
+    {
+        name: "lastHeartbeat",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "stationId", type: "uint256" }],
+        outputs: [{ name: "", type: "uint256" }],
+    },
+    {
+        name: "emissionScale",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "stationId", type: "uint256" }],
+        outputs: [{ name: "", type: "uint256" }],
+    },
+    {
+        name: "contentSegments",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "stationId", type: "uint256" }],
+        outputs: [{ name: "", type: "uint256" }],
+    },
+];
+async function fetchHeartbeat(stationId) {
+    const c = getClient();
+    const sid = BigInt(stationId);
+    try {
+        const [alive, dead, daysLeft, daysUntilDeath, lastPing, scale, segments] = await Promise.all([
+            c.readContract({
+                address: HEARTBEAT_ADDRESS,
+                abi: heartbeatABI,
+                functionName: "isAlive",
+                args: [sid],
+            }),
+            c.readContract({
+                address: HEARTBEAT_ADDRESS,
+                abi: heartbeatABI,
+                functionName: "isDead",
+                args: [sid],
+            }),
+            c.readContract({
+                address: HEARTBEAT_ADDRESS,
+                abi: heartbeatABI,
+                functionName: "daysRemaining",
+                args: [sid],
+            }),
+            c.readContract({
+                address: HEARTBEAT_ADDRESS,
+                abi: heartbeatABI,
+                functionName: "daysUntilDeath",
+                args: [sid],
+            }),
+            c.readContract({
+                address: HEARTBEAT_ADDRESS,
+                abi: heartbeatABI,
+                functionName: "lastHeartbeat",
+                args: [sid],
+            }),
+            c.readContract({
+                address: HEARTBEAT_ADDRESS,
+                abi: heartbeatABI,
+                functionName: "emissionScale",
+                args: [sid],
+            }),
+            c.readContract({
+                address: HEARTBEAT_ADDRESS,
+                abi: heartbeatABI,
+                functionName: "contentSegments",
+                args: [sid],
+            }),
+        ]);
+        return {
+            stationId,
+            alive: alive,
+            dead: dead,
+            daysLeft: Number(daysLeft),
+            daysUntilDeath: Number(daysUntilDeath),
+            lastPing: Number(lastPing),
+            emissionScale: Number(scale),
+            contentSegments: Number(segments),
+        };
+    }
+    catch {
+        return {
+            stationId,
+            alive: false,
+            dead: false,
+            daysLeft: 0,
+            daysUntilDeath: 0,
+            lastPing: 0,
+            emissionScale: 0,
+            contentSegments: 0,
+        };
+    }
+}
+// ─── Key Persistence (cross-platform) ────────────────────────────────────────
+function saveStationKey(stationId, key) {
+    writeFileSync(join(KEYS_DIR, `${stationId}.key`), key, { mode: 0o600 });
+}
+function loadStationKey(stationId) {
+    const p = join(KEYS_DIR, `${stationId}.key`);
+    if (existsSync(p))
+        return readFileSync(p, "utf8").trim();
+    return null;
+}
+// ─── On-chain Access Verification ────────────────────────────────────────────
+const accessCache = new Map();
+const ACCESS_CACHE_TTL = 300_000; // 5 minutes
+async function verifyHasAccess(stationId, walletAddress) {
+    const cacheKey = `${stationId}:${walletAddress.toLowerCase()}`;
+    const cached = accessCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < ACCESS_CACHE_TTL) {
+        return cached.result;
+    }
+    const c = getClient();
+    try {
+        // Get station's bonding curve address
+        const curveAddr = await c.readContract({
+            address: REGISTRY_ADDRESS,
+            abi: [
+                {
+                    name: "getStationCurve",
+                    type: "function",
+                    stateMutability: "view",
+                    inputs: [{ name: "stationId", type: "uint256" }],
+                    outputs: [{ name: "", type: "address" }],
+                },
+            ],
+            functionName: "getStationCurve",
+            args: [BigInt(stationId)],
+        });
+        if (!curveAddr ||
+            curveAddr === "0x0000000000000000000000000000000000000000") {
+            accessCache.set(cacheKey, { result: false, timestamp: Date.now() });
+            return false;
+        }
+        // Check hasAccess on the bonding curve
+        const hasAccess = await c.readContract({
+            address: curveAddr,
+            abi: [
+                {
+                    name: "hasAccess",
+                    type: "function",
+                    stateMutability: "view",
+                    inputs: [{ name: "addr", type: "address" }],
+                    outputs: [{ name: "", type: "bool" }],
+                },
+            ],
+            functionName: "hasAccess",
+            args: [walletAddress],
+        });
+        accessCache.set(cacheKey, {
+            result: hasAccess,
+            timestamp: Date.now(),
+        });
+        return hasAccess;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Segment Serving ─────────────────────────────────────────────────────────
+function getLocalStationSegments(stationId) {
+    const stationsDir = join(DATA_DIR, "stations");
+    if (!existsSync(stationsDir))
+        return [];
+    // Find station feed directory
+    for (const slug of readdirSync(stationsDir)) {
+        const metaPath = join(stationsDir, slug, "station.json");
+        if (!existsSync(metaPath))
+            continue;
+        try {
+            const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+            if (String(meta.stationId) === stationId || meta.name === stationId) {
+                const segDir = join(stationsDir, slug, "segments");
+                if (existsSync(segDir)) {
+                    return readdirSync(segDir).filter((f) => f.endsWith(".ts"));
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return [];
+}
+function getSegmentData(stationId, seq) {
+    const stationsDir = join(DATA_DIR, "stations");
+    if (!existsSync(stationsDir))
+        return null;
+    for (const slug of readdirSync(stationsDir)) {
+        const metaPath = join(stationsDir, slug, "station.json");
+        if (!existsSync(metaPath))
+            continue;
+        try {
+            const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+            if (String(meta.stationId) === stationId || meta.name === stationId) {
+                const segPath = join(stationsDir, slug, "segments", `${seq}.ts`);
+                if (existsSync(segPath))
+                    return readFileSync(segPath);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    // Also check the P2P cache directory
+    const cachePath = join(SEGMENTS_DIR, stationId, `${seq}.ts`);
+    if (existsSync(cachePath))
+        return readFileSync(cachePath);
+    return null;
+}
+// ─── HTTP API Server ─────────────────────────────────────────────────────────
+function sendJSON(res, status, data) {
+    const body = JSON.stringify(data);
+    res.writeHead(status, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+    });
+    res.end(body);
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        req.on("error", reject);
+    });
+}
+function createAPIServer(state) {
+    return createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        const path = url.pathname;
+        // CORS preflight
+        if (req.method === "OPTIONS") {
+            res.writeHead(204, {
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type",
+            });
+            res.end();
+            return;
+        }
+        // ── GET /health ──────────────────────────────────────────────────
+        if (path === "/health" && req.method === "GET") {
+            sendJSON(res, 200, {
+                ok: true,
+                platform: platform(),
+                block: state.currentBlock,
+                stations: state.stations.length,
+                heartbeats: state.heartbeats.size,
+                peers: state.peerCount,
+                uptime: process.uptime(),
+            });
+            return;
+        }
+        // ── GET /stations ────────────────────────────────────────────────
+        if (path === "/stations" && req.method === "GET") {
+            sendJSON(res, 200, state.stations);
+            return;
+        }
+        // ── GET /heartbeat/:stationId ────────────────────────────────────
+        // The decentralized heartbeat API — miners serve this
+        const heartbeatMatch = path.match(/^\/heartbeat\/(\d+)$/);
+        if (heartbeatMatch && req.method === "GET") {
+            const stationId = heartbeatMatch[1];
+            // Check cache first
+            const cached = state.heartbeats.get(stationId);
+            if (cached && Date.now() - state.lastHeartbeatPoll < 30_000) {
+                sendJSON(res, 200, cached);
+                return;
+            }
+            // Fresh read from chain
+            const hb = await fetchHeartbeat(stationId);
+            state.heartbeats.set(stationId, hb);
+            sendJSON(res, 200, hb);
+            return;
+        }
+        // ── GET /heartbeat — all known stations ──────────────────────────
+        if (path === "/heartbeat" && req.method === "GET") {
+            const all = [];
+            for (const [, hb] of state.heartbeats) {
+                all.push(hb);
+            }
+            sendJSON(res, 200, all);
+            return;
+        }
+        // ── GET /segments/:stationId/:seq.ts ─────────────────────────────
+        const segMatch = path.match(/^\/segments\/([^/]+)\/(\d+)\.ts$/);
+        if (segMatch && req.method === "GET") {
+            const data = getSegmentData(segMatch[1], parseInt(segMatch[2], 10));
+            if (data) {
+                res.writeHead(200, {
+                    "Content-Type": "video/mp2t",
+                    "Content-Length": data.length.toString(),
+                    "Access-Control-Allow-Origin": "*",
+                });
+                res.end(data);
+                return;
+            }
+            sendJSON(res, 404, { error: "segment not found" });
+            return;
+        }
+        // ── POST /key-exchange ───────────────────────────────────────────
+        if (path === "/key-exchange" && req.method === "POST") {
+            try {
+                const body = JSON.parse(await readBody(req));
+                const { stationId, walletAddress } = body;
+                if (!stationId || !walletAddress) {
+                    sendJSON(res, 400, { error: "missing stationId or walletAddress" });
+                    return;
+                }
+                const key = loadStationKey(stationId);
+                if (!key) {
+                    sendJSON(res, 404, { error: "no key for this station" });
+                    return;
+                }
+                const hasAccess = await verifyHasAccess(stationId, walletAddress);
+                if (!hasAccess) {
+                    sendJSON(res, 403, {
+                        error: "no position held — buy on the bonding curve first",
+                    });
+                    return;
+                }
+                sendJSON(res, 200, { stationKey: key, stationId });
+                console.log(`[daemon] shared key for station ${stationId} with ${walletAddress.slice(0, 10)}...`);
+            }
+            catch {
+                sendJSON(res, 400, { error: "invalid request body" });
+            }
+            return;
+        }
+        // ── GET /register/lookup?room_code=XXXX ──────────────────────
+        if (path === "/register/lookup" && req.method === "GET") {
+            const roomCode = url.searchParams.get("room_code");
+            if (!roomCode) {
+                sendJSON(res, 400, { error: "missing room_code query parameter" });
+                return;
+            }
+            const registryFile = join(CACHE_DIR, "device-registry.json");
+            if (!existsSync(registryFile)) {
+                sendJSON(res, 404, { error: "no devices registered yet" });
+                return;
+            }
+            let registry = {};
+            try {
+                registry = JSON.parse(readFileSync(registryFile, "utf8"));
+            }
+            catch {
+                sendJSON(res, 500, { error: "failed to read device registry" });
+                return;
+            }
+            const entry = Object.values(registry).find((d) => d.room_code === roomCode.toUpperCase());
+            if (!entry) {
+                sendJSON(res, 404, { error: "room code not found" });
+                return;
+            }
+            sendJSON(res, 200, entry);
+            return;
+        }
+        // ── POST /register — speaker device registration ───────────────
+        if (path === "/register" && req.method === "POST") {
+            try {
+                const body = JSON.parse(await readBody(req));
+                const { device_id } = body;
+                if (!device_id) {
+                    sendJSON(res, 400, { error: "missing device_id" });
+                    return;
+                }
+                // Load or create device registry
+                const registryFile = join(CACHE_DIR, "device-registry.json");
+                let registry = {};
+                if (existsSync(registryFile)) {
+                    try {
+                        registry = JSON.parse(readFileSync(registryFile, "utf8"));
+                    }
+                    catch {
+                        registry = {};
+                    }
+                }
+                // Existing device — return known wallet
+                if (registry[device_id]) {
+                    sendJSON(res, 200, {
+                        address: registry[device_id].address,
+                        room_code: registry[device_id].room_code,
+                        is_new: false,
+                    });
+                    return;
+                }
+                // New device — generate room code, placeholder address
+                // TODO: Replace with CDP wallet creation via Coinbase SDK
+                const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+                const roomCode = Array.from({ length: 4 }, () => chars[Math.floor(Math.random() * chars.length)]).join("");
+                // Placeholder: deterministic address from device_id hash
+                // In production: call Coinbase CDP API to create a real wallet
+                const { createHash } = await import("node:crypto");
+                const hash = createHash("sha256").update(device_id).digest("hex");
+                const placeholderAddress = `0x${hash.slice(0, 40)}`;
+                registry[device_id] = {
+                    address: placeholderAddress,
+                    room_code: roomCode,
+                    created_at: new Date().toISOString(),
+                };
+                writeFileSync(registryFile, JSON.stringify(registry, null, 2));
+                console.log(`[daemon] registered device ${device_id} → ${placeholderAddress} (code: ${roomCode})`);
+                sendJSON(res, 200, {
+                    address: placeholderAddress,
+                    room_code: roomCode,
+                    is_new: true,
+                });
+            }
+            catch {
+                sendJSON(res, 400, { error: "invalid request body" });
+            }
+            return;
+        }
+        // ── 404 ──────────────────────────────────────────────────────────
+        sendJSON(res, 404, {
+            error: "not found",
+            routes: [
+                "GET  /health",
+                "GET  /stations",
+                "GET  /heartbeat/:stationId",
+                "GET  /heartbeat",
+                "GET  /segments/:stationId/:seq.ts",
+                "GET  /register/lookup?room_code=XXXX",
+                "POST /key-exchange",
+                "POST /register",
+            ],
+        });
+    });
+}
+// ─── Background Pollers ──────────────────────────────────────────────────────
+async function pollStations(state) {
+    try {
+        state.stations = await discoverStations();
+        state.lastStationPoll = Date.now();
+        console.log(`[daemon] indexed ${state.stations.length} stations from chain`);
+    }
+    catch (e) {
+        console.error(`[daemon] station poll failed: ${e}`);
+    }
+}
+async function pollHeartbeats(state) {
+    try {
+        const promises = state.stations.map(async (s) => {
+            const hb = await fetchHeartbeat(s.id);
+            state.heartbeats.set(s.id, hb);
+        });
+        await Promise.all(promises);
+        state.lastHeartbeatPoll = Date.now();
+        const alive = [...state.heartbeats.values()].filter((h) => h.alive).length;
+        console.log(`[daemon] heartbeats: ${alive}/${state.heartbeats.size} alive`);
+    }
+    catch (e) {
+        console.error(`[daemon] heartbeat poll failed: ${e}`);
+    }
+}
+async function pollBlock(state) {
+    try {
+        const c = getClient();
+        state.currentBlock = Number(await c.getBlockNumber());
+    }
+    catch {
+        // silent — block polling is best-effort
+    }
+}
+// ─── Main Entry ──────────────────────────────────────────────────────────────
+export async function startDaemon(opts = {}) {
+    const port = opts.port ?? 9999;
+    const bindAddr = opts.public ? "0.0.0.0" : "127.0.0.1";
+    const state = {
+        stations: [],
+        currentBlock: 0,
+        lastStationPoll: 0,
+        lastHeartbeatPoll: 0,
+        heartbeats: new Map(),
+        peerCount: 0,
+    };
+    console.log(`[daemon] deadman.fm node starting on ${platform()}`);
+    console.log(`[daemon] data: ${DATA_DIR}`);
+    // Initial chain reads
+    await pollBlock(state);
+    console.log(`[daemon] Base block: ${state.currentBlock}`);
+    await pollStations(state);
+    await pollHeartbeats(state);
+    // Start HTTP API server
+    const server = createAPIServer(state);
+    server.listen(port, bindAddr, () => {
+        console.log(`[daemon] API server: http://${bindAddr}:${port}`);
+        console.log(`[daemon] heartbeat API: http://${bindAddr}:${port}/heartbeat/:stationId`);
+        console.log(`[daemon] ${state.stations.length} stations indexed, ${state.heartbeats.size} heartbeats cached`);
+    });
+    // Background polling intervals
+    // Block: every 6 seconds
+    setInterval(() => pollBlock(state), 6_000);
+    // Stations: every 60 seconds
+    setInterval(() => pollStations(state), 60_000);
+    // Heartbeats: every 30 seconds
+    setInterval(() => pollHeartbeats(state), 30_000);
+    // Write state file for Local Link / OpenHome ability interop
+    setInterval(() => {
+        const stateFile = join(DATA_DIR, "daemon-state.json");
+        const out = {
+            block: state.currentBlock,
+            stations: state.stations,
+            heartbeats: Object.fromEntries(state.heartbeats),
+            peers: state.peerCount,
+            port,
+            platform: platform(),
+            updatedAt: new Date().toISOString(),
+        };
+        try {
+            writeFileSync(stateFile, JSON.stringify(out, null, 2));
+        }
+        catch {
+            // non-critical
+        }
+    }, 5_000);
+    // Keep alive
+    await new Promise(() => { });
+}

package/dist/node/heartbeat.d.ts

@@ -0,0 +1,51 @@
+/**
+ * deadman.fm — Heartbeat ping utility
+ *
+ * Calls StationHeartbeat.ping(stationId, segments) on Base to reset
+ * the 7-day dead man's switch after content is synced.
+ *
+ * Only the station creator can call ping(). If no private key is
+ * configured, a warning is logged and the call is skipped gracefully.
+ */
+export declare const HEARTBEAT_ADDRESS: "0xB3D6f8FEeC79De2Bf4A1F6bF48f95e5B98D42163";
+export declare const HEARTBEAT_ABI: readonly [{
+    readonly name: "ping";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "stationId";
+    }, {
+        readonly type: "uint256";
+        readonly name: "segments";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "HeartbeatPinged";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "stationId";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "creator";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint256";
+        readonly name: "segments";
+    }, {
+        readonly type: "uint256";
+        readonly name: "timestamp";
+    }];
+}];
+/**
+ * Ping the StationHeartbeat contract to reset the dead man's switch.
+ *
+ * @param stationId     On-chain station ID (uint256)
+ * @param totalSegments Total segment count to report
+ * @param privateKey    Optional hex private key (0x-prefixed). If omitted,
+ *                      the call is skipped and a warning is printed.
+ * @returns             Transaction hash, or null if skipped.
+ */
+export declare function pingHeartbeat(stationId: number, totalSegments: number, privateKey?: string): Promise<string | null>;

package/dist/node/heartbeat.js

@@ -0,0 +1,76 @@
+/**
+ * deadman.fm — Heartbeat ping utility
+ *
+ * Calls StationHeartbeat.ping(stationId, segments) on Base to reset
+ * the 7-day dead man's switch after content is synced.
+ *
+ * Only the station creator can call ping(). If no private key is
+ * configured, a warning is logged and the call is skipped gracefully.
+ */
+import { createWalletClient, createPublicClient, http, parseAbi, } from "viem";
+import { base } from "viem/chains";
+import { privateKeyToAccount } from "viem/accounts";
+// ── Contract constants ────────────────────────────────────────────────────────
+export const HEARTBEAT_ADDRESS = "0xB3D6f8FEeC79De2Bf4A1F6bF48f95e5B98D42163";
+export const HEARTBEAT_ABI = parseAbi([
+    "function ping(uint256 stationId, uint256 segments) external",
+    "event HeartbeatPinged(uint256 indexed stationId, address indexed creator, uint256 segments, uint256 timestamp)",
+]);
+// ── Main export ───────────────────────────────────────────────────────────────
+/**
+ * Ping the StationHeartbeat contract to reset the dead man's switch.
+ *
+ * @param stationId     On-chain station ID (uint256)
+ * @param totalSegments Total segment count to report
+ * @param privateKey    Optional hex private key (0x-prefixed). If omitted,
+ *                      the call is skipped and a warning is printed.
+ * @returns             Transaction hash, or null if skipped.
+ */
+export async function pingHeartbeat(stationId, totalSegments, privateKey) {
+    if (!privateKey) {
+        console.warn("\n   ⚠️  Heartbeat NOT pinged — no wallet configured.");
+        console.warn("      The 7-day dead man's switch is ticking. Ping manually:");
+        console.warn(`      deadman-fm heartbeat --station ${stationId} --segments ${totalSegments} --key <PRIVATE_KEY>`);
+        return null;
+    }
+    // Normalise key: viem expects a 0x-prefixed 32-byte hex string
+    const keyHex = privateKey.startsWith("0x")
+        ? privateKey
+        : `0x${privateKey}`;
+    let account;
+    try {
+        account = privateKeyToAccount(keyHex);
+    }
+    catch (err) {
+        console.error("   ❌ Heartbeat: invalid private key —", err.message);
+        return null;
+    }
+    const walletClient = createWalletClient({
+        account,
+        chain: base,
+        transport: http(),
+    });
+    const publicClient = createPublicClient({
+        chain: base,
+        transport: http(),
+    });
+    console.log(`\n   💓 Pinging heartbeat for station #${stationId} (${totalSegments} segments)...`);
+    try {
+        const hash = await walletClient.writeContract({
+            address: HEARTBEAT_ADDRESS,
+            abi: HEARTBEAT_ABI,
+            functionName: "ping",
+            args: [BigInt(stationId), BigInt(totalSegments)],
+        });
+        // Wait for 1 confirmation so the user gets a definitive success signal
+        await publicClient.waitForTransactionReceipt({ hash, confirmations: 1 });
+        console.log(`   ✅ Heartbeat pinged — tx: ${hash}`);
+        return hash;
+    }
+    catch (err) {
+        console.error("   ❌ Heartbeat ping failed —", err.message);
+        console.warn("      The 7-day dead man's switch is still ticking. Retry with:");
+        console.warn(`      deadman-fm heartbeat --station ${stationId} --segments ${totalSegments} --key <PRIVATE_KEY>`);
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadman-fm",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "💀.fm — Create and seed decentralized radio stations",
   "type": "module",
   "files": [