Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
// ════════════════════════════════════════════════════════════════════════════
// Coin Radar — live pump.fun launch intelligence.
//
// Renders the Coin Intelligence Engine feed (GET /api/pump/coin-intel): every
// coin observed in its first ~90s of trading, classified and risk-scored. The
// trader question this page answers at a glance: "organic, or a bundle/rug?"
//
// Data source is the ONLY one: /api/pump/coin-intel (radar list) and
// /api/pump/coin-intel?mint=<mint>&wallets=1 (single-coin detail). Every number
// traces to an observed on-chain trade — nothing here is synthesized. A signal
// the engine did not measure (e.g. fresh_wallet_ratio === null) renders as
// "not measured", never as 0.
// ════════════════════════════════════════════════════════════════════════════
import { createLogger } from './shared/log.js';
import { initFork, openFork } from './fork-trade.js';
const log = createLogger('radar');
const POLL_MS = 12000;
const DEFAULT_LIMIT = 60;
// ── watchlist helpers (same key as launch-detail.js, watchlist.js, launches.js, oracle.js) ──
const WATCH_KEY = 'ld_watchlist';
function isWatched(mint) {
try { return JSON.parse(localStorage.getItem(WATCH_KEY) || '[]').includes(mint); } catch { return false; }
}
function toggleRadarWatch(mint) {
try {
const list = JSON.parse(localStorage.getItem(WATCH_KEY) || '[]');
const idx = list.indexOf(mint);
if (idx >= 0) list.splice(idx, 1); else list.unshift(mint);
localStorage.setItem(WATCH_KEY, JSON.stringify(list.slice(0, 200)));
return idx < 0;
} catch { return false; }
}
const CATEGORIES = [
'meme', 'tech', 'ai', 'culture', 'community',
'political', 'news', 'animal', 'celebrity', 'utility', 'unknown',
];
const CATEGORY_LABEL = {
meme: 'Meme', tech: 'Tech', ai: 'AI', culture: 'Culture',
community: 'Community', political: 'Political', news: 'News',
animal: 'Animal', celebrity: 'Celebrity', utility: 'Utility', unknown: 'Unknown',
};
// Risk-flag vocabulary → display label + severity. danger = act-with-caution,
// warn = worth noting. Unknown future flags fall back to a neutral warn pill.
const FLAG_META = {
bundle_launch: { label: 'Bundle launch', tone: 'danger', tip: 'Many wallets bought in the same block — likely coordinated.' },
dev_dumped: { label: 'Dev dumped', tone: 'danger', tip: 'The creator sold their position.' },
single_whale: { label: 'Single whale', tone: 'danger', tip: 'One wallet holds an outsized share of supply.' },
low_diversity: { label: 'Low diversity', tone: 'danger', tip: 'Few unique buyers — thin, concentrated participation.' },
fresh_wallet_swarm:{ label: 'Fresh-wallet swarm',tone: 'danger', tip: 'A cluster of brand-new wallets bought together.' },
sell_pressure: { label: 'Sell pressure', tone: 'warn', tip: 'Sells are outpacing buys early.' },
sniped: { label: 'Sniped', tone: 'warn', tip: 'Snipers grabbed supply in the first moments.' },
};
// Sort options — the label users see, mapped to the server `sort` param.
const SORTS = [
{ key: 'new', label: 'Newest' },
{ key: 'quality', label: 'Quality' },
{ key: 'smart', label: 'Smart money' },
{ key: 'buyers', label: 'Buyers' },
{ key: 'volume', label: 'Buy volume' },
];
const SORT_KEYS = new Set(SORTS.map((s) => s.key));
// ── tiny DOM + format helpers ───────────────────────────────────────────────
const el = (tag, cls, text) => {
const n = document.createElement(tag);
if (cls) n.className = cls;
if (text != null) n.textContent = text;
return n;
};
const pct = (v) => (v == null ? null : Math.round(v * 100));
const clamp01 = (v) => Math.max(0, Math.min(1, v));
const short = (s, head = 4, tail = 4) =>
typeof s === 'string' && s.length > head + tail + 1 ? `${s.slice(0, head)}…${s.slice(-tail)}` : (s || '');
const fmtSol = (v) => {
if (v == null || Number.isNaN(v)) return null;
const abs = Math.abs(v);
if (abs === 0) return '0';
if (abs < 0.001) return v.toFixed(5);
if (abs < 1) return v.toFixed(3);
if (abs < 1000) return v.toFixed(2);
return v.toLocaleString(undefined, { maximumFractionDigits: 0 });
};
const fmtInt = (v) => (v == null ? '—' : Number(v).toLocaleString());
// Market cap (denominated in SOL at first observation) → compact label.
const fmtMcap = (v) => {
if (v == null || Number.isNaN(v)) return null;
if (v >= 1000) return (v / 1000).toFixed(1).replace(/\.0$/, '') + 'k ◎';
if (v >= 1) return v.toFixed(1).replace(/\.0$/, '') + ' ◎';
return v.toFixed(2) + ' ◎';
};
function timeAgo(ts) {
if (!ts) return '';
const ms = Date.parse(ts);
if (Number.isNaN(ms)) return '';
const s = Math.max(0, Math.floor((Date.now() - ms) / 1000));
if (s < 60) return s + 's ago';
const m = Math.floor(s / 60);
if (m < 60) return m + 'm ago';
const h = Math.floor(m / 60);
if (h < 24) return h + 'h ago';
return Math.floor(h / 24) + 'd ago';
}
function solscanToken(mint, network) {
const base = `https://solscan.io/token/${encodeURIComponent(mint)}`;
return network === 'devnet' ? `${base}?cluster=devnet` : base;
}
function solscanAccount(addr, network) {
const base = `https://solscan.io/account/${encodeURIComponent(addr)}`;
return network === 'devnet' ? `${base}?cluster=devnet` : base;
}
// Quality 0–100 → red→amber→green ramp. Null score → neutral grey.
function qualityColor(score) {
if (score == null) return 'var(--ink-faint)';
if (score >= 70) return 'var(--success)';
if (score >= 40) return 'var(--warn)';
return 'var(--danger)';
}
function qualityLabel(score) {
if (score == null) return 'Unscored';
if (score >= 70) return 'Healthy';
if (score >= 40) return 'Mixed';
return 'High risk';
}
// ── state ───────────────────────────────────────────────────────────────────
const state = {
network: 'mainnet',
category: null, // null = all
minQuality: 0,
hideRisky: false, // client-side: drop danger-flagged coins
smartOnly: false, // server-side: only coins smart money touched
newsOnly: false, // server-side: only news-meme coins
sort: 'new', // new | quality | smart | buyers | volume
query: '', // free-text search (name / symbol / mint)
view: 'grid', // grid | list
coins: [],
seen: new Set(), // mints already rendered (for enter animation)
status: 'loading', // loading | ready | empty | error
lastUpdated: 0,
pollTimer: null,
inFlight: null,
pulse: null, // market-pulse aggregate (or null until first load)
pulseStatus: 'loading', // loading | ready | error (drives the strip's own state)
pulseInFlight: null,
};
let root = null;
// ── URL <-> state (shareable views) ─────────────────────────────────────────
function readUrl() {
const p = new URLSearchParams(location.search);
if (p.get('network') === 'devnet') state.network = 'devnet';
const cat = p.get('category');
if (cat && CATEGORIES.includes(cat)) state.category = cat;
const mq = parseInt(p.get('min_quality'), 10);
if (Number.isFinite(mq)) state.minQuality = Math.max(0, Math.min(100, mq));
if (p.get('hide_risky') === '1') state.hideRisky = true;
if (p.get('smart_money') === '1') state.smartOnly = true;
if (p.get('news') === '1') state.newsOnly = true;
if (SORT_KEYS.has(p.get('sort'))) state.sort = p.get('sort');
if (p.get('view') === 'list') state.view = 'list';
const q = p.get('q');
if (q) state.query = q.slice(0, 64);
}
function writeUrl() {
const p = new URLSearchParams();
if (state.network !== 'mainnet') p.set('network', state.network);
if (state.category) p.set('category', state.category);
if (state.minQuality > 0) p.set('min_quality', String(state.minQuality));
if (state.hideRisky) p.set('hide_risky', '1');
if (state.smartOnly) p.set('smart_money', '1');
if (state.newsOnly) p.set('news', '1');
if (state.sort !== 'new') p.set('sort', state.sort);
if (state.view === 'list') p.set('view', 'list');
if (state.query) p.set('q', state.query);
const qs = p.toString();
const url = location.pathname + (qs ? '?' + qs : '');
history.replaceState(null, '', url);
}
// ── data fetch ──────────────────────────────────────────────────────────────
function buildFeedUrl() {
const p = new URLSearchParams();
p.set('limit', String(DEFAULT_LIMIT));
p.set('network', state.network);
if (state.category) p.set('category', state.category);
if (state.minQuality > 0) p.set('min_quality', String(state.minQuality));
if (state.smartOnly) p.set('smart_money', '1');
if (state.newsOnly) p.set('news', '1');
if (state.sort !== 'new') p.set('sort', state.sort);
if (state.query) p.set('q', state.query);
return '/api/pump/coin-intel?' + p.toString();
}
async function fetchFeed({ silent = false } = {}) {
if (state.inFlight) state.inFlight.abort();
const ctrl = new AbortController();
state.inFlight = ctrl;
if (!silent) {
state.status = 'loading';
render();
}
try {
const r = await fetch(buildFeedUrl(), {
headers: { accept: 'application/json' },
signal: ctrl.signal,
});
if (!r.ok) throw new Error(`feed HTTP ${r.status}`);
const data = await r.json();
const coins = Array.isArray(data.coins) ? data.coins : [];
state.coins = coins;
state.lastUpdated = Date.now();
state.status = coins.length ? 'ready' : 'empty';
render();
} catch (err) {
if (err.name === 'AbortError') return;
log.error('feed fetch failed:', err.message || err);
// Keep previously rendered coins on a silent (poll) failure; only blank
// out to the error state when we have nothing to show.
if (!state.coins.length) {
state.status = 'error';
render();
}
} finally {
state.inFlight = null;
}
}
// Market-pulse aggregate — independent of the feed filters; reflects the whole
// recent window for the active network. Best-effort: a failure leaves the last
// strip in place rather than blanking it.
async function fetchPulse() {
if (state.pulseInFlight) state.pulseInFlight.abort();
const ctrl = new AbortController();
state.pulseInFlight = ctrl;
try {
const r = await fetch(`/api/pump/coin-intel?stats=1&network=${state.network}`, {
headers: { accept: 'application/json' },
signal: ctrl.signal,
});
if (!r.ok) throw new Error(`pulse HTTP ${r.status}`);
state.pulse = await r.json();
state.pulseStatus = 'ready';
updatePulseStrip();
} catch (err) {
if (err.name === 'AbortError') return;
log.error('pulse fetch failed:', err.message || err);
// A later poll can still succeed, so keep the last good aggregate on
// screen. With nothing to keep, swap the skeleton for a designed
// "unavailable" cell instead of leaving a shimmer up forever.
if (!state.pulse) { state.pulseStatus = 'error'; updatePulseStrip(); }
} finally {
state.pulseInFlight = null;
}
}
// ── polling (paused when tab hidden) ────────────────────────────────────────
function startPolling() {
stopPolling();
state.pollTimer = setInterval(() => {
if (document.hidden) return;
fetchFeed({ silent: true });
fetchPulse();
}, POLL_MS);
}
function stopPolling() {
if (state.pollTimer) { clearInterval(state.pollTimer); state.pollTimer = null; }
}
// ════════════════════════════════════════════════════════════════════════════
// RENDER
// ════════════════════════════════════════════════════════════════════════════
function render() {
if (!root) return;
root.innerHTML = '';
root.append(renderPulseStrip());
root.append(renderToolbar());
const body = el('div', 'radar-body');
if (state.status === 'loading' && !state.coins.length) {
body.append(renderSkeletonGrid());
} else if (state.status === 'error') {
body.append(renderErrorState());
} else {
const visible = applyClientFilters(state.coins);
if (!visible.length) {
// Most of the filters (search, category, min quality, smart money,
// news) are applied server-side, so an over-tight filter comes back
// as an empty feed and used to render "radar is clear", blaming the
// market for the user's own filter and offering no way out. The
// filter state, not the response shape, decides which state is true.
body.append(activeFilters().length ? renderNoMatchState() : renderEmptyState());
} else {
body.append(state.view === 'list' ? renderList(visible) : renderGrid(visible));
}
}
root.append(body);
updateUpdatedLabel();
}
// Every filter currently narrowing the feed, each with the label the user sees
// and the reset that drops just that one. Drives the no-match state's removable
// chips, and (by being non-empty) the choice between "no match" and "no coins".
function activeFilters() {
const out = [];
if (state.query) out.push({ label: `Search: ${state.query}`, clear: () => { state.query = ''; } });
if (state.category) out.push({ label: `Category: ${CATEGORY_LABEL[state.category] || state.category}`, clear: () => { state.category = null; } });
if (state.minQuality > 0) out.push({ label: `Min quality: ${state.minQuality}`, clear: () => { state.minQuality = 0; } });
if (state.smartOnly) out.push({ label: 'Smart money only', clear: () => { state.smartOnly = false; } });
if (state.newsOnly) out.push({ label: 'News-driven only', clear: () => { state.newsOnly = false; } });
if (state.hideRisky) out.push({ label: 'Flagged coins hidden', clear: () => { state.hideRisky = false; } });
return out;
}
function applyClientFilters(coins) {
if (!state.hideRisky) return coins;
return coins.filter((c) => {
const flags = c.risk_flags || [];
return !flags.some((f) => (FLAG_META[f]?.tone ?? 'warn') === 'danger');
});
}
// ── market pulse ──────────────────────────────────────────────────────────────
// A single-glance read of the room: launches in the window, the health split,
// and the structural rates (bundle, smart-money, graduation) the engine derives.
function renderPulseStrip() {
const strip = el('div', 'radar-pulse');
strip.id = 'radar-pulse';
strip.setAttribute('aria-label', 'Market pulse — last 24 hours');
fillPulseStrip(strip, state.pulse);
return strip;
}
function updatePulseStrip() {
const strip = root && root.querySelector('#radar-pulse');
if (strip) fillPulseStrip(strip, state.pulse);
}
function fillPulseStrip(strip, p) {
strip.innerHTML = '';
strip.classList.remove('radar-pulse--unavailable');
if (!p) {
if (state.pulseStatus === 'error') {
// The aggregate is a summary of the same window the feed below
// already shows, so its failure is a note, not a page error. Say so
// and offer the retry rather than shimmering forever.
const cell = el('div', 'rp-cell rp-cell--unavailable');
cell.append(el('span', 'rp-label', 'Market pulse'));
cell.append(el('span', 'rp-sub', 'The 24h aggregate did not load. The live feed below is unaffected.'));
const retry = el('button', 'rp-retry', 'Retry');
retry.type = 'button';
retry.addEventListener('click', () => {
state.pulseStatus = 'loading';
updatePulseStrip();
fetchPulse();
});
cell.append(retry);
strip.classList.add('radar-pulse--unavailable');
strip.append(cell);
return;
}
// first paint, before the aggregate lands — quiet skeleton, no layout jump
for (let i = 0; i < 5; i++) {
const cell = el('div', 'rp-cell rp-cell--sk');
cell.append(el('div', 'sk sk-bar w70'), el('div', 'sk sk-bar'));
strip.append(cell);
}
return;
}
const total24 = p.observed_24h || 0;
const known = (p.healthy || 0) + (p.mixed || 0) + (p.risky || 0);
// 1 — launches observed (24h, with a 1h pace inset)
strip.append(pulseCell('Launches · 24h', fmtInt(total24), p.observed_1h != null ? `${fmtInt(p.observed_1h)} in last hour` : null));
// 2 — health distribution (segmented mini-bar + legend)
const healthCell = el('div', 'rp-cell rp-cell--health');
healthCell.append(el('span', 'rp-label', 'Health mix · 24h'));
const bar = el('div', 'rp-dist');
bar.setAttribute('aria-hidden', 'true');
const seg = (cls, n) => {
if (!n) return;
const s = el('span', `rp-dist-seg rp-dist-seg--${cls}`);
s.style.flex = String(n);
s.title = `${n} ${cls}`;
bar.append(s);
};
if (known) { seg('healthy', p.healthy); seg('mixed', p.mixed); seg('risky', p.risky); }
else bar.append(el('span', 'rp-dist-seg rp-dist-seg--empty'));
const legend = el('div', 'rp-dist-legend');
legend.append(distTag('healthy', 'Healthy', p.healthy || 0));
legend.append(distTag('mixed', 'Mixed', p.mixed || 0));
legend.append(distTag('risky', 'Risk', p.risky || 0));
healthCell.append(bar, legend);
strip.append(healthCell);
// 3 — flagged share of scored launches
const scored = known || 1;
const flaggedPct = Math.round(((p.flagged || 0) / scored) * 100);
strip.append(pulseCell('Flagged · 24h', known ? flaggedPct + '%' : '—', `${fmtInt(p.flagged || 0)} with danger flags`, flaggedPct >= 50 ? 'danger' : flaggedPct >= 25 ? 'warn' : 'ok'));
// 4 — smart money footprint
strip.append(pulseCell('Smart money', fmtInt(p.smart_money_touched || 0), 'launches they touched', (p.smart_money_touched || 0) > 0 ? 'smart' : null));
// 5 — labeled outcomes (graduated vs rugged)
const o = p.outcomes || {};
const outCell = el('div', 'rp-cell');
outCell.append(el('span', 'rp-label', 'Outcomes · 24h'));
const outVal = el('div', 'rp-outcomes');
outVal.append(outStat('grad', '↑', fmtInt(o.graduated || 0), 'graduated'));
outVal.append(outStat('rug', '↓', fmtInt(o.rugged || 0), 'rugged'));
outCell.append(outVal);
strip.append(outCell);
}
function pulseCell(label, value, sub, tone) {
const cell = el('div', 'rp-cell' + (tone ? ` rp-cell--${tone}` : ''));
cell.append(el('span', 'rp-label', label));
cell.append(el('span', 'rp-value', value));
if (sub) cell.append(el('span', 'rp-sub', sub));
return cell;
}
function distTag(cls, label, n) {
const t = el('span', `rp-leg rp-leg--${cls}`);
t.append(el('span', 'rp-leg-dot'));
t.append(el('span', null, `${label} ${n}`));
return t;
}
function outStat(cls, glyph, n, label) {
const s = el('span', `rp-out rp-out--${cls}`);
s.append(el('span', 'rp-out-glyph', glyph));
s.append(el('span', 'rp-out-num', n));
s.title = `${n} ${label}`;
return s;
}
// ── toolbar / filters ───────────────────────────────────────────────────────
function renderToolbar() {
const bar = el('div', 'radar-toolbar');
bar.setAttribute('role', 'region');
bar.setAttribute('aria-label', 'Radar filters');
// row 1: category chips
const chips = el('div', 'radar-chips');
chips.setAttribute('role', 'group');
chips.setAttribute('aria-label', 'Filter by category');
chips.append(chip('All', state.category === null, () => { state.category = null; onFilterChange(); }));
for (const c of CATEGORIES) {
chips.append(chip(CATEGORY_LABEL[c], state.category === c, () => {
state.category = state.category === c ? null : c;
onFilterChange();
}));
}
// row 2: controls
const controls = el('div', 'radar-controls');
// search (name / symbol / mint) — debounced, server-side
const search = el('div', 'radar-search');
const searchIcon = el('span', 'radar-search-icon');
searchIcon.setAttribute('aria-hidden', 'true');
searchIcon.innerHTML = '<svg viewBox="0 0 20 20" width="15" height="15" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><circle cx="9" cy="9" r="6"/><path d="M14 14l3.5 3.5"/></svg>';
const input = el('input', 'radar-search-input');
input.type = 'search';
input.id = 'radar-search';
input.placeholder = 'Search name, ticker, or mint';
input.value = state.query;
input.setAttribute('aria-label', 'Search coins by name, ticker, or mint');
input.autocomplete = 'off';
input.spellcheck = false;
let searchTimer = null;
input.addEventListener('input', () => {
const v = input.value.trim().slice(0, 64);
if (searchTimer) clearTimeout(searchTimer);
searchTimer = setTimeout(() => {
if (v === state.query) return;
state.query = v;
onFilterChange();
}, 320);
});
input.addEventListener('keydown', (e) => {
if (e.key === 'Escape' && input.value) { e.stopPropagation(); input.value = ''; state.query = ''; onFilterChange(); }
});
search.append(searchIcon, input);
// sort
const sortWrap = el('div', 'radar-control radar-sort');
const sortLabel = el('label', 'radar-control-label');
sortLabel.htmlFor = 'radar-sort';
sortLabel.append(el('span', null, 'Sort'));
const sel = el('select', 'radar-select');
sel.id = 'radar-sort';
sel.setAttribute('aria-label', 'Sort coins');
for (const s of SORTS) {
const opt = el('option', null, s.label);
opt.value = s.key;
if (s.key === state.sort) opt.selected = true;
sel.append(opt);
}
sel.addEventListener('change', () => { state.sort = SORT_KEYS.has(sel.value) ? sel.value : 'new'; onFilterChange(); });
sortWrap.append(sortLabel, sel);
// min-quality slider
const qWrap = el('div', 'radar-control radar-quality');
const qLabel = el('label', 'radar-control-label');
qLabel.htmlFor = 'radar-min-quality';
qLabel.append(el('span', null, 'Min quality'));
const qVal = el('span', 'radar-quality-val', state.minQuality === 0 ? 'Any' : String(state.minQuality));
qLabel.append(qVal);
const slider = el('input', 'radar-slider');
slider.type = 'range';
slider.id = 'radar-min-quality';
slider.min = '0'; slider.max = '100'; slider.step = '5';
slider.value = String(state.minQuality);
slider.setAttribute('aria-valuetext', state.minQuality === 0 ? 'Any' : state.minQuality + ' of 100');
slider.addEventListener('input', () => {
state.minQuality = parseInt(slider.value, 10) || 0;
qVal.textContent = state.minQuality === 0 ? 'Any' : String(state.minQuality);
slider.setAttribute('aria-valuetext', state.minQuality === 0 ? 'Any' : state.minQuality + ' of 100');
});
// commit on release (avoid a fetch per tick)
slider.addEventListener('change', () => onFilterChange());
qWrap.append(qLabel, slider);
// hide-risky toggle
const toggle = el('button', 'radar-toggle');
toggle.type = 'button';
toggle.setAttribute('role', 'switch');
toggle.setAttribute('aria-checked', String(state.hideRisky));
toggle.append(el('span', 'radar-toggle-track'));
toggle.append(el('span', 'radar-toggle-label', 'Hide flagged'));
toggle.title = 'Hide coins with danger-level risk flags (bundle, dev-dump, whale, swarm)';
toggle.addEventListener('click', () => {
state.hideRisky = !state.hideRisky;
toggle.setAttribute('aria-checked', String(state.hideRisky));
writeUrl();
render();
});
// smart-money + news-meme quick filters (server-side)
const smartFilter = filterPill('Smart money', state.smartOnly, 'Only coins a reputation-scored wallet bought', () => {
state.smartOnly = !state.smartOnly; onFilterChange();
});
const newsFilter = filterPill('News-driven', state.newsOnly, 'Only coins matching a live news headline', () => {
state.newsOnly = !state.newsOnly; onFilterChange();
});
// grid / list view toggle
const viewWrap = el('div', 'radar-control radar-view');
viewWrap.setAttribute('role', 'group');
viewWrap.setAttribute('aria-label', 'View density');
const viewBtn = (key, title, svg) => {
const b = el('button', 'radar-seg radar-view-btn' + (state.view === key ? ' is-active' : ''));
b.type = 'button';
b.title = title;
b.setAttribute('aria-label', title);
b.setAttribute('aria-pressed', String(state.view === key));
b.innerHTML = svg;
b.addEventListener('click', () => { if (state.view === key) return; state.view = key; writeUrl(); render(); });
return b;
};
viewWrap.append(
viewBtn('grid', 'Grid view', '<svg viewBox="0 0 18 18" width="15" height="15" fill="currentColor"><rect x="1" y="1" width="7" height="7" rx="1.5"/><rect x="10" y="1" width="7" height="7" rx="1.5"/><rect x="1" y="10" width="7" height="7" rx="1.5"/><rect x="10" y="10" width="7" height="7" rx="1.5"/></svg>'),
viewBtn('list', 'List view', '<svg viewBox="0 0 18 18" width="15" height="15" fill="currentColor"><rect x="1" y="2" width="16" height="3" rx="1.5"/><rect x="1" y="7.5" width="16" height="3" rx="1.5"/><rect x="1" y="13" width="16" height="3" rx="1.5"/></svg>'),
);
// network segmented control
const netWrap = el('div', 'radar-control radar-network');
netWrap.setAttribute('role', 'group');
netWrap.setAttribute('aria-label', 'Network');
for (const n of ['mainnet', 'devnet']) {
const b = el('button', 'radar-seg' + (state.network === n ? ' is-active' : ''), n === 'mainnet' ? 'Mainnet' : 'Devnet');
b.type = 'button';
b.setAttribute('aria-pressed', String(state.network === n));
b.addEventListener('click', () => {
if (state.network === n) return;
state.network = n;
state.coins = [];
state.seen.clear();
onFilterChange();
});
netWrap.append(b);
}
// updated indicator
const updated = el('div', 'radar-updated');
updated.id = 'radar-updated';
updated.setAttribute('aria-live', 'polite');
const dot = el('span', 'radar-live-dot');
dot.setAttribute('aria-hidden', 'true');
updated.append(dot, el('span', 'radar-updated-text', 'Connecting…'));
controls.append(search, sortWrap, qWrap, toggle, smartFilter, newsFilter, viewWrap, netWrap, updated);
bar.append(chips, controls);
return bar;
}
function filterPill(label, active, tip, onClick) {
const b = el('button', 'radar-filter-pill' + (active ? ' is-active' : ''), label);
b.type = 'button';
b.title = tip;
b.setAttribute('aria-pressed', String(active));
b.addEventListener('click', onClick);
return b;
}
function chip(label, active, onClick) {
const b = el('button', 'radar-chip' + (active ? ' is-active' : ''), label);
b.type = 'button';
b.setAttribute('aria-pressed', String(active));
b.addEventListener('click', onClick);
return b;
}
function onFilterChange() {
writeUrl();
fetchFeed();
fetchPulse();
}
function updateUpdatedLabel() {
const node = root && root.querySelector('#radar-updated .radar-updated-text');
const dot = root && root.querySelector('#radar-updated .radar-live-dot');
if (!node) return;
if (state.status === 'error') {
node.textContent = 'Reconnecting…';
if (dot) dot.classList.add('is-stale');
return;
}
if (!state.lastUpdated) {
node.textContent = 'Live';
return;
}
if (dot) dot.classList.remove('is-stale');
const s = Math.floor((Date.now() - state.lastUpdated) / 1000);
node.textContent = s < 5 ? 'Live · just now' : `Live · updated ${s}s ago`;
}
// ── grids ───────────────────────────────────────────────────────────────────
function renderGrid(coins) {
const grid = el('div', 'radar-grid');
grid.setAttribute('role', 'list');
for (const coin of coins) grid.append(renderCard(coin));
return grid;
}
// Compact list view — a dense row per coin for fast scanning, same data spine
// as the cards. Click / Enter opens the same detail drawer.
function renderList(coins) {
const list = el('div', 'radar-list');
list.setAttribute('role', 'list');
const header = el('div', 'rl-header');
header.setAttribute('aria-hidden', 'true');
['Coin', 'Quality', 'Organic / Bundle', 'Buyers', 'Net flow', 'Signals', ''].forEach((h, i) => {
header.append(el('span', 'rl-h' + (i === 0 ? ' rl-h-coin' : ''), h));
});
list.append(header);
for (const coin of coins) list.append(renderListRow(coin));
return list;
}
function renderListRow(coin) {
const isNew = !state.seen.has(coin.mint);
state.seen.add(coin.mint);
const row = el('div', 'radar-list-row' + (isNew ? ' is-enter' : ''));
row.setAttribute('role', 'listitem');
row.tabIndex = 0;
row.setAttribute('aria-label', `${coin.name || coin.symbol || 'coin'} — quality ${coin.quality_score ?? 'unscored'}. Open details.`);
const open = () => openDrawer(coin.mint);
row.addEventListener('click', (e) => { if (e.target.closest('a,button')) return; open(); });
row.addEventListener('keydown', (e) => { if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); open(); } });
// coin identity
const idc = el('div', 'rl-coin');
const img = el('img', 'rl-img');
img.loading = 'lazy'; img.decoding = 'async'; img.width = 30; img.height = 30; img.alt = '';
const seed = coin.symbol || coin.name || coin.mint || 'coin';
img.src = coin.image_uri && /^https?:\/\//i.test(coin.image_uri)
? `/api/img?url=${encodeURIComponent(coin.image_uri)}&seed=${encodeURIComponent(seed)}`
: `/api/img?seed=${encodeURIComponent(seed)}`;
img.addEventListener('error', () => { img.src = `/api/img?seed=${encodeURIComponent(seed)}`; }, { once: true });
const idt = el('div', 'rl-id');
const nm = el('div', 'rl-name', coin.name || 'Unnamed');
nm.title = coin.name || '';
const sub = el('div', 'rl-sub');
sub.append(el('span', 'rl-ticker', coin.symbol ? '$' + coin.symbol : '—'));
sub.append(el('span', 'rl-cat', CATEGORY_LABEL[coin.category] || 'Unknown'));
sub.append(el('span', 'rl-age', timeAgo(coin.first_seen_at)));
idt.append(nm, sub);
idc.append(img, idt);
// quality pill
const ql = el('div', 'rl-quality');
const dot = el('span', 'rl-q-dot');
dot.style.background = qualityColor(coin.quality_score);
const qn = el('span', 'rl-q-num', coin.quality_score != null ? String(coin.quality_score) : '—');
qn.style.color = qualityColor(coin.quality_score);
ql.append(dot, qn);
// organic/bundle mini-bar
const ob = el('div', 'rl-ob');
const bar = el('div', 'rc-ob-bar');
const o = coin.organic_score, b = coin.bundle_score;
const oFill = el('span', 'rc-ob-fill rc-ob-fill--organic');
oFill.style.width = (o != null ? clamp01(o) * 100 : 0) + '%';
const bFill = el('span', 'rc-ob-fill rc-ob-fill--bundle');
bFill.style.width = (b != null ? clamp01(b) * 100 : 0) + '%';
bar.append(oFill, bFill);
const obTxt = el('span', 'rl-ob-txt');
obTxt.append(el('span', 'rc-ob-tag--organic', o != null ? pct(o) + '%' : 'n/m'));
obTxt.append(el('span', null, ' / '));
obTxt.append(el('span', 'rc-ob-tag--bundle', b != null ? pct(b) + '%' : 'n/m'));
ob.append(bar, obTxt);
// buyers
const buyers = el('div', 'rl-buyers rd-num', fmtInt(coin.unique_buyers));
// net flow
const net = el('div', 'rl-net rd-num');
if (coin.net_volume_sol == null) net.textContent = '—';
else {
net.textContent = (coin.net_volume_sol > 0 ? '+' : '') + fmtSol(coin.net_volume_sol) + ' ◎';
// Exactly-zero net flow has no directional class — adding '' throws on DOMTokenList.
if (coin.net_volume_sol > 0) net.classList.add('rc-pos');
else if (coin.net_volume_sol < 0) net.classList.add('rc-neg');
}
// signals (badges + flags, condensed)
const sig = el('div', 'rl-signals');
const badges = renderCardBadges(coin);
if (badges) sig.append(badges);
const dangers = (coin.risk_flags || []).filter((f) => (FLAG_META[f]?.tone ?? 'warn') === 'danger');
if (dangers.length) {
const f = el('span', 'rc-flag rc-flag--danger', `${dangers.length} flag${dangers.length === 1 ? '' : 's'}`);
f.title = dangers.map((d) => FLAG_META[d]?.label || d).join(', ');
sig.append(f);
} else if (!badges) {
sig.append(el('span', 'rc-flag rc-flag--clean', 'Clean'));
}
// actions
const act = el('div', 'rl-act');
const watched = isWatched(coin.mint);
const watchBtn = el('button', `rc-watch${watched ? ' rc-watched' : ''}`, watched ? '★' : '☆');
watchBtn.type = 'button';
watchBtn.title = watched ? 'Remove from watchlist' : 'Add to watchlist';
watchBtn.setAttribute('aria-label', watchBtn.title);
watchBtn.setAttribute('aria-pressed', String(watched));
watchBtn.addEventListener('click', (e) => {
e.stopPropagation();
const now = toggleRadarWatch(coin.mint);
watchBtn.textContent = now ? '★' : '☆';
watchBtn.classList.toggle('rc-watched', now);
watchBtn.setAttribute('aria-pressed', String(now));
watchBtn.title = now ? 'Remove from watchlist' : 'Add to watchlist';
watchBtn.setAttribute('aria-label', watchBtn.title);
});
act.append(watchBtn);
row.append(idc, ql, ob, buyers, net, sig, act);
if (isNew) requestAnimationFrame(() => row.classList.remove('is-enter'));
return row;
}
function renderSkeletonGrid() {
const grid = el('div', 'radar-grid', null);
grid.setAttribute('aria-hidden', 'true');
for (let i = 0; i < 8; i++) {
const c = el('div', 'radar-card radar-card--skeleton');
c.append(
el('div', 'sk sk-row'),
el('div', 'sk sk-ring'),
el('div', 'sk sk-bar'),
el('div', 'sk sk-bar w70'),
el('div', 'sk sk-pills'),
);
grid.append(c);
}
return grid;
}
function renderCard(coin) {
const isNew = !state.seen.has(coin.mint);
state.seen.add(coin.mint);
const card = el('article', 'radar-card' + (isNew ? ' is-enter' : ''));
card.setAttribute('role', 'listitem');
card.tabIndex = 0;
const label = `${coin.name || coin.symbol || 'coin'} — quality ${coin.quality_score ?? 'unscored'}, ${qualityLabel(coin.quality_score)}. Open details.`;
card.setAttribute('aria-label', label);
const open = () => openDrawer(coin.mint);
card.addEventListener('click', (e) => {
if (e.target.closest('a')) return; // let links work
open();
});
card.addEventListener('keydown', (e) => {
if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); open(); }
});
// ── header: identity + category ──
const head = el('div', 'rc-head');
const img = el('img', 'rc-img');
img.loading = 'lazy';
img.decoding = 'async';
img.width = 40; img.height = 40;
img.alt = '';
const seed = coin.symbol || coin.name || coin.mint || 'coin';
img.src = coin.image_uri && /^https?:\/\//i.test(coin.image_uri)
? `/api/img?url=${encodeURIComponent(coin.image_uri)}&seed=${encodeURIComponent(seed)}`
: `/api/img?seed=${encodeURIComponent(seed)}`;
img.addEventListener('error', () => { img.src = `/api/img?seed=${encodeURIComponent(seed)}`; }, { once: true });
const idCol = el('div', 'rc-id');
const nameEl = el('div', 'rc-name', coin.name || 'Unnamed');
nameEl.title = coin.name || '';
const symEl = el('div', 'rc-sym');
symEl.append(el('span', 'rc-ticker', coin.symbol ? '$' + coin.symbol : '—'));
symEl.append(el('span', 'rc-age', timeAgo(coin.first_seen_at)));
idCol.append(nameEl, symEl);
const cat = el('span', 'rc-cat', CATEGORY_LABEL[coin.category] || 'Unknown');
cat.title = coin.classify_source
? `Classified by ${coin.classify_source}${coin.classify_confidence != null ? ` · ${pct(coin.classify_confidence)}% confidence` : ''}`
: 'Category';
head.append(img, idCol, cat);
card.append(head);
// ── signal badges (smart money / news / outcome) ──
const badges = renderCardBadges(coin);
if (badges) card.append(badges);
// ── quality ring + organic/bundle ──
const scoreRow = el('div', 'rc-score');
scoreRow.append(renderRing(coin.quality_score));
scoreRow.append(renderOrganicBundle(coin));
card.append(scoreRow);
// ── narrative ──
if (coin.narrative) {
const n = el('p', 'rc-narrative', coin.narrative);
n.title = coin.narrative;
card.append(n);
}
// ── risk flags ──
const flags = (coin.risk_flags || []);
if (flags.length) {
const pills = el('div', 'rc-flags');
for (const f of flags) {
const meta = FLAG_META[f] || { label: f.replace(/_/g, ' '), tone: 'warn', tip: '' };
const p = el('span', `rc-flag rc-flag--${meta.tone}`, meta.label);
if (meta.tip) p.title = meta.tip;
pills.append(p);
}
card.append(pills);
} else {
const clean = el('div', 'rc-flags');
clean.append(el('span', 'rc-flag rc-flag--clean', 'No risk flags'));
card.append(clean);
}
// ── key stats ──
const stats = el('div', 'rc-stats');
stats.append(stat('Buyers', fmtInt(coin.unique_buyers)));
stats.append(stat('Mkt cap', fmtMcap(coin.market_cap_sol) || '—', 'Market cap in SOL at first observation'));
stats.append(stat('Dev buy', coin.dev_buy_sol != null ? fmtSol(coin.dev_buy_sol) + ' ◎' : '—'));
stats.append(stat('Buy vol', coin.buy_volume_sol != null ? fmtSol(coin.buy_volume_sol) + ' ◎' : '—'));
stats.append(stat('Top 10', coin.concentration_top10 != null ? pct(coin.concentration_top10) + '%' : '—', 'Share of supply held by the top 10 wallets'));
stats.append(netStat(coin.net_volume_sol));
card.append(stats);
// ── footer links ──
const foot = el('div', 'rc-foot');
const scan = el('a', 'rc-link', 'Solscan');
scan.href = solscanToken(coin.mint, coin.network);
scan.target = '_blank'; scan.rel = 'noopener noreferrer';
scan.addEventListener('click', (e) => e.stopPropagation());
// Mainnet coins link straight to their full intelligence page (the card body
// still opens the quick-view drawer); devnet coins have no page, so the
// button keeps opening the drawer.
let detail;
if (coin.network === 'devnet') {
detail = el('button', 'rc-detail', 'Full intel →');
detail.type = 'button';
detail.addEventListener('click', (e) => { e.stopPropagation(); open(); });
} else {
detail = el('a', 'rc-detail', 'Full intel →');
detail.href = `/oracle/coin/${coin.mint}`;
detail.addEventListener('click', (e) => e.stopPropagation());
}
const watched = isWatched(coin.mint);
const watchBtn = el('button', `rc-watch${watched ? ' rc-watched' : ''}`, watched ? '★' : '☆');
watchBtn.type = 'button';
watchBtn.setAttribute('aria-label', watched ? 'Remove from watchlist' : 'Add to watchlist');
watchBtn.setAttribute('aria-pressed', String(watched));
watchBtn.title = watched ? 'Remove from watchlist' : 'Add to watchlist';
watchBtn.addEventListener('click', (e) => {
e.stopPropagation();
const nowWatched = toggleRadarWatch(coin.mint);
watchBtn.textContent = nowWatched ? '★' : '☆';
watchBtn.classList.toggle('rc-watched', nowWatched);
watchBtn.setAttribute('aria-pressed', String(nowWatched));
watchBtn.setAttribute('aria-label', nowWatched ? 'Remove from watchlist' : 'Add to watchlist');
watchBtn.title = nowWatched ? 'Remove from watchlist' : 'Add to watchlist';
});
// Fork: the one action on an otherwise read-only card. Opens the real trade
// panel for this coin; the visitor's own wallet signs. Mainnet only, since a
// devnet coin has no market to buy into.
const forkBtn = coin.network === 'devnet' ? null : el('button', 'rc-fork', 'Fork');
if (forkBtn) {
forkBtn.type = 'button';
const sym = coin.symbol ? `$${String(coin.symbol).toUpperCase()}` : 'this coin';
forkBtn.setAttribute('aria-label', `Fork this trade: buy ${sym} from your own wallet`);
forkBtn.title = `Buy ${sym} from your own wallet`;
// Bound directly rather than via fork-trade's delegation: the card itself
// listens for clicks to open the quick-view drawer, so this has to stop
// the event at the button, which a document-level delegate never sees.
forkBtn.addEventListener('click', (e) => {
e.stopPropagation();
openFork({ mint: coin.mint, symbol: coin.symbol, name: coin.name, image: coin.image_uri }, { trigger: forkBtn });
});
}
foot.append(scan, detail, ...(forkBtn ? [forkBtn] : []), watchBtn);
card.append(foot);
if (isNew) requestAnimationFrame(() => card.classList.remove('is-enter'));
return card;
}
function stat(label, value, tip) {
const s = el('div', 'rc-stat');
const l = el('span', 'rc-stat-label', label);
if (tip) { s.title = tip; }
s.append(l);
s.append(el('span', 'rc-stat-value', value));
return s;
}
// Net flow stat — buy minus sell volume, coloured by sign.
function netStat(net) {
const s = el('div', 'rc-stat');
s.title = 'Net SOL flow (buy volume − sell volume) during observation';
s.append(el('span', 'rc-stat-label', 'Net flow'));
const v = el('span', 'rc-stat-value');
if (net == null) { v.textContent = '—'; }
else {
v.textContent = (net > 0 ? '+' : '') + fmtSol(net) + ' ◎';
// Exactly-zero net flow has no directional class — adding '' throws on DOMTokenList.
if (net > 0) v.classList.add('rc-pos');
else if (net < 0) v.classList.add('rc-neg');
}
s.append(v);
return s;
}
// Smart-money / news / outcome badges shown high on each card. Returns null when
// a coin has none, so plain coins stay visually quiet.
function renderCardBadges(coin) {
const items = [];
if (coin.smart_money_count > 0) {
const b = el('span', 'rc-badge rc-badge--smart');
b.append(el('span', 'rc-badge-glyph', '◆'));
b.append(el('span', null, `${coin.smart_money_count} smart`));
b.title = `${coin.smart_money_count} reputation-scored wallet${coin.smart_money_count === 1 ? '' : 's'} bought in${coin.smart_money_score != null ? ` · pedigree ${Math.round(coin.smart_money_score)}/100` : ''}`;
items.push(b);
}
if (coin.is_news_meme) {
const b = el('span', 'rc-badge rc-badge--news');
b.append(el('span', 'rc-badge-glyph', '⚡'));
b.append(el('span', null, 'News'));
b.title = coin.news_headline ? `Matches headline: ${coin.news_headline}` : 'Matches a live news headline';
items.push(b);
}
if (coin.cluster_count > 1) {
const b = el('span', 'rc-badge rc-badge--cluster');
b.append(el('span', 'rc-badge-glyph', '⬡'));
b.append(el('span', null, `${coin.cluster_count} clusters`));
b.title = `${coin.cluster_count} distinct funding clusters detected among buyers`;
items.push(b);
}
if (coin.outcome && (coin.outcome.graduated || coin.outcome.rugged)) {
const grad = coin.outcome.graduated;
const b = el('span', `rc-badge rc-badge--${grad ? 'grad' : 'rug'}`);
b.append(el('span', 'rc-badge-glyph', grad ? '↑' : '↓'));
const ath = coin.outcome.ath_multiple;
b.append(el('span', null, grad ? (ath ? `Graduated ${ath.toFixed(1)}×` : 'Graduated') : 'Rugged'));
b.title = grad ? 'This coin later graduated to a DEX' : 'This coin later rugged';
items.push(b);
}
if (!items.length) return null;
const row = el('div', 'rc-badges');
for (const b of items) row.append(b);
return row;
}
// SVG quality ring, 0–100, color-graded.
function renderRing(score) {
const NS = 'http://www.w3.org/2000/svg';
const size = 64, stroke = 6, r = (size - stroke) / 2, c = 2 * Math.PI * r;
const has = score != null;
const frac = has ? clamp01(score / 100) : 0;
const wrap = el('div', 'rc-ring');
const svg = document.createElementNS(NS, 'svg');
svg.setAttribute('viewBox', `0 0 ${size} ${size}`);
svg.setAttribute('class', 'rc-ring-svg');
svg.setAttribute('aria-hidden', 'true');
const track = document.createElementNS(NS, 'circle');
track.setAttribute('cx', size / 2); track.setAttribute('cy', size / 2); track.setAttribute('r', r);
track.setAttribute('class', 'rc-ring-track');
track.setAttribute('stroke-width', stroke); track.setAttribute('fill', 'none');
const arc = document.createElementNS(NS, 'circle');
arc.setAttribute('cx', size / 2); arc.setAttribute('cy', size / 2); arc.setAttribute('r', r);
arc.setAttribute('class', 'rc-ring-arc');
arc.setAttribute('fill', 'none');
arc.setAttribute('stroke', qualityColor(score));
arc.setAttribute('stroke-width', stroke);
arc.setAttribute('stroke-linecap', 'round');
arc.setAttribute('stroke-dasharray', String(c));
arc.setAttribute('stroke-dashoffset', String(c * (1 - frac)));
arc.setAttribute('transform', `rotate(-90 ${size / 2} ${size / 2})`);
svg.append(track, arc);
const val = el('div', 'rc-ring-val');
val.style.color = qualityColor(score);
val.append(el('span', 'rc-ring-num', has ? String(score) : '—'));
wrap.append(svg, val);
const cap = el('div', 'rc-ring-cap', qualityLabel(score));
cap.style.color = qualityColor(score);
const col = el('div', 'rc-ring-col');
col.append(wrap, cap);
return col;
}
function renderOrganicBundle(coin) {
const o = coin.organic_score, b = coin.bundle_score;
const wrap = el('div', 'rc-ob');
const readout = el('div', 'rc-ob-readout');
readout.append(obTag('Organic', pct(o), 'organic'));
readout.append(obTag('Bundle', pct(b), 'bundle'));
wrap.append(readout);
// dual bar — only the measured side fills; an unmeasured side stays empty.
const bar = el('div', 'rc-ob-bar');
bar.setAttribute('aria-hidden', 'true');
const oFill = el('span', 'rc-ob-fill rc-ob-fill--organic');
oFill.style.width = (o != null ? clamp01(o) * 100 : 0) + '%';
const bFill = el('span', 'rc-ob-fill rc-ob-fill--bundle');
bFill.style.width = (b != null ? clamp01(b) * 100 : 0) + '%';
bar.append(oFill, bFill);
wrap.append(bar);
return wrap;
}
function obTag(label, p, kind) {
const t = el('span', `rc-ob-tag rc-ob-tag--${kind}`);
t.append(el('span', 'rc-ob-tag-label', label));
t.append(el('span', 'rc-ob-tag-val', p == null ? 'n/m' : p + '%'));
if (p == null) t.title = `${label} score not measured`;
return t;
}
// ── states ──────────────────────────────────────────────────────────────────
function renderEmptyState() {
const box = el('div', 'radar-state radar-empty');
box.append(radarGlyph());
box.append(el('h2', 'radar-state-title', 'Radar is clear — waiting for the next launch'));
const p = el('p', 'radar-state-text');
p.textContent = state.network === 'devnet'
? 'No devnet coins have been observed yet. The Coin Intelligence Engine watches each new pump.fun launch for its first ~90 seconds, then scores it. Switch to mainnet for the live feed.'
: 'No coins in the observation window right now. The Coin Intelligence Engine watches every new pump.fun launch for its first ~90 seconds of trading, derives its bundle / organic / concentration signals, classifies it, and posts it here. New cards appear automatically the moment a launch finishes its observation window.';
box.append(p);
const actions = el('div', 'radar-state-actions');
if (state.network !== 'mainnet') {
const toMain = el('button', 'radar-btn', 'View mainnet');
toMain.type = 'button';
toMain.addEventListener('click', () => {
state.network = 'mainnet'; state.coins = []; state.seen.clear(); onFilterChange();
});
actions.append(toMain);
}
const live = el('a', 'radar-btn radar-btn--ghost', 'See raw launches →');
live.href = '/pump-live';
actions.append(live);
box.append(actions);
const note = el('p', 'radar-state-note', 'This view refreshes every 12 seconds. It will populate itself — no need to reload.');
box.append(note);
return box;
}
function renderNoMatchState() {
const filters = activeFilters();
const box = el('div', 'radar-state radar-empty');
box.append(radarGlyph());
box.append(el('h2', 'radar-state-title', 'No coins match these filters'));
box.append(el('p', 'radar-state-text', 'The radar is live and scoring launches, but nothing in the current window passes every filter you have set. Drop one to widen the search.'));
// Removable chips: dropping the one filter that is too tight beats resetting
// everything and rebuilding the view from scratch.
if (filters.length) {
const chips = el('div', 'radar-active-filters');
chips.setAttribute('role', 'group');
chips.setAttribute('aria-label', 'Active filters');
for (const f of filters) {
const b = el('button', 'radar-active-filter');
b.type = 'button';
b.append(el('span', 'radar-active-filter-text', f.label));
const x = el('span', 'radar-active-filter-x', '\u00d7');
x.setAttribute('aria-hidden', 'true');
b.append(x);
b.title = `Remove filter: ${f.label}`;
b.setAttribute('aria-label', `Remove filter: ${f.label}`);
b.addEventListener('click', () => { f.clear(); onFilterChange(); });
chips.append(b);
}
box.append(chips);
}
const actions = el('div', 'radar-state-actions');
const reset = el('button', 'radar-btn', 'Reset all filters');
reset.type = 'button';
reset.addEventListener('click', () => {
state.category = null; state.minQuality = 0; state.hideRisky = false;
state.smartOnly = false; state.newsOnly = false; state.query = ''; state.sort = 'new';
onFilterChange();
});
actions.append(reset);
const live = el('a', 'radar-btn radar-btn--ghost', 'See raw launches \u2192');
live.href = '/pump-live';
actions.append(live);
box.append(actions);
return box;
}
function renderErrorState() {
const box = el('div', 'radar-state radar-error');
box.setAttribute('role', 'alert');
box.append(el('h2', 'radar-state-title', 'Could not reach the radar feed'));
box.append(el('p', 'radar-state-text', 'The Coin Intelligence feed did not respond. This is usually temporary — the engine or network may be momentarily unavailable.'));
const actions = el('div', 'radar-state-actions');
const retry = el('button', 'radar-btn', 'Retry now');
retry.type = 'button';
retry.addEventListener('click', () => fetchFeed());
actions.append(retry);
box.append(actions);
return box;
}
function radarGlyph() {
const NS = 'http://www.w3.org/2000/svg';
const svg = document.createElementNS(NS, 'svg');
svg.setAttribute('viewBox', '0 0 120 120');
svg.setAttribute('class', 'radar-glyph');
svg.setAttribute('aria-hidden', 'true');
for (const rr of [20, 36, 52]) {
const ci = document.createElementNS(NS, 'circle');
ci.setAttribute('cx', '60'); ci.setAttribute('cy', '60'); ci.setAttribute('r', String(rr));
ci.setAttribute('class', 'radar-glyph-ring'); ci.setAttribute('fill', 'none');
svg.append(ci);
}
const sweep = document.createElementNS(NS, 'path');
sweep.setAttribute('d', 'M60 60 L60 8 A52 52 0 0 1 104 38 Z');
sweep.setAttribute('class', 'radar-glyph-sweep');
svg.append(sweep);
const dot = document.createElementNS(NS, 'circle');
dot.setAttribute('cx', '60'); dot.setAttribute('cy', '60'); dot.setAttribute('r', '3');
dot.setAttribute('class', 'radar-glyph-dot');
svg.append(dot);
return svg;
}
// ════════════════════════════════════════════════════════════════════════════
// DETAIL DRAWER
// ════════════════════════════════════════════════════════════════════════════
let drawer = null;
let drawerAbort = null;
let lastFocused = null;
// Kept in sync with corner-stack.js's MODAL_CLASS, which that script also
// publishes on window.twsCornerStack once it has run. The literal is the
// fallback for the moment before the deferred script mounts.
const CORNER_MODAL_CLASS = 'tws-modal-open';
function ensureDrawer() {
if (drawer) return drawer;
const scrim = el('div', 'radar-drawer-scrim');
scrim.id = 'radar-drawer';
scrim.hidden = true;
scrim.addEventListener('click', (e) => { if (e.target === scrim) closeDrawer(); });
const panel = el('aside', 'radar-drawer-panel');
panel.setAttribute('role', 'dialog');
panel.setAttribute('aria-modal', 'true');
panel.setAttribute('aria-label', 'Coin intelligence detail');
panel.tabIndex = -1;
scrim.append(panel);
document.body.append(scrim);
document.addEventListener('keydown', (e) => {
if (scrim.hidden) return;
if (e.key === 'Escape') { e.preventDefault(); closeDrawer(); }
if (e.key === 'Tab') trapFocus(e, panel);
});
drawer = { scrim, panel };
return drawer;
}
function trapFocus(e, panel) {
const f = panel.querySelectorAll('a[href], button:not([disabled]), [tabindex]:not([tabindex="-1"])');
if (!f.length) return;
const first = f[0], last = f[f.length - 1];
if (e.shiftKey && document.activeElement === first) { e.preventDefault(); last.focus(); }
else if (!e.shiftKey && document.activeElement === last) { e.preventDefault(); first.focus(); }
}
async function openDrawer(mint) {
const { scrim, panel } = ensureDrawer();
lastFocused = document.activeElement;
scrim.hidden = false;
document.body.classList.add('radar-no-scroll');
// The shared corner stack (public/corner-stack.js) renders above every page
// layer, so its widgets stayed clickable on top of this drawer and swallowed
// whatever control they covered (the language switcher sat on the mint row's
// Copy button). This is the flag that stack watches for.
document.body.classList.add(CORNER_MODAL_CLASS);
requestAnimationFrame(() => scrim.classList.add('is-open'));
panel.innerHTML = '';
panel.append(drawerHeader('Loading intel…', null, null));
const load = el('div', 'rd-loading');
for (let i = 0; i < 5; i++) load.append(el('div', 'sk sk-bar'));
panel.append(load);
panel.focus();
if (drawerAbort) drawerAbort.abort();
drawerAbort = new AbortController();
const net = state.network;
try {
const r = await fetch(`/api/pump/coin-intel?mint=${encodeURIComponent(mint)}&wallets=1&network=${net}`, {
headers: { accept: 'application/json' },
signal: drawerAbort.signal,
});
if (r.status === 404) { renderDrawerNotFound(panel, mint); return; }
if (!r.ok) throw new Error(`detail HTTP ${r.status}`);
const coin = await r.json();
renderDrawerContent(panel, coin);
} catch (err) {
if (err.name === 'AbortError') return;
log.error('detail fetch failed:', err.message || err);
renderDrawerError(panel, mint);
}
}
function closeDrawer() {
if (!drawer) return;
drawer.scrim.classList.remove('is-open');
document.body.classList.remove('radar-no-scroll');
document.body.classList.remove(CORNER_MODAL_CLASS);
if (drawerAbort) { drawerAbort.abort(); drawerAbort = null; }
const scrim = drawer.scrim;
const onEnd = () => { scrim.hidden = true; scrim.removeEventListener('transitionend', onEnd); };
scrim.addEventListener('transitionend', onEnd);
setTimeout(() => { if (!scrim.hidden) onEnd(); }, 320);
if (lastFocused && typeof lastFocused.focus === 'function') lastFocused.focus();
}
function drawerHeader(title, sub, coin) {
const head = el('div', 'rd-head');
const titleWrap = el('div', 'rd-head-id');
if (coin) {
const img = el('img', 'rd-img');
img.width = 44; img.height = 44; img.alt = ''; img.loading = 'lazy';
const seed = coin.symbol || coin.name || coin.mint || 'coin';
img.src = coin.image_uri && /^https?:\/\//i.test(coin.image_uri)
? `/api/img?url=${encodeURIComponent(coin.image_uri)}&seed=${encodeURIComponent(seed)}`
: `/api/img?seed=${encodeURIComponent(seed)}`;
img.addEventListener('error', () => { img.src = `/api/img?seed=${encodeURIComponent(seed)}`; }, { once: true });
titleWrap.append(img);
}
const txt = el('div');
txt.append(el('h2', 'rd-title', title));
if (sub) txt.append(el('div', 'rd-sub', sub));
// The drawer is the quick view; surface the full-page link right at the top
// so the deep coin page is one click away, not buried below the ledger.
if (coin && coin.network !== 'devnet') {
const page = el('a', 'rd-page-link', 'Open full page →');
page.href = `/oracle/coin/${coin.mint}`;
txt.append(page);
}
titleWrap.append(txt);
const close = el('button', 'rd-close');
close.type = 'button';
close.setAttribute('aria-label', 'Close detail');
close.innerHTML = '<svg viewBox="0 0 20 20" width="18" height="18" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M5 5l10 10M15 5L5 15"/></svg>';
close.addEventListener('click', closeDrawer);
head.append(titleWrap, close);
return head;
}
function renderDrawerNotFound(panel, mint) {
panel.innerHTML = '';
panel.append(drawerHeader('Not observed', short(mint, 6, 6), null));
const box = el('div', 'rd-section');
box.append(el('p', 'radar-state-text', 'This coin has no intelligence record. It may have launched before the engine started watching, or be too old — the engine only retains coins it observed live.'));
const scan = el('a', 'radar-btn radar-btn--ghost', 'View on Solscan →');
scan.href = solscanToken(mint, state.network); scan.target = '_blank'; scan.rel = 'noopener noreferrer';
box.append(scan);
panel.append(box);
}
function renderDrawerError(panel, mint) {
panel.innerHTML = '';
panel.append(drawerHeader('Could not load intel', short(mint, 6, 6), null));
const box = el('div', 'rd-section');
box.setAttribute('role', 'alert');
box.append(el('p', 'radar-state-text', 'The detail request failed. Try again in a moment.'));
const retry = el('button', 'radar-btn', 'Retry');
retry.type = 'button';
retry.addEventListener('click', () => openDrawer(mint));
box.append(retry);
panel.append(box);
}
function renderDrawerContent(panel, coin) {
panel.innerHTML = '';
panel.append(drawerHeader(
coin.name || 'Unnamed coin',
`${coin.symbol ? '$' + coin.symbol + ' · ' : ''}${CATEGORY_LABEL[coin.category] || 'Unknown'} · observed ${coin.observation_seconds ?? '—'}s`,
coin,
));
// headline: ring + organic/bundle + outcome
const headline = el('div', 'rd-headline');
headline.append(renderRing(coin.quality_score));
headline.append(renderOrganicBundle(coin));
panel.append(headline);
if (coin.outcome && coin.outcome.outcome) panel.append(renderOutcome(coin.outcome));
if (coin.narrative) {
const sec = el('div', 'rd-section');
sec.append(el('h3', 'rd-h3', 'Narrative'));
sec.append(el('p', 'rd-narrative', coin.narrative));
if (coin.classify_source) {
sec.append(el('p', 'rd-meta', `Classified by ${coin.classify_source}${coin.classify_confidence != null ? ` · ${pct(coin.classify_confidence)}% confidence` : ''}`));
}
panel.append(sec);
}
// news-meme provenance
if (coin.is_news_meme && coin.news_headline) {
const newsSec = el('div', 'rd-section rd-news');
newsSec.append(el('h3', 'rd-h3', 'News-driven'));
const row = el('div', 'rd-news-row');
row.append(el('span', 'rd-news-glyph', '⚡'));
const body = el('div');
body.append(el('p', 'rd-news-headline', coin.news_headline));
if (coin.news_url && /^https?:\/\//i.test(coin.news_url)) {
const a = el('a', 'rd-news-link', 'Read source →');
a.href = coin.news_url; a.target = '_blank'; a.rel = 'noopener noreferrer';
body.append(a);
}
row.append(body);
newsSec.append(row);
panel.append(newsSec);
}
// smart money
const notable = Array.isArray(coin.smart_money_notable) ? coin.smart_money_notable : [];
if (coin.smart_money_count > 0 || notable.length) {
const smSec = el('div', 'rd-section');
smSec.append(el('h3', 'rd-h3', 'Smart money'));
const summary = el('div', 'rd-sm-summary');
summary.append(smChip(`${coin.smart_money_count} wallet${coin.smart_money_count === 1 ? '' : 's'}`));
if (coin.smart_money_score != null) summary.append(smChip(`Pedigree ${Math.round(coin.smart_money_score)}/100`));
smSec.append(summary);
smSec.append(el('p', 'rd-meta', 'Buyers whose prior launches give them a reputation score — the highest-signal early tell the engine measures.'));
if (notable.length) {
const list = el('div', 'rd-sm-list');
for (const w of notable.slice(0, 5)) {
const item = el('div', 'rd-sm-item');
const left = el('div', 'rd-sm-left');
const a = el('a', 'rd-waddr', w.label || short(w.wallet, 4, 4));
a.href = solscanAccount(w.wallet, coin.network); a.target = '_blank'; a.rel = 'noopener noreferrer';
a.title = w.wallet;
left.append(a);
if (w.win_rate != null) {
const wins = w.wins != null && w.duds != null ? ` · ${w.wins}W/${w.duds}L` : '';
left.append(el('span', 'rd-sm-stat', `${Math.round(w.win_rate * 100)}% win${wins}`));
}
item.append(left);
if (w.smart_money_score != null) {
const sc = el('span', 'rd-sm-score', String(Math.round(w.smart_money_score)));
item.append(sc);
}
list.append(item);
}
smSec.append(list);
}
panel.append(smSec);
}
// risk flags
const flagsSec = el('div', 'rd-section');
flagsSec.append(el('h3', 'rd-h3', 'Risk flags'));
const flags = coin.risk_flags || [];
if (flags.length) {
const list = el('div', 'rd-flags');
for (const f of flags) {
const meta = FLAG_META[f] || { label: f.replace(/_/g, ' '), tone: 'warn', tip: '' };
const row = el('div', `rd-flag rd-flag--${meta.tone}`);
row.append(el('span', 'rd-flag-name', meta.label));
if (meta.tip) row.append(el('span', 'rd-flag-tip', meta.tip));
list.append(row);
}
flagsSec.append(list);
} else {
flagsSec.append(el('p', 'rd-meta', 'No risk flags raised during observation.'));
}
panel.append(flagsSec);
// signal breakdown
const sig = el('div', 'rd-section');
sig.append(el('h3', 'rd-h3', 'Signal breakdown'));
const grid = el('div', 'rd-signals');
const sigRow = (label, val, tip) => {
const r = el('div', 'rd-sig');
const l = el('span', 'rd-sig-label', label);
if (tip) l.title = tip;
r.append(l, el('span', 'rd-sig-val', val));
return r;
};
const ratio = (v) => (v == null ? 'not measured' : pct(v) + '%');
grid.append(sigRow('Organic score', ratio(coin.organic_score)));
grid.append(sigRow('Bundle score', ratio(coin.bundle_score)));
grid.append(sigRow('Coordination', ratio(coin.coordination_score), 'Blended bundle + funding-graph coordination signal'));
grid.append(sigRow('Snipe ratio', ratio(coin.snipe_ratio), 'Share of early supply taken by snipers'));
grid.append(sigRow('Top-10 concentration', ratio(coin.concentration_top10), 'Share of supply held by the top 10 wallets'));
grid.append(sigRow('Top-5 concentration', ratio(coin.concentration_top5), 'Share of supply held by the top 5 wallets'));
grid.append(sigRow('Fresh-wallet ratio', ratio(coin.fresh_wallet_ratio), 'Share of buyers using brand-new wallets'));
grid.append(sigRow('Bubblemap connectivity', ratio(coin.bubblemap_connectivity), 'How interlinked the buyer wallets are by funding'));
grid.append(sigRow('Funding clusters', coin.cluster_count != null ? fmtInt(coin.cluster_count) : '—', 'Distinct funding clusters among buyers'));
grid.append(sigRow('Market cap (first seen)', coin.market_cap_sol != null ? fmtSol(coin.market_cap_sol) + ' ◎' : 'not measured', 'Market cap in SOL when the engine began observing'));
grid.append(sigRow('Unique buyers', fmtInt(coin.unique_buyers)));
grid.append(sigRow('Unique sellers', fmtInt(coin.unique_sellers)));
grid.append(sigRow('Buys / sells', `${fmtInt(coin.buy_count)} / ${fmtInt(coin.sell_count)}`));
grid.append(sigRow('Buy/sell ratio', coin.buy_sell_ratio != null ? coin.buy_sell_ratio.toFixed(2) + '×' : '—', 'Buy volume divided by sell volume'));
grid.append(sigRow('Buy / sell volume', `${coin.buy_volume_sol != null ? fmtSol(coin.buy_volume_sol) : '—'} / ${coin.sell_volume_sol != null ? fmtSol(coin.sell_volume_sol) : '—'} ◎`));
grid.append(sigRow('Net flow', coin.net_volume_sol != null ? (coin.net_volume_sol > 0 ? '+' : '') + fmtSol(coin.net_volume_sol) + ' ◎' : '—', 'Buy volume minus sell volume'));
grid.append(sigRow('Dev buy', coin.dev_buy_sol != null ? fmtSol(coin.dev_buy_sol) + ' ◎' : '—'));
grid.append(sigRow('Dev sold', coin.dev_sold ? 'Yes' : 'No'));
grid.append(sigRow('Largest buy', coin.largest_buy_sol != null ? fmtSol(coin.largest_buy_sol) + ' ◎' : '—'));
sig.append(grid);
panel.append(sig);
// tags
if (Array.isArray(coin.tags) && coin.tags.length) {
const tagSec = el('div', 'rd-section');
tagSec.append(el('h3', 'rd-h3', 'Tags'));
const tw = el('div', 'rd-tags');
for (const t of coin.tags) tw.append(el('span', 'rd-tag', t));
tagSec.append(tw);
panel.append(tagSec);
}
// wallet ledger
panel.append(renderWalletLedger(coin));
// Oracle conviction — async injection after drawer is visible
const oracleSec = el('div', 'rd-section rd-oracle');
const oracleSk = el('div', 'rd-oracle-sk');
oracleSec.append(el('h3', 'rd-h3', 'Oracle conviction'));
oracleSec.append(oracleSk);
panel.append(oracleSec);
// links + socials
const links = el('div', 'rd-section rd-links');
if (coin.network !== 'devnet') {
const page = el('a', 'radar-btn', 'Full coin page →');
page.href = `/oracle/coin/${coin.mint}`;
links.append(page);
}
const scan = el('a', 'radar-btn radar-btn--ghost', 'Solscan');
scan.href = solscanToken(coin.mint, coin.network); scan.target = '_blank'; scan.rel = 'noopener noreferrer';
links.append(scan);
const s = coin.socials || {};
if (s.twitter) links.append(socialLink('Twitter', s.twitter));
if (s.telegram) links.append(socialLink('Telegram', s.telegram));
if (s.website) links.append(socialLink('Website', s.website));
panel.append(links);
// Fetch Oracle conviction async and inject into the already-visible section
if (coin.network !== 'devnet') {
const TIER_META = {
prime: { label: 'PRIME', color: '#c084fc', bg: 'rgba(192,132,252,.14)' },
strong: { label: 'STRONG', color: '#34d399', bg: 'rgba(52,211,153,.12)' },
lean: { label: 'LEAN', color: '#fbbf24', bg: 'rgba(251,191,36,.12)' },
watch: { label: 'WATCH', color: '#94a3b8', bg: 'rgba(148,163,184,.1)' },
avoid: { label: 'AVOID', color: '#f87171', bg: 'rgba(248,113,113,.12)' },
};
const PILLAR_COLORS = { pedigree: '#5fe3ff', structure: '#34d399', narrative: '#a07bff', momentum: '#fbbf24' };
fetch(`/api/oracle/coin?mint=${encodeURIComponent(coin.mint)}`)
.then(r => r.ok ? r.json() : null)
.catch(() => null)
.then(data => {
if (!oracleSec.isConnected) return;
const cv = data?.conviction;
if (!cv) {
oracleSk.replaceWith(el('p', 'rd-meta', 'No Oracle score yet for this coin.'));
return;
}
const tier = cv.tier || 'watch';
const meta = TIER_META[tier] || TIER_META.watch;
const score = Math.round(Number(cv.score ?? 0));
const pillars = cv.pillars || {};
const head = el('div', 'rd-oracle-head');
const dial = el('div', 'rd-oracle-dial');
const scoreEl = el('span', 'rd-oracle-score', String(score));
scoreEl.style.color = meta.color;
const maxEl = el('span', 'rd-oracle-max', '/100');
const badge = el('span', 'rd-oracle-badge', meta.label);
badge.style.cssText = `background:${meta.bg};color:${meta.color};border-color:${meta.color}40`;
dial.append(scoreEl, maxEl);
head.append(dial, badge);
const pillarRow = el('div', 'rd-oracle-pillars');
for (const key of ['pedigree', 'structure', 'narrative', 'momentum']) {
const val = Math.round(Number(pillars[key] ?? 0));
const row = el('div', 'rd-oracle-pillar');
const label = el('span', 'rd-oracle-pillar-label', key);
const bar = el('div', 'rd-oracle-pillar-bar');
const fill = el('div', 'rd-oracle-pillar-fill');
fill.style.cssText = `width:${val}%;background:${PILLAR_COLORS[key]}`;
const valEl = el('span', 'rd-oracle-pillar-val', String(val));
bar.append(fill);
row.append(label, bar, valEl);
pillarRow.append(row);
}
const link = el('a', 'radar-btn radar-btn--ghost rd-oracle-link', 'Full conviction →');
link.href = `/oracle/coin/${encodeURIComponent(coin.mint)}`;
link.target = '_blank';
link.rel = 'noopener noreferrer';
link.style.cssText = 'color:' + meta.color + ';border-color:' + meta.color + '40;margin-top:8px';
const body = el('div', 'rd-oracle-body');
body.append(head, pillarRow, link);
oracleSk.replaceWith(body);
});
} else {
oracleSec.remove();
}
const id = el('div', 'rd-mint');
id.append(el('span', null, 'Mint'));
const code = el('code', null, coin.mint);
const copy = el('button', 'rd-copy', 'Copy');
copy.type = 'button';
copy.addEventListener('click', async () => {
const ok = await writeClipboard(coin.mint);
copy.textContent = ok ? 'Copied' : 'Copy failed';
setTimeout(() => { copy.textContent = 'Copy'; }, 1400);
});
id.append(code, copy);
panel.append(id);
// focus close for keyboard users
const close = panel.querySelector('.rd-close');
if (close) close.focus();
}
// Clipboard API first; on a browser or context that refuses it (an insecure
// origin, a denied permission) fall back to a scratch textarea so the mint
// button still copies instead of only reporting failure. Mirrors the same
// helper in src/converter.js.
async function writeClipboard(text) {
if (navigator.clipboard?.writeText) {
try {
await navigator.clipboard.writeText(text);
return true;
} catch {
// Permission denied or an insecure context: try the fallback below.
}
}
const ta = document.createElement('textarea');
ta.value = text;
ta.setAttribute('readonly', '');
ta.style.cssText = 'position:fixed;top:0;left:-9999px;opacity:0';
document.body.appendChild(ta);
ta.select();
let ok = false;
try {
ok = document.execCommand('copy');
} catch {
ok = false;
}
ta.remove();
return ok;
}
function smChip(text) {
return el('span', 'rd-sm-chip', text);
}
function socialLink(label, href) {
const a = el('a', 'radar-btn radar-btn--ghost', label);
const safe = /^https?:\/\//i.test(href) ? href : ('https://' + href);
a.href = safe; a.target = '_blank'; a.rel = 'noopener noreferrer';
return a;
}
function renderOutcome(o) {
const sec = el('div', 'rd-section rd-outcome');
const tone = o.rugged ? 'danger' : o.graduated ? 'success' : 'neutral';
sec.classList.add('rd-outcome--' + tone);
const labelMap = { graduated: 'Graduated', rugged: 'Rugged' };
const word = o.rugged ? 'Rugged' : o.graduated ? 'Graduated' : (labelMap[o.outcome] || o.outcome);
const row = el('div', 'rd-outcome-row');
row.append(el('span', 'rd-outcome-badge', word));
if (o.ath_multiple != null) row.append(el('span', 'rd-outcome-stat', `ATH ${o.ath_multiple.toFixed(1)}×`));
if (o.ath_market_cap_usd != null) row.append(el('span', 'rd-outcome-stat', `ATH MC $${Math.round(o.ath_market_cap_usd).toLocaleString()}`));
if (o.last_market_cap_usd != null) row.append(el('span', 'rd-outcome-stat', `Now $${Math.round(o.last_market_cap_usd).toLocaleString()}`));
sec.append(el('h3', 'rd-h3', 'Labeled outcome'), row);
return sec;
}
function renderWalletLedger(coin) {
const sec = el('div', 'rd-section');
sec.append(el('h3', 'rd-h3', 'Top trader ledger'));
const wallets = Array.isArray(coin.wallets) ? coin.wallets : [];
if (!wallets.length) {
sec.append(el('p', 'rd-meta', 'No per-wallet ledger available for this coin.'));
return sec;
}
const tableWrap = el('div', 'rd-table-wrap');
const table = el('table', 'rd-table');
const thead = el('thead');
const htr = el('tr');
['Wallet', 'Buy ◎', 'Sell ◎', 'Net ◎'].forEach((h, i) => {
const th = el('th', i === 0 ? null : 'rd-num', h);
th.scope = 'col';
htr.append(th);
});
thead.append(htr);
table.append(thead);
const tbody = el('tbody');
for (const w of wallets) {
const tr = el('tr');
const wcell = el('td', 'rd-wcell');
const a = el('a', 'rd-waddr', short(w.wallet, 4, 4));
a.href = solscanAccount(w.wallet, coin.network);
a.target = '_blank'; a.rel = 'noopener noreferrer';
a.title = w.wallet;
wcell.append(a);
if (w.is_creator) wcell.append(el('span', 'rd-wtag', 'creator'));
tr.append(wcell);
tr.append(el('td', 'rd-num', w.buy_sol != null ? fmtSol(w.buy_sol) : '—'));
tr.append(el('td', 'rd-num', w.sell_sol != null ? fmtSol(w.sell_sol) : '—'));
const net = el('td', 'rd-num ' + (w.net_sol > 0 ? 'rd-pos' : w.net_sol < 0 ? 'rd-neg' : ''), w.net_sol != null ? (w.net_sol > 0 ? '+' : '') + fmtSol(w.net_sol) : '—');
tr.append(net);
tbody.append(tr);
}
table.append(tbody);
tableWrap.append(table);
sec.append(tableWrap);
return sec;
}
// ════════════════════════════════════════════════════════════════════════════
// MOUNT
// ════════════════════════════════════════════════════════════════════════════
export function mountRadar(mountEl) {
root = mountEl;
readUrl();
// An inbound ?fork=<mint> link opens the real trade panel on arrival. Runs
// before the first writeUrl() rewrites the query string.
initFork();
render();
fetchFeed();
fetchPulse();
startPolling();
// keep "updated Xs ago" ticking without re-rendering the grid
setInterval(updateUpdatedLabel, 1000);
document.addEventListener('visibilitychange', () => {
if (!document.hidden) { fetchFeed({ silent: true }); fetchPulse(); }
});
bindShortcuts();
}
// Keyboard shortcuts — power-user affordances that don't get in the way:
// / focus search · g/l grid/list · r refresh now
function bindShortcuts() {
document.addEventListener('keydown', (e) => {
if (e.metaKey || e.ctrlKey || e.altKey) return;
const drawerOpen = drawer && !drawer.scrim.hidden;
if (drawerOpen) return;
const t = e.target;
const typing = t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.tagName === 'SELECT' || t.isContentEditable);
if (e.key === '/' && !typing) {
e.preventDefault();
const input = root && root.querySelector('#radar-search');
if (input) input.focus();
return;
}
if (typing) return;
if (e.key === 'g' && state.view !== 'grid') { state.view = 'grid'; writeUrl(); render(); }
else if (e.key === 'l' && state.view !== 'list') { state.view = 'list'; writeUrl(); render(); }
else if (e.key === 'r') { e.preventDefault(); fetchFeed(); fetchPulse(); }
});
}