┌──────────────┐                                     ┌──────────────┐
│  HOST        │                                     │  GUEST       │
│  (browser)   │                                     │  (browser)   │
└──────┬───────┘                                     └──────┬───────┘
       │                                                    │
       │  1. publish room heartbeat (kind 30311)            │
       │  ───────────────────┐                              │
       │                     ▼                              │
       │                ┌──────────────────┐                │
       │                │  NOSTR RELAYS    │                │
       │                │  wss://nos.lol   │ ◄──────────────┤ 2. subscribe to rooms
       │                │  wss://damus     │                │    (kind 30311 filter)
       │                │  wss://wellorder │                │
       │                └──────────────────┘                │
       │  4. SDP OFFER         │       3. JOIN REQ          │
       │     (kind 1314)       │          (kind 1312)       │
       │◄──────────────────────┼──────────────────────────►│
       │                       │                            │
       │  5. SDP ANSWER        │                            │
       │     (kind 1315)       │                            │
       │◄──────────────────────┴──────────────────────────►│
       │                                                    │
       │  6. STUN / TURN / ICE candidate exchange           │
       │◄──────────────────────────────────────────────────►│
       │         (via stun.l.google.com + TURN)             │
       │                                                    │
       │  7. WebRTC DataChannel OPEN — P2P from here on     │
       │◄══════════════════════════════════════════════════►│
       │                                                    │
       │     position, input, chat, zombie kills, etc.      │
       │     (JSON messages over the channel, ~10 Hz)       │
       │                                                    │

var NOSTR_RELAYS = [
  'wss://nos.lol',
  'wss://nostr-pub.wellorder.net',
  'wss://relay.damus.io'
];

var NOSTR_GAME_TAG = 'your-game-lobby-v1';

// Plug in TURN credentials from whatever provider you use. Rotate across
// multiple accounts if you expect heavy traffic.
var TURN_CREDS = [
  { username: 'YOUR_TURN_USERNAME', credential: 'YOUR_TURN_CREDENTIAL' }
];

function buildIceServers() {
  // Chrome gathers ICE candidates from every TURN server listed per PC, so
  // stacking multiple credentials in one config multiplies per-peer quota cost.
  // Rotate instead — pick one at random per new peer.
  var c = TURN_CREDS[Math.floor(Math.random() * TURN_CREDS.length)];
  return [
    { urls: 'stun:stun.l.google.com:19302' },
    { urls: 'stun:stun1.l.google.com:19302' },
    { urls: 'turn:YOUR_TURN_HOST:3478',               username: c.username, credential: c.credential },
    { urls: 'turn:YOUR_TURN_HOST:3478?transport=tcp', username: c.username, credential: c.credential }
  ];
}

import { build } from 'esbuild';
import fs from 'fs';

const entry = `
import { generateSecretKey, getPublicKey, finalizeEvent } from 'nostr-tools/pure';
window.NostrSign = { generateSecretKey, getPublicKey, finalizeEvent };
`;

fs.writeFileSync('_nostr-min-entry.js', entry);

await build({
  entryPoints: ['_nostr-min-entry.js'],
  bundle: true, minify: true,
  format: 'iife', platform: 'browser', target: 'es2020',
  outfile: 'nostr-min-bundle.js'
});

fs.unlinkSync('_nostr-min-entry.js');

npm install nostr-tools esbuild
node bundle-nostr-minimal.mjs
# → nostr-min-bundle.js  (~27 KB minified)

function nostrConnect(url) {
  var ws; try { ws = new WebSocket(url); } catch (e) { return null; }
  var subs = {}, pubResolvers = {}, openQueue = [], isOpen = false;

  ws.onopen = function () {
    isOpen = true;
    openQueue.forEach(function (f) { try { ws.send(f); } catch (e) {} });
    openQueue.length = 0;
  };
  ws.onmessage = function (ev) {
    var m; try { m = JSON.parse(ev.data); } catch (e) { return; }
    var t = m[0];
    if (t === 'EVENT') { var s = subs[m[1]]; if (s && s.onevent) s.onevent(m[2], url); }
    else if (t === 'EOSE') { var s2 = subs[m[1]]; if (s2 && s2.oneose) s2.oneose(url); }
    else if (t === 'OK')   { var r = pubResolvers[m[1]]; if (r) { clearTimeout(r.timer); delete pubResolvers[m[1]]; m[2] ? r.resolve() : r.reject(new Error(m[3] || 'rejected')); } }
  };

  function send(f) { if (isOpen) { try { ws.send(f); } catch (e) {} } else openQueue.push(f); }

  return {
    url: url,
    publish: function (evt) {
      return new Promise(function (res, rej) {
        var timer = setTimeout(function () { if (pubResolvers[evt.id]) { delete pubResolvers[evt.id]; rej(new Error('timeout')); } }, 8000);
        pubResolvers[evt.id] = { resolve: res, reject: rej, timer: timer };
        send(JSON.stringify(['EVENT', evt]));
      });
    },
    subscribe: function (filter, handlers) {
      var subId = 's' + Math.random().toString(36).slice(2, 10);
      subs[subId] = handlers;
      send(JSON.stringify(['REQ', subId, filter]));
      return { close: function () { send(JSON.stringify(['CLOSE', subId])); delete subs[subId]; } };
    },
    close: function () { try { ws.close(); } catch (e) {} }
  };
}

function nostrPublishAll(evt) {
  var pubs = nostrConns.map(function (r) {
    return r ? r.publish(evt).then(function () { return true; }).catch(function () { return false; }) : Promise.resolve(false);
  });
  return Promise.all(pubs).then(function (rs) { return rs.filter(Boolean).length; });
}

function nostrSubscribeAll(filter, onevent, oneose) {
  var seen = {};
  var subs = nostrConns.map(function (r) {
    if (!r) return null;
    return r.subscribe(filter, {
      onevent: function (evt, url) { if (seen[evt.id]) return; seen[evt.id] = true; onevent(evt, url); },
      oneose: oneose
    });
  });
  return { close: function () { subs.forEach(function (s) { s && s.close(); }); } };
}

function nostrInit() {
  if (!window.NostrSign) return false;
  if (nostrSk) return true;
  nostrSk = window.NostrSign.generateSecretKey();   // fresh secp256k1 key
  nostrPk = window.NostrSign.getPublicKey(nostrSk);
  nostrConns = NOSTR_RELAYS.map(function (u) { return nostrConnect(u); });
  return true;
}

function nostrStartHosting() {
  if (!NOSTR_ENABLED || !nostrInit()) return;

  function pubRoom() {
    var evt = nostrMakeEvent(NOSTR_KIND_ROOM, JSON.stringify({
      name: myName || 'Host',
      game: 'your-game',
      ts:   Date.now()
    }), [
      ['d', 'room'],                         // NIP-33 replaceable tag
      ['t', NOSTR_GAME_TAG],                 // game filter
      ['title', (myName || 'Host') + "'s room"],
      ['status', 'live']
    ]);
    nostrPublishAll(evt);
  }
  pubRoom();
  nostrPublishTimer = setInterval(pubRoom, 30000);

  // Publish "ended" on tab close so guests' lobbies drop us immediately
  window.addEventListener('beforeunload', function () {
    var endEvt = nostrMakeEvent(NOSTR_KIND_ROOM, JSON.stringify({
      name: myName, game: 'your-game', ts: Date.now()
    }), [['d','room'], ['t', NOSTR_GAME_TAG], ['title', myName + "'s room"], ['status','ended']]);
    nostrPublishAll(endEvt);
  });

  // Listen for join requests targeting us (p-tag = our pubkey)
  nostrJoinSub = nostrSubscribeAll({
    kinds: [NOSTR_KIND_JOIN_REQ],
    '#p':  [nostrPk],
    since: Math.floor(Date.now()/1000) - 5
  }, function (evt) {
    if (nostrJoinRequests[evt.id]) return;
    var body; try { body = JSON.parse(evt.content); } catch (e) { return; }
    nostrJoinRequests[evt.id] = { guestPk: evt.pubkey, guestName: body.name, evt: evt };
    nostrShowJoinPopup(evt.id);          // shows accept/reject UI
  });

  // Listen for answers coming back
  nostrAnswerSub = nostrSubscribeAll({
    kinds: [NOSTR_KIND_ANSWER],
    '#p':  [nostrPk],
    since: Math.floor(Date.now()/1000) - 5
  }, function (evt) {
    var body; try { body = JSON.parse(evt.content); } catch (e) { return; }
    if (!body.peerId || !body.answerCode) return;
    acceptAnswer(body.answerCode, body.peerId);
  });
}

function createInvite(nostrGuestPk) {
  var peerId = 'peer_' + Date.now();
  var pc = new RTCPeerConnection({ iceServers: buildIceServers() });
  var dc = pc.createDataChannel('game', { ordered: false });

  pc.oniceconnectionstatechange = function () {
    if (pc.iceConnectionState === 'failed') pc.restartIce();
  };
  setupHostDC(peerId, dc, pc);

  pc.createOffer()
    .then(function (offer) { return pc.setLocalDescription(offer); })
    .then(function ()      { return waitICE(pc); })
    .then(function () {
      var code = encode(pc.localDescription.sdp, 'offer', myName);
      pendingInvites[peerId] = { pc: pc, dc: dc };
      if (nostrGuestPk) {
        nostrSendOfferToGuest(peerId, code, nostrGuestPk);
      } else {
        // Fallback: manual copy/paste flow — show code in UI
        document.getElementById('offerCode').textContent = code;
      }
    });
}

function nostrStartBrowsing(onRoomsUpdate) {
  if (!NOSTR_ENABLED || !nostrInit()) return;
  nostrRooms = {};
  nostrRoomSub = nostrSubscribeAll({
    kinds: [NOSTR_KIND_ROOM],
    '#t':  [NOSTR_GAME_TAG],
    since: Math.floor(Date.now()/1000) - 60       // last 60 s
  }, function (evt) {
    var body; try { body = JSON.parse(evt.content); } catch (e) { return; }
    if (body.game !== 'your-game') return;
    var status = (evt.tags.find(function (t) { return t[0] === 'status'; }) || [])[1];
    if (status === 'ended') { delete nostrRooms[evt.pubkey]; onRoomsUpdate && onRoomsUpdate(); return; }
    var existing = nostrRooms[evt.pubkey];
    if (existing && evt.created_at <= existing.createdAt) return;  // drop stale replay
    nostrRooms[evt.pubkey] = { name: body.name, createdAt: evt.created_at, evt: evt };
    onRoomsUpdate && onRoomsUpdate();
  });
}

function nostrJoinRoom(hostPk) {
  nostrActiveHostPk = hostPk;

  // Listen for an offer from this specific host, tagged to us
  nostrOfferSub = nostrSubscribeAll({
    kinds:   [NOSTR_KIND_OFFER],
    '#p':    [nostrPk],
    authors: [hostPk],
    since:   Math.floor(Date.now()/1000) - 5
  }, function (evt) {
    var body; try { body = JSON.parse(evt.content); } catch (e) { return; }
    if (!body.offerCode || !body.peerId) return;
    window._nostrPendingPeerId = body.peerId;
    window._nostrPendingHostPk = hostPk;
    // Reuse the manual-paste flow by populating the textarea
    document.getElementById('peerCode').value = body.offerCode;
    joinGame();
  });

  // Send join request
  var req = nostrMakeEvent(NOSTR_KIND_JOIN_REQ,
    JSON.stringify({ name: myName }),
    [['p', hostPk]]);
  nostrPublishAll(req);
}

function nostrSendAnswerToHost(answerCode) {
  var evt = nostrMakeEvent(NOSTR_KIND_ANSWER, JSON.stringify({
    peerId:     window._nostrPendingPeerId,
    answerCode: answerCode
  }), [['p', window._nostrPendingHostPk]]);
  nostrPublishAll(evt);
}

function acceptAnswer(answerCode, specificPeerId) {
  var decoded = decode(answerCode);
  var matched = null;
  if (specificPeerId && pendingInvites[specificPeerId] &&
      pendingInvites[specificPeerId].pc.signalingState !== 'closed') {
    matched = specificPeerId;   // Nostr path: exact match
  } else {
    for (var id in pendingInvites) {                     // Manual path: FIFO
      if (pendingInvites[id].pc.signalingState !== 'closed') { matched = id; break; }
    }
  }
  if (!matched) return;
  var inv = pendingInvites[matched];
  inv.pc.setRemoteDescription({ type: 'answer', sdp: decoded.sdp }).then(function () {
    peers[matched] = { name: decoded.username, pc: inv.pc, dc: inv.dc };
    delete pendingInvites[matched];
  });
}

function encode(sdp, type, name) {
  var p = extractParams(sdp);              // pulls ufrag, pwd, fingerprint, ICE candidates
  var candStr = p.cands.length ? p.cands.join('|') : '0.0.0.0:9';
  return (type === 'offer' ? 'O' : 'A') + ',' + name + ',' + p.ufrag + ',' + p.pwd + ',' + p.fp + ',' + candStr;
}

function decode(tok) {
  var t = tok.trim().split(',');
  if (t.length < 6) throw new Error('need 6 parts');
  var type = t[0] === 'O' ? 'offer' : 'answer';
  var name = t[1], ufrag = t[2], pwd = t[3], fpHex = t[4], candStr = t[5];
  // reconstruct ice-ufrag, ice-pwd, fingerprint, candidate lines into a minimal SDP...
  return {
    type, username: name,
    sdp: 'v=0\r\no=- ...\r\na=ice-ufrag:' + ufrag + '\r\na=ice-pwd:' + pwd + '\r\n' +
         'a=fingerprint:sha-256 ' + fp + '\r\n' + candLines + 'a=end-of-candidates\r\n'
  };
}

// reference: your-game.html
function waitICE(pc) {
  return new Promise(function (resolve) {
    if (pc.iceGatheringState === 'complete') return resolve();
    var done = false;
    function fin() { if (!done) { done = true; resolve(); } }
    pc.onicecandidate = function (e) { if (!e.candidate) fin(); };
    pc.onicegatheringstatechange = function () { if (pc.iceGatheringState === 'complete') fin(); };
    setTimeout(fin, 8000);   // HARD cap — ship what we have
  });
}

// Guest → Host
{ type: 'hello', name: 'Alice' }

// Host → Guest (reply on dc.onopen)
{ type: 'init',
  yourColor: '#ff6a00',
  hostName:  'Bob',
  players:   [{name:'Bob',color:'#00ff44'}, {name:'Carol',color:'#ff00ff'}],
  buildings: [true, false, true],         // any persistent world state
  fireSaleUntil: 1713012345678 }

// Guest → Host
{ type:'pos', x:5.2, y:1.65, z:-3.1, ry:1.57, zone:'office', w:0 }

// Host broadcasts to everyone else
{ type:'pos', id:'peer_1713012345', name:'Alice', x:5.2, y:1.65, z:-3.1, ry:1.57, zone:'office', color:'#ff6a00', w:0 }

function broadcastAsHost(msg, excludeId) {
  var data = JSON.stringify(msg);
  for (var id in peers) {
    if (id !== excludeId && peers[id].dc && peers[id].dc.readyState === 'open') {
      try { peers[id].dc.send(data); } catch (e) {}
    }
  }
}

// Guest → Host
{ type:'hitZombie', id:'zombie_42', damage:25 }

// Host → all
{ type:'zombieDied', id:'zombie_42', points:100 }
// Host → the specific killer only
{ type:'youKilledZombie', points:100 }

case 'hitZombie':
  if (zombies[m.id]) {
    zombies[m.id].hp -= getInstaDamage(m.damage);
    if (zombies[m.id].hp <= 0) {
      var pts = Math.floor(100 * (1 + waveNumber * 0.1) * getPointsMult());
      broadcastAsHost({ type:'zombieDied', id:m.id, points:pts }, null);
      if (peers[peerId] && peers[peerId].dc && peers[peerId].dc.readyState === 'open') {
        peers[peerId].dc.send(JSON.stringify({ type:'youKilledZombie', points:pts }));
      }
      removeZombie(m.id);
    }
  }
  break;

pc.oniceconnectionstatechange = function () {
  if (pc.iceConnectionState === 'failed') pc.restartIce();
};

npm install nostr-tools esbuild

Player A (host)             Your Relay                Player B (guest)
  browser                   Node process                 browser
    │                      ┌──────────────┐                │
    │   WebRTC DC ─────────┤ slot N (UDP) ├──── WebRTC DC │
    │                      │              │                │
    │                      │ slot M (UDP) ├◄──────────────┤
    │                      └──────────────┘                │
    │                                                      │
    │  host→'room-create' ─────────────────────────────►  │
    │  ◄─────────────── 'room-event: join' ◄──guest joins │
    │  ◄─────────────── game traffic both ways ──────────►│

free → pending → connected → recycling → free

O,<slot index>,<ice-ufrag>,<ice-pwd>,<DTLS fingerprint hex>,<public-ip>:<udp port>

O,0,YOUR_UFRAG,YOUR_PWD,YOUR_FINGERPRINT,YOUR_RELAY_IP:PORT
O,1,YOUR_UFRAG,YOUR_PWD,YOUR_FINGERPRINT,YOUR_RELAY_IP:PORT+2
...

var RELAY_IP = 'YOUR_RELAY_PUBLIC_IP';
var RELAY_STUN_PORT = 4444;
var _relayPingTimer = null;
var _relayPending = {};

// Tokens — one per slot, generated by your relay at first boot. Never change.
var RELAY_TOKENS = [
  // 'O,0,YOUR_UFRAG,YOUR_PWD,YOUR_FINGERPRINT,YOUR_RELAY_IP:PORT',
  // 'O,1,YOUR_UFRAG,YOUR_PWD,YOUR_FINGERPRINT,YOUR_RELAY_IP:PORT',
  // ...
];

function relayRequest(action, params, _attempt) {
  _attempt = _attempt || 0;
  return new Promise(function(resolve, reject) {
    var id = Math.random().toString(36).slice(2);
    var timer = setTimeout(function() {
      delete _relayPending[id];
      if (_attempt < 3 && relayDC && relayDC.readyState === 'open') {
        relayRequest(action, params, _attempt + 1).then(resolve).catch(reject);
      } else {
        reject(new Error('relay timeout: ' + action));
      }
    }, 8000);
    _relayPending[id] = {
      resolve: function(r) { clearTimeout(timer); resolve(r); },
      reject:  function(e) { clearTimeout(timer); reject(e); }
    };
    relayDC.send(JSON.stringify(Object.assign({ action: action, id: id }, params)));
  });
}

// Heartbeat — paste inside dc.onopen:
if (_relayPingTimer) clearInterval(_relayPingTimer);
_relayPingTimer = setInterval(function() {
  if (relayDC && relayDC.readyState === 'open') {
    try { relayDC.send(JSON.stringify({ action: 'ping' })); } catch(e) {}
  }
}, 5000);

{
  "RELAY_IP": "YOUR_RELAY_PUBLIC_IP",
  "RELAY_STUN_PORT": 4444,
  "RELAY_TOKENS": [
    "O,0,...",
    "O,1,..."
  ]
}

const CONFIG_INSCRIPTION_ID = 'YOUR_CONFIG_INSCRIPTION_ID';
const cfg = await fetch('/content/' + CONFIG_INSCRIPTION_ID).then(r => r.json());
window.RELAY_IP = cfg.RELAY_IP;
window.RELAY_STUN_PORT = cfg.RELAY_STUN_PORT;
window.RELAY_TOKENS = cfg.RELAY_TOKENS;
// ... now run your relay connector code, using these window-level values

# Start under pm2
pm2 start relay-server.js --name kenobi-relay

# Check status
pm2 status

# Tail logs without disturbing connected players
pm2 logs kenobi-relay --lines 40 --nostream

# Health check (the server exposes /health on its control port)
curl http://YOUR_RELAY_IP:CONTROL_PORT/health