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
// Oracle — the fused pump.fun conviction war room.
//
// Reads /api/oracle/* (feed, coin, wallet, stream, watch, trades). Every
// surface degrades gracefully: if the backend isn't reachable yet (it deploys
// with the migration), the page shows an honest "warming up" state instead of
// breaking.
//
// Views: live conviction feed (with SSE), wallet reputation leaderboard,
// conviction-tier edge backtest, the agent action-loop arm panel, and the 3D
// force graph. The coin drawer also streams live trades via oracle-tape.js.
import { proxiedImageURL } from './ipfs.js';
import { gmgnTokenUrl } from './shared/trading-terminals.js';
import { shortAddress as shortAddr } from './shared/address.js';
import { loadTelegramChat, telegramLoginUrl, telegramActionError, TELEGRAM_LINK_URL } from './oracle-telegram.js';
const NETWORK = 'mainnet';
const $ = (s, r = document) => r.querySelector(s);
const $$ = (s, r = document) => [...r.querySelectorAll(s)];
// ── watchlist helpers (same key as launch-detail.js and watchlist.js) ────────
const WATCH_KEY = 'ld_watchlist';
function watchedMints() {
try { return new Set(JSON.parse(localStorage.getItem(WATCH_KEY) || '[]')); } catch { return new Set(); }
}
function toggleOracleWatch(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; }
}
// ── tiny helpers ─────────────────────────────────────────────────────────────
function setMeta(prop, content) {
let el = document.querySelector(`meta[property="${prop}"], meta[name="${prop}"]`);
if (!el) {
el = document.createElement('meta');
document.head.appendChild(el);
}
el.setAttribute(prop.startsWith('og:') || prop.startsWith('twitter:') ? 'property' : 'name', prop);
el.setAttribute('content', content || '');
}
const esc = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&', '<': '<', '>': '>', '"': '"', "'": ''' }[c]));
// ── token / NFT art proxy ────────────────────────────────────────────────────
// Route every remote image through the same-origin proxy (api/img.js) instead of
// hot-linking public IPFS gateways. Those gateways (ipfs.io, pinata, …) answer
// cross-origin <img> loads with no CORS/content-type headers the browser trusts,
// so it ORB-blocks them (net::ERR_BLOCKED_BY_ORB) and every piece of art on the
// page fails. The proxy fetches server-side across a gateway fallback list and
// ALWAYS returns a valid image — the real art or an on-brand placeholder — so the
// loader never sees a broken-image icon. Same pattern as src/radar.js.
//
// Returns the `src` + fallback attributes for an <img>. `seed` should be a stable
// per-token identifier (mint, symbol) so a given coin's placeholder art is unique
// and identical across loads. On error the shared handler in
// public/inline-behaviors.js swaps to the seed-only placeholder (no upstream
// URL) exactly once, so a placeholder that itself fails cannot spin an error
// loop, and `data-fallback="keep"` leaves the element in place after that
// rather than pulling it out of the grid.
//
// Seeds are attacker-controlled (a pump.fun launcher picks the token symbol), so
// both URLs only ever land in esc()'d attribute values and never inside a script
// body, which is what an inline onerror would have made them.
function proxyImgAttrs(rawUrl, seed) {
const s = String(seed || 'coin');
const placeholder = `/api/img?${new URLSearchParams({ seed: s })}`;
// Only remote art is proxied. Anything else — a javascript:/data: URI reaching
// us through a creator-controlled feed — degrades to the placeholder instead.
const src = rawUrl && /^(https?|ipfs|ar):\/\//i.test(String(rawUrl))
? proxiedImageURL(String(rawUrl), s)
: placeholder;
return `src="${esc(src)}" data-fallback-src="${esc(placeholder)}" data-fallback="keep"`;
}
const fmtSol = (n) => (n == null ? '—' : `${Number(n) < 0.01 && Number(n) > 0 ? Number(n).toFixed(4) : Number(n).toFixed(2)}◎`);
const fmtPct = (n) => (n == null ? '—' : `${Math.round(Number(n))}%`);
// Compact USD for market stats: $2.1M, $465K, $1.2B, $0.00.
function fmtUsd(n) {
if (n == null || !Number.isFinite(Number(n))) return '—';
const v = Number(n);
const abs = Math.abs(v);
if (abs >= 1e9) return `$${(v / 1e9).toFixed(2)}B`;
if (abs >= 1e6) return `$${(v / 1e6).toFixed(2)}M`;
if (abs >= 1e3) return `$${(v / 1e3).toFixed(1)}K`;
return `$${v.toFixed(2)}`;
}
// Token price: keep 3–4 significant figures for sub-cent memecoins.
function fmtPrice(n) {
if (n == null || !Number.isFinite(Number(n))) return '—';
const v = Number(n);
if (v === 0) return '$0';
if (v >= 1) return `$${v.toLocaleString(undefined, { maximumFractionDigits: 4 })}`;
const decimals = Math.min(12, Math.max(4, 3 - Math.floor(Math.log10(v))));
return `$${v.toFixed(decimals)}`;
}
const fmtInt = (n) => (n == null || !Number.isFinite(Number(n)) ? '—' : Math.round(Number(n)).toLocaleString());
// Signed percent with an up/down class — for price-change chips.
function changeStr(n) {
if (n == null || !Number.isFinite(Number(n))) return { txt: '—', cls: 'flat' };
const v = Number(n);
const cls = v > 0 ? 'up' : v < 0 ? 'down' : 'flat';
const txt = `${v > 0 ? '+' : ''}${v.toFixed(v <= -100 || v >= 100 ? 0 : 2)}%`;
return { txt, cls };
}
const tierClass = (t) => `t-${t || 'avoid'}`;
const tierPill = (t) => `tp-${t || 'avoid'}`;
function ago(ts) {
if (!ts) return '—';
const s = Math.max(0, (Date.now() - new Date(ts).getTime()) / 1000);
if (s < 60) return `${Math.floor(s)}s`;
if (s < 3600) return `${Math.floor(s / 60)}m`;
if (s < 86400) return `${Math.floor(s / 3600)}h`;
return `${Math.floor(s / 86400)}d`;
}
function solscan(addr) { return `https://solscan.io/account/${addr}`; }
function pumpUrl(mint) { return `https://pump.fun/coin/${mint}`; }
function winTweet(w) {
const sym = (w.symbol || w.mint.slice(0, 6)).toUpperCase();
const ath = w.ath_multiple != null ? `${Number(w.ath_multiple).toFixed(1)}×` : 'graduated';
const score = w.score != null ? `${w.score}/100 ${w.tier}` : w.tier;
const shareUrl = coinShareUrl(w.mint);
const text = `Oracle called $${sym} (${score} conviction) — it went ${ath} 🔮\n\nproof.not.promises @trythreews\n${shareUrl}`;
return `https://twitter.com/intent/tweet?text=${encodeURIComponent(text)}`;
}
function coinShareUrl(mint) {
return `https://three.ws/oracle/coin/${encodeURIComponent(mint)}`;
}
function tweetConviction(c) {
const tier = c.tier || 'watch';
const score = c.score ?? '—';
const symbol = c.symbol || '—';
const shareUrl = coinShareUrl(c.mint);
const text = `$${symbol} — ${score}/100 ${tier} conviction on @trythreews Oracle\n\nWho · How · What · Move all fused into one score.\n${shareUrl}`;
return `https://twitter.com/intent/tweet?text=${encodeURIComponent(text)}`;
}
const CATEGORIES = ['meme', 'tech', 'ai', 'culture', 'community', 'political', 'news', 'animal', 'celebrity', 'utility', 'unknown'];
const TIER_ORDER = ['prime', 'strong', 'lean', 'watch', 'avoid'];
const TIER_COLOR = { prime: '#e8ebf2', strong: '#cdd2e0', lean: '#c4c9d6', watch: '#8a92a8', avoid: '#6c7280' };
const ARCH_TITLE = {
smart_money: 'Smart Money', kol: 'KOL', top_dev: 'Top Dev', sniper: 'Sniper',
dumper: 'Dumper', rugger: 'Rugger', fresh: 'Fresh', neutral: 'Neutral', unproven: 'Unproven',
};
async function api(path, opts = {}) {
const ctrl = new AbortController();
const to = setTimeout(() => ctrl.abort(), opts.timeout || 12000);
try {
const res = await fetch(path, { credentials: 'include', signal: ctrl.signal, ...opts });
const data = await res.json().catch(() => null);
return { ok: res.ok, status: res.status, data };
} catch {
return { ok: false, status: 0, data: null };
} finally {
clearTimeout(to);
}
}
// ── failure states ────────────────────────────────────────────────
// A request that never landed is not an empty result. Telling a user "nothing
// scored yet" when the fetch actually failed sends them away from a working
// product, so every panel that loads over the network renders this instead:
// what broke, whether it is on us or on their connection, and a retry.
// Plain-language cause, derived from the transport status api() hands back:
// 0 means the request never completed (offline, DNS, timeout, blocked).
function failureCause(status) {
if (!status) return 'The request did not complete. Check your connection, then try again.';
if (status === 429) return 'Oracle is rate limiting right now. Give it a few seconds, then retry.';
if (status >= 500) return 'The conviction engine returned an error. This is on us and usually clears in a moment.';
return `The conviction engine answered with HTTP ${status}. Retrying usually clears it.`;
}
// One designed error block, wired to a retry. `onRetry` runs on click; the
// button id is scoped per panel so two open panels never collide.
function renderFailure(el, { title, status, retryId, onRetry, gridSpan = false }) {
if (!el) return;
const span = gridSpan ? ' style="grid-column:1/-1"' : '';
el.innerHTML = `<div class="state"${span}><b>${esc(title)}</b>${esc(failureCause(status))}<div style="margin-top:14px"><button class="btn" type="button" id="${retryId}">Retry now</button></div></div>`;
const btn = el.querySelector(`#${retryId}`);
if (btn && onRetry) {
btn.addEventListener('click', () => {
btn.disabled = true;
btn.textContent = 'Retrying\u2026';
onRetry();
});
}
}
// ── state ────────────────────────────────────────────────────────────────────
const state = {
view: 'feed',
tier: '',
category: '',
minScore: 0,
sort: 'score', // 'score' | 'hot' | 'new'
watchOnly: false, // feed filtered to the local watchlist
label: '',
feed: new Map(), // mint -> item, preserves SSE + initial load
es: null,
agents: [],
agentId: null,
watch: null,
tape: null, // { destroy() } handle from oracle-tape.js
};
// ── boot ─────────────────────────────────────────────────────────────────────
function boot() {
// populate category filter
const catSel = $('#catSel');
for (const c of CATEGORIES) {
const o = document.createElement('option');
o.value = c; o.textContent = c[0].toUpperCase() + c.slice(1);
catSel.appendChild(o);
}
// tabs — click + full keyboard support (roving tabindex per ARIA tablist).
const tabs = $$('.tab');
tabs.forEach((t, i) => {
t.setAttribute('aria-selected', String(i === 0));
t.tabIndex = i === 0 ? 0 : -1;
t.addEventListener('click', () => switchView(t.dataset.view));
t.addEventListener('keydown', (e) => {
const dir = e.key === 'ArrowRight' || e.key === 'ArrowDown' ? 1
: e.key === 'ArrowLeft' || e.key === 'ArrowUp' ? -1 : 0;
if (dir) {
e.preventDefault();
const next = tabs[(i + dir + tabs.length) % tabs.length];
next.focus(); switchView(next.dataset.view);
} else if (e.key === 'Home') {
e.preventDefault(); tabs[0].focus(); switchView(tabs[0].dataset.view);
} else if (e.key === 'End') {
e.preventDefault(); tabs[tabs.length - 1].focus(); switchView(tabs[tabs.length - 1].dataset.view);
}
});
});
// filters
$('#tierSeg').addEventListener('click', (e) => {
const b = e.target.closest('button'); if (!b) return;
$$('#tierSeg button').forEach((x) => x.classList.toggle('on', x === b));
state.tier = b.dataset.tier; syncFilterUrl(); loadFeed();
});
$('#catSel').addEventListener('change', (e) => {
state.category = e.target.value;
syncFilterUrl();
loadFeed();
$$('#hotSectors .hs-card').forEach((c) => c.classList.toggle('active', c.dataset.cat === state.category && !!state.category));
});
$('#minSel').addEventListener('change', (e) => { state.minScore = Number(e.target.value) || 0; syncFilterUrl(); loadFeed(); });
$('#sortSeg').addEventListener('click', (e) => {
const b = e.target.closest('[data-fsort]'); if (!b) return;
$$('#sortSeg button').forEach((x) => x.classList.toggle('on', x === b));
state.sort = b.dataset.fsort; syncFilterUrl(); renderFeed();
});
// Watchlist filter — folds the local ★ watchlist into the live feed.
$('#watchToggle')?.addEventListener('click', () => {
state.watchOnly = !state.watchOnly;
syncWatchToggleUi();
renderFeed();
});
// Conviction breadth bar — segments and legend chips filter the feed by tier.
$('#breadthBar')?.addEventListener('click', (e) => {
const el = e.target.closest('[data-tier]');
if (el) applyTierFilter(el.dataset.tier);
});
const MINT_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
const searchEl = $('#mintSearch');
let _searchTimer = null;
const _searchDrop = document.createElement('div');
_searchDrop.id = 'mintSearchDrop';
_searchDrop.className = 'ms-drop';
_searchDrop.style.display = 'none';
searchEl.parentNode?.insertBefore(_searchDrop, searchEl.nextSibling);
function closeSearchDrop() { _searchDrop.style.display = 'none'; _searchDrop.innerHTML = ''; }
// A dropdown that silently disappears reads as a broken search box, so a
// miss and an outage each say so in place, in the same surface.
function showSearchNote(text) {
_searchDrop.innerHTML = `<div class="ms-note" role="status">${esc(text)}</div>`;
_searchDrop.style.display = '';
}
async function doSymbolSearch(q) {
if (!q || q.length < 2) { closeSearchDrop(); return; }
const { ok, data } = await api(`/api/oracle/search?q=${encodeURIComponent(q)}&network=${NETWORK}&limit=8`);
// The box may have moved on while the request was in flight.
if (searchEl.value.trim() !== q) return;
if (!ok || !data) { showSearchNote('Search is unavailable right now. Try again in a moment.'); return; }
const items = data.items || [];
if (!items.length) { showSearchNote(`No scored coin matches “${q}”. Oracle only searches launches it has scored.`); return; }
const TCOL = { prime: '#e8ebf2', strong: '#e4e8f2', lean: '#c4c9d6', watch: '#8a92a8', avoid: '#6c7280' };
_searchDrop.innerHTML = items.map((it) => {
const col = TCOL[it.tier] || '#8a92a8';
const label = it.symbol || it.name || it.mint.slice(0, 8);
return `<button class="ms-item" data-mint="${esc(it.mint)}" type="button" aria-label="View ${esc(label)} conviction">
<span class="ms-sym">${esc(label)}</span>
<span class="ms-tier" style="color:${col}">${esc(it.tier || '')}${it.score != null ? ` ${it.score}` : ''}</span>
</button>`;
}).join('');
_searchDrop.style.display = '';
}
searchEl.addEventListener('input', () => {
const v = searchEl.value.trim();
clearTimeout(_searchTimer);
if (MINT_RE.test(v)) { closeSearchDrop(); return; }
_searchTimer = setTimeout(() => doSymbolSearch(v), 280);
});
searchEl.addEventListener('keydown', (e) => {
if (e.key === 'Escape') { closeSearchDrop(); return; }
if (e.key !== 'Enter') return;
const v = searchEl.value.trim();
if (MINT_RE.test(v)) { openCoin(v); searchEl.blur(); closeSearchDrop(); }
});
_searchDrop.addEventListener('click', (e) => {
const btn = e.target.closest('[data-mint]');
if (!btn) return;
openCoin(btn.dataset.mint);
searchEl.value = '';
closeSearchDrop();
searchEl.blur();
});
document.addEventListener('click', (e) => {
if (!searchEl.contains(e.target) && !_searchDrop.contains(e.target)) closeSearchDrop();
});
// movers filters
$('#movDirSeg')?.addEventListener('click', (e) => {
const b = e.target.closest('[data-movdir]'); if (!b) return;
$$('#movDirSeg button').forEach((x) => x.classList.toggle('on', x === b));
_moversState.direction = b.dataset.movdir; loadMovers(true);
});
$('#movHrSeg')?.addEventListener('click', (e) => {
const b = e.target.closest('[data-movhr]'); if (!b) return;
$$('#movHrSeg button').forEach((x) => x.classList.toggle('on', x === b));
_moversState.hours = Number(b.dataset.movhr); loadMovers(true);
});
$('#labelSeg').addEventListener('click', (e) => {
const b = e.target.closest('button'); if (!b) return;
$$('#labelSeg button').forEach((x) => x.classList.toggle('on', x === b));
state.label = b.dataset.label; loadWallets();
});
// proof filters
$('#proofTierSeg')?.addEventListener('click', (e) => {
const b = e.target.closest('[data-ptier]'); if (!b) return;
$$('#proofTierSeg button').forEach((x) => x.classList.toggle('on', x === b));
_proofState.tier = b.dataset.ptier; loadProof(true);
});
$('#proofPeriodSeg')?.addEventListener('click', (e) => {
const b = e.target.closest('[data-pperiod]'); if (!b) return;
$$('#proofPeriodSeg button').forEach((x) => x.classList.toggle('on', x === b));
_proofState.period = b.dataset.pperiod; loadProof(true);
});
$('#proofLoadMoreBtn')?.addEventListener('click', () => {
$('#proofLoadMoreBtn').disabled = true; loadProof(false);
});
// activity feed filters
$('#afModeSeg')?.addEventListener('click', (e) => {
const b = e.target.closest('[data-afmode]'); if (!b) return;
$$('#afModeSeg button').forEach((x) => x.classList.toggle('on', x === b));
_afState.mode = b.dataset.afmode; loadActivity(true);
});
$('#afTierSeg')?.addEventListener('click', (e) => {
const b = e.target.closest('[data-aftier]'); if (!b) return;
$$('#afTierSeg button').forEach((x) => x.classList.toggle('on', x === b));
_afState.tier = b.dataset.aftier; loadActivity(true);
});
$('#afOutcomeSeg')?.addEventListener('click', (e) => {
const b = e.target.closest('[data-afoutcome]'); if (!b) return;
$$('#afOutcomeSeg button').forEach((x) => x.classList.toggle('on', x === b));
_afState.outcome = b.dataset.afoutcome; loadActivity(true);
});
$('#afMoreBtn')?.addEventListener('click', () => {
$('#afMoreBtn').disabled = true; loadActivity(false);
});
// follow agent panel — delegated on the leaderboard container
document.addEventListener('click', (e) => {
const followBtn = e.target.closest('.lrow-follow');
if (!followBtn) return;
const entry = followBtn.closest('.al-entry');
if (!entry) return;
const panel = entry.querySelector('.follow-panel');
if (!panel) return;
const open = followBtn.getAttribute('aria-expanded') === 'true';
followBtn.setAttribute('aria-expanded', String(!open));
panel.hidden = open;
if (!open && !panel.dataset.loaded) {
panel.dataset.loaded = '1';
initFollowPanel(entry.dataset.agentId, panel);
}
});
// drawer close
$$('#drawer [data-close]').forEach((el) => el.addEventListener('click', closeDrawer));
document.addEventListener('keydown', (e) => { if (e.key === 'Escape') closeDrawer(); });
// Read initial filter state from URL — enables shareable filter links.
const qs = new URLSearchParams(location.search);
const VALID_TIERS = new Set(['prime', 'strong', 'lean', 'watch', 'avoid']);
const VALID_SORTS = new Set(['score', 'hot', 'new']);
const VALID_CATS = new Set(CATEGORIES);
const qTier = qs.get('tier') || '';
const qCategory = qs.get('category') || '';
const qMinScore = Math.max(0, Math.min(100, Number(qs.get('min_score')) || 0));
const qSort = qs.get('sort') || 'score';
if (VALID_TIERS.has(qTier)) { state.tier = qTier; const b = $(`#tierSeg [data-tier="${qTier}"]`); if (b) { $$('#tierSeg button').forEach((x) => x.classList.toggle('on', x === b)); } }
if (VALID_CATS.has(qCategory)) { state.category = qCategory; const s = $('#catSel'); if (s) s.value = qCategory; }
if (qMinScore) { state.minScore = qMinScore; const s = $('#minSel'); if (s) s.value = String(qMinScore); }
if (VALID_SORTS.has(qSort) && qSort !== 'score') { state.sort = qSort; const b = $(`#sortSeg [data-fsort="${qSort}"]`); if (b) { $$('#sortSeg button').forEach((x) => x.classList.toggle('on', x === b)); } }
wireStatActions();
syncWatchToggleUi();
setupShortcuts(tabs);
loadFeed();
loadHotSectors();
loadBreadth();
openStream();
// Keep the headline numbers honest while the page sits open: re-pull the
// global stats and the conviction-breadth read on a slow cadence, but only
// while the tab is visible so a backgrounded page costs nothing.
setInterval(() => {
if (document.hidden) return;
loadGlobalStats();
loadBreadth();
}, 60000);
// Restore the active tab from the URL hash so /oracle#wallets etc. deep-link,
// and keep the browser back/forward buttons stepping through views.
const hashView = location.hash.replace(/^#/, '');
if (VIEWS.includes(hashView) && hashView !== 'feed') switchView(hashView, { updateHash: false });
window.addEventListener('popstate', () => {
const v = location.hash.replace(/^#/, '') || 'feed';
switchView(VIEWS.includes(v) ? v : 'feed', { updateHash: false });
});
// If the page was opened with ?mint= (e.g. from a shared link or Telegram alert),
// open that coin's drawer immediately after the feed loads.
const MINT_RE2 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
const initialMint = qs.get('mint');
if (initialMint && MINT_RE2.test(initialMint)) openCoin(initialMint);
}
// Global keyboard shortcuts: "/" focuses search, 1–9 jump to a tab. Ignored
// while typing in a field or when a modifier is held.
function setupShortcuts(tabs) {
document.addEventListener('keydown', (e) => {
if (e.metaKey || e.ctrlKey || e.altKey) return;
const el = e.target;
const typing = el && (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.tagName === 'SELECT' || el.isContentEditable);
if (e.key === '/' && !typing) {
e.preventDefault();
const s = $('#mintSearch');
if (s) { switchView('feed'); s.focus(); s.select(); }
return;
}
if (typing) return;
if ($('#drawer')?.classList.contains('open')) return;
if (/^[1-9]$/.test(e.key)) {
const tab = tabs[Number(e.key) - 1];
if (tab) { e.preventDefault(); tab.focus(); switchView(tab.dataset.view); }
}
});
}
function syncFilterUrl() {
const url = new URL(location.href);
if (state.tier) url.searchParams.set('tier', state.tier); else url.searchParams.delete('tier');
if (state.category) url.searchParams.set('category', state.category); else url.searchParams.delete('category');
if (state.minScore) url.searchParams.set('min_score', String(state.minScore)); else url.searchParams.delete('min_score');
if (state.sort && state.sort !== 'score') url.searchParams.set('sort', state.sort); else url.searchParams.delete('sort');
history.replaceState(null, '', url.toString());
}
const VIEWS = ['feed', 'movers', 'wallets', 'graph', 'edge', 'proof', 'agents', 'activity', 'agent'];
function switchView(view, { updateHash = true } = {}) {
if (!VIEWS.includes(view)) view = 'feed';
state.view = view;
$$('.tab').forEach((t) => {
const on = t.dataset.view === view;
t.classList.toggle('on', on);
t.setAttribute('aria-selected', String(on));
t.tabIndex = on ? 0 : -1;
});
$$('.view').forEach((v) => v.classList.toggle('on', v.id === `view-${view}`));
// Keep the tab in the URL hash so views are shareable, bookmarkable, and the
// browser back button steps through them. 'feed' is the default — no hash.
if (updateHash) {
const url = new URL(location.href);
url.hash = view === 'feed' ? '' : view;
history.replaceState(null, '', url.toString());
}
if (view === 'movers' && !$('#moversGrid').dataset.loaded) loadMovers();
if (view === 'wallets' && !$('#walletWrap').dataset.loaded) loadWallets();
if (view === 'edge' && !$('#edgeWrap').dataset.loaded) loadEdge();
if (view === 'proof' && !$('#proofGrid').dataset.loaded) loadProof(true);
if (view === 'agents' && !$('#agentLeadWrap').dataset.loaded) loadAgentLeaderboard();
if (view === 'activity' && !$('#afTableWrap').dataset.loaded) loadActivity(true);
if (view === 'agent' && !$('#armBody').dataset.loaded) loadAgentPanel();
if (view === 'graph') loadGraph();
}
let graphHandle = null;
async function loadGraph() {
const canvas = $('#og-canvas');
const labels = $('#og-labels');
const stateEl = $('#og-state');
if (!canvas || canvas.dataset.loaded) return;
canvas.dataset.loaded = '1';
if (stateEl) stateEl.textContent = 'Loading conviction data…';
try {
const { mountOracleGraph } = await import('./oracle-graph.js');
const q = new URLSearchParams({ network: NETWORK, limit: '80' });
const { ok, status, data } = await api(`/api/oracle/feed?${q}`);
if (!ok || !data) {
canvas.dataset.loaded = '';
return renderFailure(stateEl, {
title: 'Could not load the conviction graph',
status,
retryId: 'ogRetry',
onRetry: () => { stateEl.textContent = ''; loadGraph(); },
});
}
const coins = Array.isArray(data.items) ? data.items : [];
if (!coins.length) {
if (stateEl) stateEl.textContent = 'No scored coins yet — check back once the Oracle has swept.';
return;
}
if (stateEl) stateEl.textContent = '';
graphHandle = mountOracleGraph(canvas, labels);
graphHandle.loadCoins(coins);
} catch (err) {
if (!stateEl) return;
// A dynamic-import failure means this document is stale: it was cached
// against a build whose chunks have since been replaced, so the graph
// module 404s and no amount of retrying that import will ever succeed.
// Reloading refetches the HTML and the current chunk names with it.
const stale = isChunkLoadError(err);
const body = stale
? 'This page was loaded from a cached copy of an older release, so the graph module no longer exists. Reload to pick up the current build.'
: (err.message || 'The conviction data could not be reached. This is usually temporary.');
stateEl.innerHTML = `<div class="state" style="padding:0"><b>Graph failed to load</b>${esc(body)}<div style="margin-top:14px"><button class="btn" type="button" id="ogRetry">${stale ? 'Reload the page' : 'Retry now'}</button></div></div>`;
$('#ogRetry')?.addEventListener('click', () => {
if (stale) return reloadFresh();
canvas.dataset.loaded = '';
stateEl.textContent = '';
loadGraph();
});
}
}
// Vite emits hashed chunk names, so a chunk 404 is always "the HTML we are
// running predates the chunks on the origin", never a transient network blip.
function isChunkLoadError(err) {
const m = String(err?.message || err || '');
return /dynamically imported module|Importing a module script failed|error loading dynamically imported/i.test(m);
}
// Reload past the HTTP cache. A cache-busting query on the current URL forces a
// fresh document even when an intermediary is still holding the stale variant.
function reloadFresh() {
const url = new URL(location.href);
url.searchParams.set('_r', Date.now().toString(36));
location.replace(url.toString());
}
// Open coin drawer from the 3D graph node click.
window.addEventListener('oracle:open-coin', (e) => {
const mint = e.detail?.mint;
if (mint) openCoin(mint);
});
// ── feed ─────────────────────────────────────────────────────────────────────
function feedSkeletons() {
$('#feedGrid').innerHTML = Array.from({ length: 6 }, () => '<div class="skel"></div>').join('');
}
async function loadFeed() {
feedSkeletons();
const q = new URLSearchParams({ network: NETWORK, limit: '60' });
if (state.tier) q.set('tier', state.tier);
if (state.category) q.set('category', state.category);
if (state.minScore) q.set('min_score', String(state.minScore));
const { ok, status, data } = await api(`/api/oracle/feed?${q}`);
if (!ok || !data) {
$('#ctFeed').textContent = '';
return renderFailure($('#feedGrid'), {
title: 'Could not load the conviction feed',
status,
retryId: 'feedRetry',
onRetry: loadFeed,
gridSpan: true,
});
}
state.feed = new Map((data.items || []).map((it) => [it.mint, it]));
setStats(data);
renderFeed();
if (Array.isArray(data.backtest)) cacheBacktest(data.backtest);
}
function syncWatchToggleUi() {
const btn = $('#watchToggle');
if (!btn) return;
const on = state.watchOnly;
btn.setAttribute('aria-pressed', String(on));
btn.firstChild.textContent = on ? '★ Watching ' : '☆ Watching ';
const ct = $('#watchCt');
if (ct) ct.textContent = watchedMints().size ? watchedMints().size : '';
}
function renderFeed() {
const sorter = state.sort === 'new'
? (a, b) => new Date(b.scored_at || 0) - new Date(a.scored_at || 0)
: state.sort === 'hot'
? (a, b) => (Number(b.pillars?.momentum) || 0) - (Number(a.pillars?.momentum) || 0)
: (a, b) => b.score - a.score;
const watched = watchedMints();
let items = [...state.feed.values()].sort(sorter);
if (state.watchOnly) items = items.filter((it) => watched.has(it.mint));
items = collapseCopycats(items, watched);
syncWatchToggleUi();
$('#ctFeed').textContent = items.length ? items.length : '';
if (!items.length) return renderFeedEmpty(state.watchOnly ? 'watch' : 'empty');
const grid = $('#feedGrid');
grid.innerHTML = '';
items.forEach((it) => grid.appendChild(coinCard(it, watched)));
}
// Copycat & bundle spam floods pump.fun — dozens of distinct mints launched
// with an identical symbol+name (the "deploy 100 more" and "America 250" runs),
// each landing on the same default conviction. Because every mint is its own
// row, the feed would render a wall of near-identical cards that reads like a
// bug. Fold each cluster into its single strongest representative — items arrive
// pre-sorted, so the first one seen (highest score / newest, per the active
// sort) wins — and tag it with the cluster size. A watched ★ mint is never
// folded away: a coin you're tracking always keeps its own card.
function collapseCopycats(items, watched = new Set()) {
const repByKey = new Map();
const out = [];
for (const it of items) {
const sym = (it.symbol || '').trim().toLowerCase();
const name = (it.name || '').trim().replace(/\s+/g, ' ').toLowerCase();
const key = (sym || name) ? `${sym}\u0000${name}` : null;
if (!key || watched.has(it.mint)) { out.push(it); continue; }
const rep = repByKey.get(key);
if (rep) {
rep._dupes += 1;
rep._dupeMints.push(it.mint);
} else {
// Shallow clone so the dupe tally never mutates the cached feed item
// (renderFeed runs on every SSE insert — mutation would double-count).
const clone = { ...it, _dupes: 1, _dupeMints: [it.mint] };
repByKey.set(key, clone);
out.push(clone);
}
}
return out;
}
function renderFeedEmpty(kind) {
const grid = $('#feedGrid');
$('#ctFeed').textContent = '';
if (kind === 'watch') {
const hasWatched = watchedMints().size > 0;
grid.innerHTML = hasWatched
? `<div class="state" style="grid-column:1/-1"><b>None of your watched coins are scored right now</b>The coins on your watchlist haven't surfaced in the current conviction window. They'll reappear here the moment Oracle re-scores them.<div style="margin-top:14px"><button class="btn" type="button" id="watchClear">Show all coins</button></div></div>`
: `<div class="state" style="grid-column:1/-1"><b>Your watchlist is empty</b>Tap the ☆ on any coin to track it — then this filter shows just your watched setups, scored live. It's shared with your launch watchlist across three.ws.<div style="margin-top:14px"><button class="btn" type="button" id="watchClear">Show all coins</button></div></div>`;
$('#watchClear')?.addEventListener('click', () => {
state.watchOnly = false;
syncWatchToggleUi();
renderFeed();
});
return;
}
// kind === 'empty' — the feed loaded, but nothing rendered. Distinguish
// "no scored coins anywhere yet" from "your filters excluded everything".
const hasFilters = !!(state.tier || state.category || state.minScore);
if (!hasFilters) {
grid.innerHTML = `<div class="state" style="grid-column:1/-1"><b>No launches scored yet</b>Oracle hasn't surfaced any conviction-scored coins in this window. New launches are scored the moment they hit pump.fun — they'll appear here automatically, no reload needed.</div>`;
return;
}
grid.innerHTML = `<div class="state" style="grid-column:1/-1"><b>No launches clear your filters</b>There are scored coins, but none pass your current tier, narrative, or minimum-score filters. Loosen them to see more.<div style="margin-top:14px"><button class="btn" type="button" id="feedReset">Reset filters</button></div></div>`;
$('#feedReset')?.addEventListener('click', resetFeedFilters);
}
function resetFeedFilters() {
state.tier = '';
state.category = '';
state.minScore = 0;
$$('#tierSeg button').forEach((x) => x.classList.toggle('on', x.dataset.tier === ''));
const catSel = $('#catSel'); if (catSel) catSel.value = '';
const minSel = $('#minSel'); if (minSel) minSel.value = '0';
$$('#hotSectors .hs-card').forEach((c) => c.classList.remove('active'));
syncFilterUrl();
loadFeed();
}
// ── hot sectors ───────────────────────────────────────────────────────────────
async function loadHotSectors() {
const el = $('#hotSectors');
if (!el || el.dataset.loaded) return;
el.dataset.loaded = '1';
const { ok, data } = await api(`/api/oracle/categories?network=${NETWORK}&hours=24`);
const items = ok && data ? (data.items || []) : [];
// Secondary strip: it stays hidden rather than shouting at the user, but the
// latch is released so the next feed refresh can fill it in.
if (!items.length) { el.dataset.loaded = ''; return; }
el.innerHTML = items.map((c) => {
const initial = esc((c.best_symbol || c.category || '?')[0].toUpperCase());
const imgEl = c.best_image_uri
? `<img class="hs-img" ${proxyImgAttrs(c.best_image_uri, c.best_symbol || c.category)} alt="" loading="lazy"/>`
: `<div class="hs-img">${initial}</div>`;
const primeBadge = c.prime_count > 0 ? `<span class="hs-badge prime">${c.prime_count} prime</span>` : '';
const strongBadge = c.strong_count > 0 ? `<span class="hs-badge strong">${c.strong_count} strong</span>` : '';
const totalBadge = `<span class="hs-badge">${c.total} coins</span>`;
return `<button class="hs-card" type="button" data-cat="${esc(c.category)}">
<div class="hs-head">${imgEl}<div class="hs-cat">${esc(c.category)}</div></div>
<div style="display:flex;align-items:baseline;gap:6px">
<span class="hs-avg">${Math.round(c.avg_score)}</span>
<span class="hs-avg-label">avg conviction</span>
</div>
<div class="hs-badges">${primeBadge}${strongBadge}${totalBadge}</div>
</button>`;
}).join('');
el.style.display = '';
// Sync active state with any pre-selected category from URL params.
if (state.category) {
const activeCard = el.querySelector(`[data-cat="${CSS.escape(state.category)}"]`);
if (activeCard) activeCard.classList.add('active');
}
el.addEventListener('click', (e) => {
const card = e.target.closest('.hs-card');
if (!card) return;
const cat = card.dataset.cat;
// Toggle: clicking the active category again deselects it.
state.category = state.category === cat ? '' : cat;
syncFilterUrl();
const catSel = $('#catSel');
if (catSel) catSel.value = state.category;
loadFeed();
$$('#hotSectors .hs-card').forEach((c) => c.classList.toggle('active', c === card && !!state.category));
});
}
// ── conviction breadth ─────────────────────────────────────────────────────────
// A market-breadth read: the live tier distribution across the full scored
// window, independent of the user's active feed filters. Each segment / legend
// chip filters the feed to that tier. Refreshed on its own cadence so it stays
// an honest gauge of "is the board hot or cold right now".
async function loadBreadth() {
const { ok, data } = await api(`/api/oracle/feed?network=${NETWORK}&limit=200`);
if (!ok || !Array.isArray(data?.items) || !data.items.length) return;
renderBreadth(data.items);
}
function renderBreadth(items) {
const bar = $('#breadthBar');
if (!bar) return;
const counts = Object.fromEntries(TIER_ORDER.map((t) => [t, 0]));
let scoreSum = 0;
for (const it of items) {
if (counts[it.tier] != null) counts[it.tier]++;
scoreSum += Number(it.score) || 0;
}
const total = items.length;
const avg = Math.round(scoreSum / total);
const hotPct = Math.round(((counts.prime + counts.strong) / total) * 100);
const sub = $('#breadthSub');
if (sub) sub.innerHTML = `${total} live · avg <b>${avg}</b> · ${hotPct}% strong+`;
const track = $('#breadthTrack');
if (track) {
track.innerHTML = TIER_ORDER.filter((t) => counts[t] > 0).map((t) => {
const pct = (counts[t] / total) * 100;
return `<button class="breadth-seg" type="button" data-tier="${t}" style="width:${pct}%;background:${TIER_COLOR[t]}"
title="${counts[t]} ${t} (${Math.round(pct)}%)" aria-label="${counts[t]} ${t} coins — filter the feed"></button>`;
}).join('');
}
const legend = $('#breadthLegend');
if (legend) {
legend.innerHTML = TIER_ORDER.map((t) =>
`<button class="breadth-leg ${state.tier === t ? 'on' : ''}" type="button" data-tier="${t}" aria-pressed="${state.tier === t}">
<i style="background:${TIER_COLOR[t]}"></i>${t} <b>${counts[t]}</b></button>`
).join('');
}
bar.style.display = '';
}
// Reflect the active tier filter on the breadth legend without a refetch.
function syncBreadthActive() {
$$('#breadthLegend .breadth-leg').forEach((el) => {
const on = el.dataset.tier === state.tier;
el.classList.toggle('on', on);
el.setAttribute('aria-pressed', String(on));
});
}
// Shared tier-filter mutation used by the breadth bar (toggle semantics).
function applyTierFilter(tier) {
state.tier = state.tier === tier ? '' : tier;
$$('#tierSeg button').forEach((x) => x.classList.toggle('on', x.dataset.tier === state.tier));
state.watchOnly = false;
syncFilterUrl();
syncBreadthActive();
loadFeed();
}
function pillar(kind, label, val) {
return `<div class="pil ${kind}"><div class="lab">${label}<b>${val ?? '—'}</b></div>
<div class="track"><div class="fill" style="width:${Math.max(0, Math.min(100, val || 0))}%"></div></div></div>`;
}
// Inline conviction trajectory — a tiny SVG sparkline of the score over the last
// 24h. Trend-colored, with the live point dotted. Renders nothing for <2 points.
function miniSpark(points) {
const pts = (points || []).map(Number).filter(Number.isFinite);
if (pts.length < 2) return '';
const W = 56, H = 18, pad = 2;
const min = Math.min(...pts), max = Math.max(...pts);
const span = max - min || 1;
const n = pts.length;
const xs = pts.map((_, i) => pad + (i / (n - 1)) * (W - pad * 2));
const ys = pts.map((v) => pad + (1 - (v - min) / span) * (H - pad * 2));
const delta = Math.round(pts[n - 1] - pts[0]);
const col = delta > 2 ? 'var(--up)' : delta < -2 ? 'var(--down)' : 'var(--muted)';
const poly = xs.map((x, i) => `${x.toFixed(1)},${ys[i].toFixed(1)}`).join(' ');
const sign = delta > 0 ? '+' : '';
return `<span class="coin-spark" title="Conviction ${sign}${delta} pts over the last 24h · ${n} readings">
<svg width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" aria-label="Conviction trend ${sign}${delta} points over 24 hours">
<polyline points="${poly}" fill="none" stroke="${col}" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
<circle cx="${xs[n - 1].toFixed(1)}" cy="${ys[n - 1].toFixed(1)}" r="1.9" fill="${col}"/>
</svg></span>`;
}
const TAKE_TIER = {
prime: 'A prime setup',
strong: 'A strong setup',
lean: 'A lean call',
watch: 'One to watch',
avoid: 'Steer clear',
};
const TAKE_PILLAR = {
pedigree: { hi: 'sharp wallets are already in', lo: 'no real pedigree behind it' },
structure:{ hi: 'a clean, distributed launch', lo: 'the launch structure is shaky' },
narrative:{ hi: 'a narrative with legs', lo: 'a thin story' },
momentum: { hi: 'real buy pressure building', lo: 'momentum hasn\'t shown up' },
};
const TAKE_LABEL = { pedigree: 'Who', structure: 'How', narrative: 'What', momentum: 'Move' };
/**
* One clause of evidence: what the engine saw, and how that bucket has
* historically performed against the base rate. `subject` and `lift` are served
* with the verdict; the split is the fallback for a cached row scored before
* they were, so an old card degrades to the observation without its lift rather
* than to nothing.
*/
function reasonClause(r) {
const text = String(r.text || '');
const subject = String(r.subject || text.split(':')[0] || '').trim();
if (!subject) return '';
// A row cached before the engine emitted structured reasons still has both
// halves inside its sentence, so recover them rather than dropping the lift
// for as long as the old rows live.
const lift = Number.isFinite(Number(r.lift)) ? Number(r.lift) : Number(text.match(/\(([\d.]+)x base rate\)/)?.[1]);
if (!Number.isFinite(lift) || (lift > 0.85 && lift < 1.15)) return esc(subject);
return `${esc(subject)} <i>${lift}x base</i>`;
}
// Oracle's take: this coin's own strongest evidence, in one line.
//
// The engine writes a distinct, quantified reason for every coin it scores, and
// the card had no access to any of it, so it synthesized a sentence from the
// argmax pillar instead. Momentum is the argmax on ~90% of the live feed, which
// meant the entire top of the feed printed the same sentence: 200 cards, one
// take, zero information. The reasons now ship with the feed, so the card can
// quote the read instead of a template. The pillar template survives only as
// the fallback for a row cached before the feed carried reasons.
function oracleTake(it) {
const tier = it.tier || 'watch';
const lead = TAKE_TIER[tier] || 'One to watch';
const flags = it.badges || [];
const clauses = (Array.isArray(it.reasons) ? it.reasons : [])
.map(reasonClause)
.filter(Boolean)
.slice(0, 2);
let body = clauses.length ? clauses.join(', ') : pillarTake(it, tier);
if (!body) return '';
if (flags.includes('pedigree-flag')) body += '. Creator has a rug history';
else if (flags.includes('structure-flag')) body += '. Structure throws a flag';
const cat = it.category && it.category !== 'unknown'
? ` Riding ${/^[aeiou]/i.test(it.category) ? 'an' : 'a'} ${esc(it.category)} narrative.`
: '';
return `<div class="coin-take"><span class="ct-q">“</span><span><b>${lead}</b>: ${body}.${cat}</span></div>`;
}
/**
* What this score has been WORTH, not what it looks like. A conviction of 99 is
* a rank on a 0-100 line, and a card that shows the rank alone invites everyone
* to read it as 99% certain. This chip states the measured outcome for the
* score's band instead: how often a coin scored into it graduated or ran 2x
* without ever rugging, over every such coin the market has already resolved.
* Served with the feed (hit_rate/hit_rate_lift/hit_rate_n), fitted by
* scripts/oracle-calibrate.mjs.
*/
function oddsChip(it) {
const rate = Number(it.hit_rate);
const n = Number(it.hit_rate_n);
if (!Number.isFinite(rate) || !Number.isFinite(n) || n < 100) return '';
const pct = Math.round(rate * 100);
const lift = Number(it.hit_rate_lift);
const liftTxt = Number.isFinite(lift) ? `, ${lift}x the rate of a coin picked at random` : '';
const title = `Of the ${n.toLocaleString()} coins Oracle scored into this band that the market has since resolved, ${pct}% graduated or ran 2x or more without ever rugging${liftTxt}. The score ranks the odds of a run; this counts only the runs that survived.`;
return `<span class="chip odds" title="${esc(title)}"><b>${pct}%</b> held 2x+</span>`;
}
/**
* How this specific call ended, on the card. The feed ranks by score, so its top
* rows are the boldest calls, and a resolved one that shows only its verdict is
* why a working engine reads as a broken one: the score is about the launch's
* first 90 seconds, the outcome is about everything since, and the card used to
* carry only the first. Served with the feed (outcome), null until the market
* resolves the coin.
*/
function outcomeChip(it) {
const out = it.outcome;
if (!out) return '';
const ath = Number(out.ath_multiple);
const peak = Number.isFinite(ath) && ath > 0 ? `${ath.toFixed(1)}x` : null;
if (out.graduated) {
return `<span class="chip sm" title="This launch graduated to a DEX${peak ? `, peaking at ${peak} its market cap when Oracle scored it` : ''}.">graduated ✓${peak ? ` <b>${peak}</b>` : ''}</span>`;
}
if (out.rugged) {
return `<span class="chip flag" title="${peak ? `This launch ran to ${peak} and then collapsed. ` : 'This launch collapsed. '}The call was about the odds of a run, not the odds of a safe hold.">${peak ? `ran <b>${peak}</b>, ` : ''}rugged ✕</span>`;
}
return peak ? `<span class="chip" title="Peak market cap versus its market cap when Oracle scored it">peak <b>${peak}</b></span>` : '';
}
/** Pre-reasons fallback: synthesize from the pillars the card already shows. */
function pillarTake(it, tier) {
const p = it.pillars || {};
const entries = ['pedigree', 'structure', 'narrative', 'momentum']
.map((k) => ({ k, v: Number(p[k]) }))
.filter((e) => Number.isFinite(e.v));
if (!entries.length) return '';
const strong = entries.reduce((a, b) => (b.v > a.v ? b : a));
const weak = entries.reduce((a, b) => (b.v < a.v ? b : a));
if (tier === 'prime' || tier === 'strong') {
let body = TAKE_PILLAR[strong.k].hi;
if (it.smart_wallet_count >= 3 && strong.k !== 'pedigree') body += `, with ${it.smart_wallet_count} smart-money wallets in`;
return body;
}
if (tier === 'lean') return `${TAKE_PILLAR[strong.k].hi}, but ${TAKE_PILLAR[weak.k].lo}`;
return weak.v < 40 ? TAKE_PILLAR[weak.k].lo : 'nothing here stands out yet';
}
function coinCard(it, watched = new Set()) {
const p = it.pillars || {};
const BADGE_META = {
'smart-money': { cls: 'sm', txt: 'smart-money', title: '3+ proven wallets are already in' },
'structure-flag': { cls: 'flag', txt: 'structure ⚑', title: 'A structural red flag (bundle, concentration, dumping dev) caps the score' },
'pedigree-flag': { cls: 'flag', txt: 'creator ⚑', title: 'The creator wallet has a rug history — the score is ceilinged regardless of its buyers' },
'thin-data': { cls: 'thin', txt: 'thin data', title: 'Much of this read rests on defaulted inputs — treat as a lead to watch, not a sized call' },
'news': { cls: 'news', txt: 'news', title: 'Riding a live news story — fast but fragile' },
'momentum': { cls: 'mom', txt: 'momentum', title: 'Buy-side momentum alone would carry this launch to prime' },
};
const badges = (it.badges || []).map((b) => {
const m = BADGE_META[b] || { cls: '', txt: b, title: '' };
return `<span class="chip ${m.cls}"${m.title ? ` title="${esc(m.title)}"` : ''}>${esc(m.txt)}</span>`;
}).join('');
// A real link to the coin's full page: crawlable, cmd/ctrl/middle-click and
// "open in new tab" all work. A plain left-click is intercepted to open the
// in-feed drawer instead, so the fast quick-glance flow is unchanged.
const btn = document.createElement('a');
btn.className = `coin ${tierClass(it.tier)}`;
btn.dataset.mint = it.mint;
btn.href = `/oracle/coin/${encodeURIComponent(it.mint)}`;
btn.setAttribute('aria-label', `View ${it.symbol || it.name || it.mint.slice(0, 8)} conviction — score ${it.score}, ${it.tier || 'unrated'} tier${it._dupes > 1 ? `, ${it._dupes} copycat mints share this name` : ''}`);
btn.innerHTML = `
<div class="coin-top">
${it.image_uri
? `<img class="coin-img" ${proxyImgAttrs(it.image_uri, it.mint)} alt="" loading="lazy">`
: `<div class="coin-img">${esc((it.symbol || '?')[0])}</div>`}
<div class="coin-id">
<div class="coin-sym"><span class="sym-txt">${esc(it.symbol || '—')}</span>${it._dupes > 1
? `<span class="dupe-badge" title="${it._dupes} distinct mints launched with this exact name — copycat or bundle spam. Showing the highest-conviction one.">×${it._dupes}</span>`
: ''}</div>
<div class="coin-name">${esc(it.name || it.mint.slice(0, 8))}</div>
</div>
<div class="dial">
<b>${it.score}</b><span>conviction</span>
<div class="tierpill ${tierPill(it.tier)}">${esc(it.tier)}</div>
${miniSpark(it.spark)}
</div>
</div>
${oracleTake(it)}
<div class="pillars">
${pillar('ped', 'Who', p.pedigree)}
${pillar('str', 'How', p.structure)}
${pillar('nar', 'What', p.narrative)}
${pillar('mom', 'Move', p.momentum)}
</div>
<div class="coin-meta">
${it.category ? `<span class="chip cat">${esc(it.category)}</span>` : ''}
${it.smart_wallet_count ? `<span class="chip sm"><b>${it.smart_wallet_count}</b> smart in</span>` : ''}
${badges}
${oddsChip(it)}
${outcomeChip(it)}
${it.coin_first_seen_at ? `<span class="chip" title="Launch age — first seen on pump.fun">age <b>${ago(it.coin_first_seen_at)}</b></span>` : ''}
<span class="chip" title="When Oracle last scored this launch">scored ${ago(it.scored_at)} ago</span>
</div>`;
btn.addEventListener('click', (e) => {
if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0) return; // let the browser handle new-tab/window opens
e.preventDefault();
openCoin(it.mint);
});
const isWatched = watched.has(it.mint);
const watchBtn = document.createElement('button');
watchBtn.className = `oc-watch${isWatched ? ' oc-watched' : ''}`;
watchBtn.type = 'button';
watchBtn.textContent = isWatched ? '★' : '☆';
watchBtn.setAttribute('aria-label', isWatched ? 'Remove from watchlist' : 'Add to watchlist');
watchBtn.setAttribute('aria-pressed', String(isWatched));
watchBtn.title = isWatched ? 'Remove from watchlist' : 'Add to watchlist';
watchBtn.addEventListener('click', (e) => {
e.stopPropagation();
const nowWatched = toggleOracleWatch(it.mint);
watchBtn.textContent = nowWatched ? '★' : '☆';
watchBtn.classList.toggle('oc-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';
});
const wrap = document.createElement('div');
wrap.className = 'coin-wrap';
wrap.appendChild(btn);
wrap.appendChild(watchBtn);
return wrap;
}
function setStats(data) {
const items = data.items || [];
// Populate from the feed window immediately, then override with the richer
// global stats once /api/oracle/stats responds.
$('#stScored').textContent = (data.count ?? items.length).toLocaleString();
$('#stPrime').textContent = items.filter((i) => i.tier === 'prime').length || '—';
$('#stStrong').textContent = items.filter((i) => i.tier === 'strong').length || '—';
loadGlobalStats();
}
async function loadGlobalStats() {
try {
const { ok, data } = await api('/api/oracle/stats');
if (!ok || !data) return;
const set = (id, v) => { const el = $(id); if (el) el.textContent = v; };
set('#stScored', (data.scored_24h ?? 0).toLocaleString());
if (data.scored_total != null) set('#stScoredSub', `${data.scored_total.toLocaleString()} all-time`);
set('#stPrime', data.prime_count != null ? data.prime_count.toLocaleString() : '—');
set('#stStrong', data.strong_count != null ? data.strong_count.toLocaleString() : '—');
// Call win rate: Lean/Strong/Prime calls only. Null until real calls
// resolve — show that honestly instead of substituting the market rate.
set('#stWin', data.win_rate != null ? data.win_rate + '%' : '—');
set('#stWinSub', data.total_resolved
? `${(data.total_wins ?? 0).toLocaleString()} / ${data.total_resolved.toLocaleString()} calls resolved`
: 'no calls resolved yet');
const winEl = $('#stWin');
if (winEl) winEl.classList.toggle('up', data.win_rate != null && data.win_rate >= 50);
set('#stAth', data.best_ath != null ? Number(data.best_ath).toFixed(1) + '×' : '—');
set('#stArmed', (data.agents_armed ?? 0).toLocaleString());
set('#stArmedSub', data.open_actions != null ? `${data.open_actions.toLocaleString()} open positions` : '');
set('#stOpenTrades', data.open_actions != null ? data.open_actions.toLocaleString() : '—');
// Market base rate: every scored launch — the baseline the calls must beat.
set('#stBase', data.market_base_rate != null ? data.market_base_rate + '%' : '—');
set('#stBaseSub', data.market_resolved
? `${(data.market_wins ?? 0).toLocaleString()} / ${data.market_resolved.toLocaleString()} launches`
: '');
// Telegram signal feed: the button only exists when the deployment has a
// public signals channel configured, so it never renders a dead link.
const tgBtn = $('#tgFeedBtn');
if (tgBtn && data.telegram_channel) {
tgBtn.href = data.telegram_channel;
tgBtn.hidden = false;
}
} catch { /* non-fatal — feed-window fallbacks already rendered */ }
}
// Deep-link the hero KPIs: clicking a stat jumps to the surface that proves it.
function wireStatActions() {
$('#statline')?.addEventListener('click', (e) => {
const btn = e.target.closest('[data-stat-action]');
if (!btn) return;
const action = btn.dataset.statAction;
if (action === 'prime' || action === 'strong') {
state.tier = action;
$$('#tierSeg button').forEach((x) => x.classList.toggle('on', x.dataset.tier === action));
state.watchOnly = false;
syncWatchToggleUi();
syncFilterUrl();
loadFeed();
switchView('feed');
$('.tabs')?.scrollIntoView({ behavior: 'smooth', block: 'start' });
} else if (action === 'edge') {
switchView('edge');
} else if (action === 'proof') {
switchView('proof');
} else if (action === 'agents') {
switchView('agents');
}
});
}
// ── live stream ──────────────────────────────────────────────────────────────
function openStream() {
try {
const es = new EventSource(`/api/oracle/stream?network=${NETWORK}`);
state.es = es;
es.addEventListener('hello', () => { setLive(true); });
es.addEventListener('coin', (e) => {
let it; try { it = JSON.parse(e.data); } catch { return; }
onLiveCoin(it);
});
es.addEventListener('bye', () => { es.close(); setTimeout(openStream, 1500); });
es.onerror = () => { setLive(false); es.close(); setTimeout(openStream, 4000); };
} catch { setLive(false); }
}
function setLive(on) {
$('#liveDot').classList.toggle('off', !on);
$('#liveLabel').textContent = on ? 'Live · fused conviction' : 'Reconnecting…';
}
function onLiveCoin(it) {
// passes active filters?
if (state.tier && it.tier !== state.tier) return;
if (state.category && it.category !== state.category) return;
if (state.minScore && it.score < state.minScore) return;
const isNew = !state.feed.has(it.mint);
state.feed.set(it.mint, it);
// Push fresh coin to the 3D graph if it's mounted.
if (graphHandle?.addCoin) graphHandle.addCoin(it);
if (state.view !== 'feed') return;
renderFeed();
if (isNew) {
const el = $(`#feedGrid .coin[data-mint="${CSS.escape(it.mint)}"]`);
if (el) { el.classList.add('flash'); setTimeout(() => el.classList.remove('flash'), 950); }
}
}
// ── wallets ──────────────────────────────────────────────────────────────────
async function loadWallets() {
const wrap = $('#walletWrap');
wrap.innerHTML = '<div class="state">Loading the reputation graph…</div>';
const q = new URLSearchParams({ leaderboard: '1', network: NETWORK, limit: '60' });
if (state.label) q.set('label', state.label);
const { ok, status, data } = await api(`/api/oracle/wallet?${q}`);
wrap.dataset.loaded = '1';
if (!ok) {
wrap.dataset.loaded = '';
$('#ctWallets').textContent = '';
return renderFailure(wrap, {
title: 'Could not reach the reputation graph',
status,
retryId: 'walletRetry',
onRetry: loadWallets,
});
}
if (!data || !(data.items || []).length) {
const filtered = !!state.label;
wrap.innerHTML = filtered
? `<div class="state"><b>No wallets match this label</b>No wallets carry the <b>${esc(state.label.replace('_', ' '))}</b> label yet. Switch back to <b>All</b> to see every ranked wallet.<div style="margin-top:14px"><button class="btn" type="button" id="walletReset">Show all wallets</button></div></div>`
: `<div class="state"><b>No wallets ranked yet</b>The reputation graph fills in as coins resolve to outcomes. Once the brain has judged enough launches, the proven money surfaces here.</div>`;
$('#ctWallets').textContent = '';
$('#walletReset')?.addEventListener('click', () => {
state.label = '';
$$('#labelSeg button').forEach((x) => x.classList.toggle('on', x.dataset.label === ''));
loadWallets();
});
return;
}
$('#ctWallets').textContent = data.items.length;
wrap.innerHTML = `
<div class="lhead"><span>#</span><span>Wallet</span><span class="colhide">Win rate</span><span>Early win</span><span>Score</span></div>
${data.items.map((w, i) => walletRow(w, i)).join('')}`;
$$('#walletWrap .lrow').forEach((r) => r.addEventListener('click', () => openWallet(r.dataset.wallet)));
}
function walletRow(w, i) {
const a = w.archetype || { label: w.label, title: ARCH_TITLE[w.label] || 'Unproven' };
return `<div class="lrow-wrap">
<button type="button" class="lrow" data-wallet="${esc(w.wallet)}">
<span class="lrank ${i < 3 ? 'top' : ''}">${i + 1}</span>
<span class="lw"><span class="nlabel lb-${esc(w.label)}">${esc(a.title)}</span><span class="lw-addr">${esc(shortAddr(w.wallet))}</span></span>
<span class="lstat colhide"><b>${fmtPct(w.win_rate)}</b></span>
<span class="lstat"><b>${fmtPct(w.early_win_rate)}</b></span>
<span class="lscore">${Math.round(w.score)}</span>
</button>
<a class="lrow-copy" href="/trader/${encodeURIComponent(w.wallet)}" title="Trader profile + copy trades">→</a>
</div>`;
}
// ── oracle agent leaderboard ──────────────────────────────────────────────────
async function loadAgentLeaderboard() {
const wrap = $('#agentLeadWrap');
wrap.dataset.loaded = '1';
wrap.innerHTML = '<div class="state">Loading agent rankings…</div>';
const { ok, status, data } = await api(`/api/oracle/leaderboard?network=${NETWORK}&limit=30&min_actions=1`);
if (!ok || !data) {
wrap.dataset.loaded = '';
$('#ctAgents').textContent = '';
return renderFailure(wrap, {
title: 'Could not load the agent rankings',
status,
retryId: 'agentLeadRetry',
onRetry: loadAgentLeaderboard,
});
}
const agents = data.agents || [];
if (!agents.length) {
wrap.innerHTML = `<div class="state"><b>No ranked agents yet</b>Once oracle agents have resolved enough conviction calls, they appear here ranked by win rate. Agents in simulate mode are included — their track records are just as honest.</div>`;
$('#ctAgents').textContent = '';
return;
}
$('#ctAgents').textContent = agents.length;
wrap.innerHTML = `
<div class="alhead"><span>#</span><span>Agent</span><span class="colhide">Actions</span><span>Win rate</span><span>PnL ◎</span></div>
${agents.map((a, i) => agentLeadRow(a, i)).join('')}`;
bindFollowHandlers(wrap);
}
function bindFollowHandlers(wrap) {
wrap.addEventListener('click', (e) => {
const btn = e.target.closest('.lrow-follow');
if (!btn) return;
e.preventDefault();
const entry = btn.closest('.al-entry');
const panel = entry?.querySelector('.follow-panel');
if (!panel) return;
const opening = panel.hidden;
panel.hidden = !opening;
btn.setAttribute('aria-expanded', String(opening));
if (opening) panel.querySelector('.fp-chat, .fp-tg-action, .fp-sub:not([disabled])')?.focus();
});
wrap.addEventListener('input', (e) => {
const slider = e.target.closest('.fp-score');
if (!slider) return;
const label = slider.closest('.fp-score-field')?.querySelector('.fp-score-val');
if (label) label.textContent = slider.value;
});
wrap.addEventListener('submit', async (e) => {
const form = e.target.closest('.follow-form');
if (!form) return;
e.preventDefault();
const entry = form.closest('.al-entry');
const agentId = entry?.dataset.agentId;
const chatId = form.dataset.chat || '';
const minScore = Number(form.querySelector('.fp-score')?.value) || 54;
const msg = form.querySelector('.fp-msg');
if (!chatId) { showFpMsg(msg, 'Link Telegram to your account first', 'err'); return; }
showFpMsg(msg, 'Subscribing…', '');
const { ok, status, data } = await api('/api/oracle/follow', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ agent_id: agentId, chat_id: chatId, min_score: minScore }),
});
if (ok) {
showFpMsg(msg, data?.action === 'updated' ? 'Updated ✓' : 'Subscribed ✓', 'ok');
} else {
showFpMsg(msg, telegramActionError({ status, data }, 'Could not subscribe. Try again.'), 'err');
}
});
wrap.addEventListener('click', async (e) => {
const btn = e.target.closest('.fp-unsub');
if (!btn) return;
const form = btn.closest('.follow-form');
const entry = form?.closest('.al-entry');
const agentId = entry?.dataset.agentId;
const chatId = form?.dataset.chat || '';
const msg = form?.querySelector('.fp-msg');
if (!chatId) { showFpMsg(msg, 'Link Telegram to your account first', 'err'); return; }
showFpMsg(msg, 'Unsubscribing…', '');
const { ok, status, data: unsubData } = await api('/api/oracle/follow', {
method: 'DELETE',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ agent_id: agentId, chat_id: chatId }),
});
showFpMsg(msg, ok ? 'Unsubscribed' : telegramActionError({ status, data: unsubData }, 'Could not unsubscribe. Try again.'), ok ? 'ok' : 'err');
});
}
function showFpMsg(el, text, cls) {
if (!el) return;
el.textContent = text;
el.className = `fp-msg${cls ? ` fp-msg-${cls}` : ''}`;
}
function renderFollowTelegram(panel, st, retry) {
const form = panel.querySelector('.follow-form');
const box = panel.querySelector('.fp-tg');
if (!form || !box) return;
const linked = st.status === 'linked';
form.dataset.chat = linked ? st.chatId : '';
panel.querySelectorAll('.fp-sub, .fp-unsub').forEach((b) => { b.disabled = !linked; });
box.dataset.state = st.status;
const label = '<span class="fp-label">Telegram</span>';
if (linked) {
box.innerHTML = `${label}<div class="fp-tg-body"><span class="fp-tg-ok">Linked</span> <code>${esc(st.chatId)}</code></div>`;
} else if (st.status === 'signed_out') {
box.innerHTML = `${label}<div class="fp-tg-body">Sign in to get this agent's signals on Telegram.</div>
<a class="fp-tg-action" href="${esc(telegramLoginUrl(location.pathname + location.search))}">Sign in</a>`;
} else if (st.status === 'unlinked') {
box.innerHTML = `${label}<div class="fp-tg-body">Link your Telegram account so alerts go only to a chat you control.</div>
<a class="fp-tg-action" href="${TELEGRAM_LINK_URL}">Link Telegram</a>`;
} else {
box.innerHTML = `${label}<div class="fp-tg-body fp-tg-err" role="alert">${esc(st.message)}</div>
<button type="button" class="fp-tg-action fp-tg-retry">Retry</button>`;
box.querySelector('.fp-tg-retry').addEventListener('click', retry);
}
}
async function initFollowPanel(agentId, panel) {
if (!agentId) return;
const resolve = async () => {
const st = await loadTelegramChat(api);
renderFollowTelegram(panel, st, resolve);
if (st.status !== 'linked') return;
const { ok, data } = await api(
`/api/oracle/follow?agent_id=${encodeURIComponent(agentId)}&chat_id=${encodeURIComponent(st.chatId)}&network=${NETWORK}`
);
if (!ok || !data?.following) return;
const msg = panel.querySelector('.fp-msg');
if (msg) showFpMsg(msg, 'Already following', 'ok');
if (data.min_score != null) {
const slider = panel.querySelector('.fp-score');
const val = panel.querySelector('.fp-score-val');
if (slider) slider.value = String(data.min_score);
if (val) val.textContent = String(data.min_score);
}
};
await resolve();
}
function agentLeadRow(a, i) {
const winRate = a.win_rate != null ? `${a.win_rate}%` : '—';
const wrClass = (a.win_rate || 0) >= 50 ? 'up' : 'dn';
const pnlVal = a.realized_pnl_sol != null ? Number(a.realized_pnl_sol) : null;
const pnlStr = pnlVal != null ? `${pnlVal >= 0 ? '+' : ''}${Math.abs(pnlVal) < 0.01 ? pnlVal.toFixed(4) : pnlVal.toFixed(3)}` : '—';
const pnlClass = pnlVal != null ? (pnlVal >= 0 ? 'up' : 'dn') : '';
const img = a.image_url
? `<img class="ag-av" ${proxyImgAttrs(a.image_url, a.agent_id || a.name)} alt="" loading="lazy" />`
: `<div class="ag-av ag-av-ph">${esc((a.name || '?')[0].toUpperCase())}</div>`;
const subLine = `${a.wins}W / ${a.losses}L${a.roi_pct != null ? ` · ROI ${a.roi_pct >= 0 ? '+' : ''}${a.roi_pct}%` : ''}`;
return `<div class="al-entry" data-agent-id="${esc(a.agent_id)}">
<div class="lrow-wrap">
<a class="alrow lrow" href="/agents/${encodeURIComponent(a.agent_id)}" target="_blank" rel="noopener">
<span class="lrank ${i < 3 ? 'top' : ''}">${i + 1}</span>
<span class="lw">${img}
<span>
<div class="ag-name">${esc(a.name || shortAddr(a.agent_id))}</div>
<div class="ag-wl colhide">${esc(subLine)}</div>
</span>
</span>
<span class="lstat colhide">${a.total}</span>
<span class="lstat"><b class="${wrClass}">${winRate}</b></span>
<span class="lstat"><b class="${pnlClass}">${pnlStr}</b></span>
</a>
<a class="lrow-copy" href="/trader/${encodeURIComponent(a.agent_id)}#tp-copy-panel" title="Copy this agent" rel="noopener">→</a>
<button class="lrow-follow" type="button" title="Follow agent signals on Telegram" aria-label="Follow agent on Telegram">+</button>
</div>
<div class="follow-panel" hidden>
<form class="follow-form" autocomplete="off">
<div class="fp-field fp-tg" data-state="loading" aria-live="polite">
<span class="fp-label">Telegram</span>
<div class="fp-tg-body">Checking your Telegram link…</div>
</div>
<div class="fp-field fp-score-field">
<label class="fp-label">Min conviction score: <b class="fp-score-val">54</b></label>
<input type="range" class="fp-score" min="36" max="100" value="54" step="1" />
</div>
<div class="fp-actions">
<button type="submit" class="fp-sub" disabled>Subscribe</button>
<button type="button" class="fp-unsub" disabled>Unsubscribe</button>
<span class="fp-msg"></span>
</div>
</form>
</div>
</div>`;
}
// ── activity feed ─────────────────────────────────────────────────────────────
const _afState = { mode: '', tier: '', outcome: '', cursor: null, loading: false };
async function loadActivity(reset = false) {
if (_afState.loading) return;
_afState.loading = true;
const wrap = $('#afTableWrap');
wrap.dataset.loaded = '1';
if (reset) { _afState.cursor = null; wrap.innerHTML = afSkeletons(8); }
const params = new URLSearchParams({ network: NETWORK, limit: '40' });
if (_afState.mode) params.set('mode', _afState.mode);
if (_afState.tier) params.set('tier', _afState.tier);
if (_afState.outcome) params.set('outcome', _afState.outcome);
if (_afState.cursor) params.set('before', _afState.cursor);
const { ok, status, data } = await api(`/api/oracle/activity?${params}`);
_afState.loading = false;
if (!ok || !data) {
if (reset) {
wrap.dataset.loaded = '';
$('#ctActivity').textContent = '';
$('#afMore').style.display = 'none';
renderFailure(wrap, {
title: 'Could not load the agent action feed',
status,
retryId: 'afRetry',
onRetry: () => loadActivity(true),
});
} else {
const moreBtn = $('#afMoreBtn');
if (moreBtn) { moreBtn.disabled = false; moreBtn.textContent = 'Retry loading more'; }
}
return;
}
const items = data.items || [];
if (!items.length && reset) {
wrap.innerHTML = `<div class="state"><b>No actions yet</b>Once Oracle-armed agents make their first call, the floor lights up here — every buy, every outcome, in real time.</div>`;
$('#ctActivity').textContent = '';
$('#afMore').style.display = 'none';
return;
}
if (reset) {
wrap.innerHTML = afTableHtml(items);
} else {
const tbody = wrap.querySelector('tbody');
if (tbody) tbody.insertAdjacentHTML('beforeend', items.map(afRow).join(''));
}
_afState.cursor = data?.next_before || null;
const moreEl = $('#afMore');
const moreBtn = $('#afMoreBtn');
moreEl.style.display = _afState.cursor ? '' : 'none';
if (moreBtn) moreBtn.disabled = false;
const total = data?.summary?.total ?? data?.total ?? null;
if (reset && total != null) $('#ctActivity').textContent = total;
}
function afSkeletons(n) {
return `<div class="af-outer">${Array.from({length: n}, () => '<div class="af-skel" style="height:46px;border-bottom:1px solid rgba(255,255,255,0.04)"></div>').join('')}</div>`;
}
function afTableHtml(items) {
return `<div class="af-outer"><table class="af-table"><thead><tr>
<th scope="col">Agent</th><th scope="col">Coin</th><th scope="col">Tier</th><th scope="col">Score</th><th scope="col">Size ◎</th><th scope="col">Mode</th><th scope="col">Outcome</th><th scope="col">PnL ◎</th><th scope="col">When</th>
</tr></thead><tbody>${items.map(afRow).join('')}</tbody></table></div>`;
}
function afRow(a) {
const av = a.agent_image
? `<img class="af-av" ${proxyImgAttrs(a.agent_image, a.agent_id || a.agent_name)} alt="" loading="lazy">`
: `<div class="af-av" style="display:grid;place-items:center;font:700 11px/1 var(--mono);color:var(--faint)">${esc((a.agent_name || '?')[0].toUpperCase())}</div>`;
const outcome = a.outcome || 'open';
const outCls = outcome === 'win' ? 'af-outcome-win' : outcome === 'loss' ? 'af-outcome-loss' : 'af-outcome-open';
const outLabel = outcome === 'win'
? `✓ Win${a.peak_multiple ? ` ${Number(a.peak_multiple).toFixed(1)}×` : ''}`
: outcome === 'loss' ? '✗ Loss' : '—';
const pnl = a.realized_pnl_sol != null ? Number(a.realized_pnl_sol) : null;
const pnlStr = pnl != null ? `${pnl >= 0 ? '+' : ''}${Math.abs(pnl) < 0.01 ? pnl.toFixed(4) : pnl.toFixed(3)}` : '—';
const pnlCls = pnl != null ? (pnl >= 0 ? 'up' : 'dn') : '';
const modeBadge = a.mode === 'live' ? '<span class="act-live">live</span>' : '<span class="act-sim">sim</span>';
return `<tr class="af-row">
<td class="af-agent">${av}<a class="af-name" href="/trader/${encodeURIComponent(a.agent_id)}" target="_blank" rel="noopener">${esc(a.agent_name || 'Agent')}</a></td>
<td class="af-coin"><a href="${esc(a.pump_url)}" target="_blank" rel="noopener">${esc(a.symbol || a.mint?.slice(0, 6) || '?')}</a></td>
<td><span class="tierpill ${tierPill(a.tier)}">${esc(a.tier || '—')}</span></td>
<td class="af-mono">${a.conviction ?? '—'}</td>
<td class="af-mono">${a.size_sol != null ? Number(a.size_sol).toFixed(3) : '—'}</td>
<td>${modeBadge}</td>
<td class="${outCls}">${outLabel}</td>
<td class="af-mono ${pnlCls}">${pnlStr}</td>
<td class="af-mono" style="color:var(--faint);font-size:11px">${a.acted_at ? ago(a.acted_at) + ' ago' : '—'}</td>
</tr>`;
}
// ── edge (backtest) ──────────────────────────────────────────────────────────
let _backtest = null;
function cacheBacktest(bt) {
// Normalize old { tier, scored, resolved, grad_rate, avg_ath_multiple } rows
// into the richer format from /api/oracle/backtest if the feed returns both.
if (!_backtest && Array.isArray(bt)) _backtest = { by_tier: bt, aggregate: null, top_performers: [] };
if ($('#edgeWrap').dataset.loaded) renderEdge();
}
async function loadEdge() {
const wrap = $('#edgeWrap');
wrap.dataset.loaded = '1';
wrap.innerHTML = '<div class="state">Loading performance data…</div>';
const { ok, status, data } = await api(`/api/oracle/backtest?period=30d&network=${NETWORK}`);
if (ok && data) {
_backtest = data;
} else if (!_backtest) {
// Fallback: the feed carries the older by-tier rows.
const { ok: feedOk, data: feed } = await api(`/api/oracle/feed?network=${NETWORK}&limit=1`);
if (feed?.backtest) {
_backtest = { by_tier: feed.backtest, aggregate: null, top_performers: [] };
} else if (!feedOk) {
// Neither source answered: report the outage, never the honest-but-
// wrong "the edge is still proving itself".
wrap.dataset.loaded = '';
return renderFailure(wrap, {
title: 'Could not load the performance record',
status,
retryId: 'edgeRetry',
onRetry: loadEdge,
});
}
}
renderEdge();
}
/**
* Whether the ladder is ordered, said honestly. The old copy asserted "the win
* rate climbs with the score at every band, the ranking is calibrated, not
* noise" whenever the API returned monotonic:true, and the API returned true for
* any ladder whose dips stayed under 5 points. It dipped by more than that, so
* the page shipped a claim its own table contradicted. The API now counts an
* inversion only where the 95% intervals are disjoint, and names them, so this
* can quote the specific bands that break the order instead of hand-waving.
*/
function ladderLine(edge) {
const inv = edge?.ladder?.clean_win?.inversions || [];
if (edge?.monotonic) return 'And the win rate climbs with the score at every band we can measure: the ranking is calibrated, not noise.';
if (!inv.length) return 'The ladder is not yet ordered end to end; treat the middle bands with caution.';
const worst = inv[0];
return `The ladder is not ordered end to end: the <b>${esc(worst.band)}</b> band wins <b>${worst.realized}%</b> against <b>${worst.below_realized}%</b> for <b>${esc(worst.below_band)}</b>${inv.length > 1 ? `, and ${inv.length - 1} other pair${inv.length > 2 ? 's' : ''} invert` : ''}. Only the top band is a clean separation so far.`;
}
/**
* The other half of the truth: the engine was fitted to predict a 3x run or a
* graduation, judged whether or not the coin later collapsed, and the headline
* above grades it on the stricter question a holder cares about. Both numbers
* are real and they are far apart, so the page states which is which instead of
* letting one stand in for the other.
*/
function spikeLine(edge) {
if (edge?.prime_spike_rate == null) return '';
const rug = edge.prime_rug_rate;
const mult = edge.spike_edge_multiple;
return `<p class="edge-hero-sub">On the event the model was actually fitted to predict, a 3× run or a graduation, <b style="color:var(--ink)">${edge.prime_spike_rate}%</b> of Prime calls hit${edge.baseline_spike_rate != null ? ` against <b style="color:var(--ink)">${edge.baseline_spike_rate}%</b> for a random launch` : ''}${mult ? ` (<b style="color:var(--ink)">${mult}×</b>)` : ''}.${rug != null ? ` ${rug}% of them collapsed afterwards anyway, which is why the win rate above is the lower number: conviction ranks the odds of a run, never the odds of a safe hold.` : ''}</p>`;
}
function renderEdge() {
const wrap = $('#edgeWrap');
const bt = _backtest;
const tiers = bt?.by_tier || [];
const rows = tiers.filter((r) => (r.total || r.scored || 0) > 0);
if (!rows.length) {
wrap.innerHTML = `<div class="state"><b>The edge is still proving itself.</b> Win-rate by tier appears once Oracle has scored coins that have since resolved to an outcome. This is intentionally honest — no backfilled numbers.</div>`;
return;
}
const agg = bt?.aggregate;
const edge = bt?.edge;
// ── verdict hero: does conviction beat blind buying? ──────────────────────
let hero = '';
if (edge && edge.prime_win_rate == null && edge.baseline_win_rate != null) {
// No Prime calls have resolved yet — say so instead of implying an edge.
hero = `
<div class="edge-hero thin">
<p class="edge-hero-claim">No Prime calls have resolved yet — the edge is unproven, and we say so.</p>
<p class="edge-hero-sub">Across <b style="color:var(--ink)">${(edge.baseline_n || 0).toLocaleString()}</b> resolved launches, buying everything blind wins <b style="color:var(--ink)">${edge.baseline_win_rate}%</b> of the time (graduated, or ≥2× without rugging). That's the market's base rate, not Oracle's skill. Prime/Strong call win rates appear here the moment real calls resolve — never backfilled, never cherry-picked.</p>
</div>`;
}
if (edge && edge.prime_win_rate != null && edge.baseline_win_rate != null) {
const lift = edge.prime_lift;
const mult = edge.edge_multiple;
const beats = lift != null && lift > 0;
const mono = edge.monotonic;
hero = `
<div class="edge-hero${beats ? '' : ' thin'}">
<p class="edge-hero-claim">Prime calls win <b class="win">${edge.prime_win_rate}%</b> of the time${beats ? `, vs <b>${edge.baseline_win_rate}%</b> for a coin picked at random` : ''}.</p>
<p class="edge-hero-sub">${beats
? `That's a <b style="color:var(--ink)">+${lift} point</b> lift over blind buying${mult ? `, <b style="color:var(--ink)">${mult}×</b> the base rate` : ''}. ${ladderLine(edge)}`
: `Conviction isn't beating the market over this window yet. We show it anyway — no cherry-picking.`}</p>
${spikeLine(edge)}
<div class="edge-hero-metrics">
<span class="edge-chip ${beats ? 'ok' : ''}"><b class="${beats ? 'up' : ''}">${lift != null ? (lift >= 0 ? '+' : '') + lift + 'pt' : '—'}</b><span>edge lift</span></span>
${mult ? `<span class="edge-chip"><b>${mult}×</b><span>vs base rate</span></span>` : ''}
${edge.brier != null ? `<span class="edge-chip" title="Mean squared error of the score (as a probability) vs the real outcome. Lower = better calibrated. 0.25 = a coin-flip."><b>${edge.brier.toFixed(3)}</b><span>brier</span></span>` : ''}
<span class="edge-chip ${mono ? 'ok' : ''}"><b class="${mono ? 'up' : ''}">${mono ? 'monotonic' : 'mixed'}</b><span>ranking</span></span>
${edge.baseline_n ? `<span class="edge-chip"><b>${edge.baseline_n.toLocaleString()}</b><span>resolved</span></span>` : ''}
</div>
</div>`;
}
const aggLine = agg && agg.total > 0 ? `
<div class="edge-agg">
<div class="edge-kpi"><span>Total scored</span><b>${agg.total.toLocaleString()}</b></div>
<div class="edge-kpi" title="Across ALL scored tiers, Watch/Avoid included — the market, not the calls"><span>Win rate (all scored)</span><b class="${(agg.win_rate||0) >= 50 ? 'up' : 'dn'}">${agg.win_rate != null ? agg.win_rate + '%' : '—'}</b>${agg.ci ? `<span class="ci">95% CI ${agg.ci.lo}–${agg.ci.hi}</span>` : ''}</div>
<div class="edge-kpi"><span>Wins</span><b class="up">${agg.wins}</b></div>
<div class="edge-kpi"><span>Losses</span><b class="dn">${agg.losses}</b></div>
<div class="edge-kpi"><span>Graduated</span><b>${agg.graduated}</b></div>
<div class="edge-kpi"><span>Rugged</span><b>${agg.rugged}</b></div>
<div class="edge-kpi"><span>≥ 5×</span><b>${agg.five_x}</b></div>
<div class="edge-kpi"><span>≥ 10×</span><b>${agg.ten_x}</b></div>
</div>` : '';
// ── calibration ladder: realized win rate by score band ───────────────────
const cal = (bt?.calibration || []).filter((c) => c.n != null);
const calHtml = cal.length ? `
<div class="dr-sec edge-sec">Calibration — realized win rate by score band</div>
<div class="cal">
${cal.slice().reverse().map(calRow).join('')}
<div class="cal-legend">
<span><i class="li-real"></i>Realized win rate (bar fill)</span>
<span><i class="li-pred"></i>What the band claims, converted from the score</span>
<span style="color:var(--faint)">A score is a rank, not a percentage: 86 claims 55%. The marker is that converted claim, on the event the model was fitted to predict (a 3× run or a graduation), so the bar and the marker measure different things on purpose. "ran 3×" is the trained event's own realized rate.</span>
</div>
</div>` : '';
const top = bt?.top_performers?.slice(0, 5) || [];
const topHtml = top.length ? `
<div class="dr-sec edge-sec">Top performers (by ATH)</div>
<div class="edge-top">
${top.map((t) => `<a class="edge-top-row" href="https://pump.fun/coin/${esc(t.mint)}" target="_blank" rel="noopener">
<span class="tierpill ${tierPill(t.tier)}">${esc(t.tier)}</span>
<b>${esc(t.symbol || t.mint.slice(0, 6))}</b>
<span class="edge-ath">${t.ath_multiple ? Number(t.ath_multiple).toFixed(1) + '×' : t.graduated ? '✓ grad' : '—'}</span>
</a>`).join('')}
</div>` : '';
wrap.innerHTML = `
${hero}
${aggLine}
<div class="dr-sec edge-sec">Win rate by conviction tier</div>
<div class="edge">
<div class="ehead"><span>Tier</span><span>Win rate (95% CI)</span><span class="colhide">Wins / Losses</span><span>Avg ATH×</span><span>≥ 5×</span></div>
${rows.map(edgeRow).join('')}
</div>
${calHtml}
${topHtml}
<p style="font-size:11px;color:var(--faint);margin-top:18px">Win = graduated, OR ATH ≥ 2× on a coin that did not rug — a 2× wick on the way to zero doesn't count. Loss = rugged OR ATH < 1.2×. Open positions excluded. Confidence intervals are Wilson 95% — wide bands mean a thin sample, not a weak edge. 30-day window.</p>`;
}
function edgeRow(r) {
// Support both old format (grad_rate, scored) and new format (win_rate, total, wins, losses, ci)
const winRate = r.win_rate ?? r.grad_rate ?? null;
const wins = r.wins ?? 0;
const losses = r.losses ?? 0;
const resolved = wins + losses;
const ath = r.avg_ath ? Number(r.avg_ath).toFixed(1) : (r.avg_ath_multiple ? Number(r.avg_ath_multiple).toFixed(1) : null);
const fiveX = r.five_x ?? 0;
const thin = resolved > 0 && resolved < 8; // too few to trust — dim it, but show it
const ci = r.ci && resolved ? `<span class="ci">${r.ci.lo}–${r.ci.hi}${thin ? ' · thin' : ''}</span>` : '';
return `<div class="erow${thin ? ' thin' : ''}"${thin ? ' title="Small sample — wide confidence band"' : ''}>
<span><span class="tierpill ${tierPill(r.tier)}">${esc(r.tier)}</span></span>
<span><div class="gradbar"><i style="width:${winRate ?? 0}%"></i></div><span class="lstat" style="text-align:left"><b>${winRate != null ? winRate + '%' : '—'}</b>${ci}</span></span>
<span class="lstat colhide">${wins} / ${losses}</span>
<span class="lstat"><b>${ath ? ath + '×' : '—'}</b></span>
<span class="lstat">${fiveX}</span>
</div>`;
}
function calRow(c) {
const real = c.realized;
const hasData = real != null && c.n > 0;
const thin = hasData && c.n < 5;
return `<div class="cal-row${hasData ? '' : ' empty'}">
<div class="cal-band">${esc(c.band)}<small>n=${c.n || 0}${thin ? ' · thin' : ''}</small></div>
<div class="cal-track" role="img" aria-label="band ${esc(c.band)}: realized ${hasData ? real + '%' : 'no data'}, predicted ${c.predicted}%">
<div class="cal-real" style="width:${hasData ? real : 0}%"></div>
<div class="cal-pred" style="left:${c.predicted}%"></div>
</div>
<div class="cal-val">${hasData ? `${real}%` : '<span style="color:var(--faint)">n/a</span>'}<small>claims ${c.predicted}%${c.realized_spike != null ? ` · ran 3× ${c.realized_spike}%` : ''}</small></div>
</div>`;
}
// ── proof / wins gallery ──────────────────────────────────────────────────────
const _proofState = { tier: '', period: '30d', cursor: null, loading: false };
// ── movers ──────────────────────────────────────────────────────────────────
const _moversState = { direction: 'rising', hours: 24 };
function moverCardHtml(m) {
const tier = m.tier || 'watch';
const deltaSign = m.delta >= 0 ? '+' : '';
const deltaCls = m.delta >= 0 ? 'up' : 'dn';
const imgSrc = m.image_uri
? `<img class="mv-img" ${proxyImgAttrs(m.image_uri, m.mint)} alt="" loading="lazy">`
: `<div class="mv-img">${esc((m.symbol || '?')[0])}</div>`;
const TIER_META = { prime: { color: '#e8ebf2' }, strong: { color: '#e4e8f2' }, lean: { color: '#c4c9d6' }, watch: { color: '#8a92a8' }, avoid: { color: '#6c7280' } };
const tierColor = (TIER_META[tier] || TIER_META.watch).color;
const pil = (val, key) => {
const v = Math.max(0, Math.min(100, Number(val) || 0));
const labels = { pedigree: 'Who', structure: 'How', narrative: 'What', momentum: 'Move' };
return `<div class="mv-pil">
<div class="mv-pil-label">${labels[key] || key}</div>
<div class="mv-pil-bar"><div class="mv-pil-fill" style="width:${v}%"></div></div>
</div>`;
};
const tierChangedHtml = m.tier_changed
? `<div class="mv-tier-change">Tier: ${esc(m.first_tier)} → ${esc(m.tier)}</div>`
: '';
return `<div class="mv-card mv-${m.delta >= 0 ? 'rising' : 'falling'}" role="button" tabindex="0"
data-mint="${esc(m.mint)}">
<div class="mv-head">
${imgSrc}
<div class="mv-id">
<div class="mv-sym">${esc(m.symbol || m.mint.slice(0, 8))}</div>
<div class="mv-name">${esc(m.name || '')}</div>
</div>
<div class="mv-delta">
<div class="mv-delta-val ${deltaCls}">${deltaSign}${m.delta}</div>
<div class="mv-delta-label">score Δ</div>
</div>
</div>
<div class="mv-scores">
<span style="color:var(--muted)">${m.first_score ?? '?'}</span>
<span class="mv-arrow">→</span>
<span class="mv-score-cur" style="color:${tierColor}">${m.score ?? '?'}</span>
<span class="tierpill tp-${tier}" style="margin-left:4px;padding:1px 6px;font-size:10px">${tier}</span>
${m.category ? `<span style="color:var(--faint);font-size:11px;margin-left:auto">${esc(m.category)}</span>` : ''}
</div>
${tierChangedHtml}
<div class="mv-pillars">
${pil(m.pillars?.pedigree, 'pedigree')}
${pil(m.pillars?.structure, 'structure')}
${pil(m.pillars?.narrative, 'narrative')}
${pil(m.pillars?.momentum, 'momentum')}
</div>
</div>`;
}
async function loadMovers(reset = false) {
const grid = $('#moversGrid');
if (!grid) return;
if (grid.dataset.loaded !== '1') {
const openFromCard = (el) => {
const mint = el?.dataset?.mint;
if (mint) openCoin(mint);
};
grid.addEventListener('click', (e) => openFromCard(e.target.closest('.mv-card')));
grid.addEventListener('keydown', (e) => {
if (e.key !== 'Enter' && e.key !== ' ') return;
const card = e.target.closest('.mv-card');
if (!card) return;
e.preventDefault();
openFromCard(card);
});
}
grid.dataset.loaded = '1';
const skels = Array.from({ length: 6 }, () =>
'<div class="skel" style="height:160px;border-radius:var(--r)"></div>'
).join('');
if (reset || !grid.children.length) grid.innerHTML = skels;
const { direction, hours } = _moversState;
const { ok, status, data } = await api(
`/api/oracle/movers?network=${NETWORK}&direction=${direction}&hours=${hours}&limit=40`
);
if (!ok || !data) {
grid.dataset.loaded = '';
return renderFailure(grid, {
title: 'Could not load conviction movers',
status,
retryId: 'moversRetry',
onRetry: () => loadMovers(true),
gridSpan: true,
});
}
if (!data.items?.length) {
grid.innerHTML = `<div class="state" style="grid-column:1/-1">
<b>No movers yet in this window.</b>
Conviction deltas appear once Oracle re-scores the same coins in the selected window.
${direction === 'rising' ? 'Try the 48h window or check back as more coins get re-scored.' : ''}
</div>`;
return;
}
grid.innerHTML = data.items.map(moverCardHtml).join('');
}
function winCardHtml(w, idx) {
const tier = w.tier || 'watch';
const athStr = w.ath_multiple != null ? `${Number(w.ath_multiple).toFixed(1)}×` : w.graduated ? 'Grad ✓' : '—';
const imgSrc = w.image_uri || '';
const sym = esc((w.symbol || w.mint.slice(0, 6)).toUpperCase());
const scoreColor = tier === 'prime' ? 'var(--up)' : tier === 'strong' ? 'var(--up)' : tier === 'lean' ? 'var(--gold)' : 'var(--muted)';
const pillars = w.pillars || {};
const pil = (k, cls, lbl) => {
const v = pillars[k] != null ? Math.round(Number(pillars[k])) : null;
return `<div class="win-pil ${cls}">
<label>${lbl}<b>${v != null ? v : '?'}</b></label>
<div class="win-pil-bar"><div class="win-pil-fill" style="width:${v ?? 0}%"></div></div>
</div>`;
};
const when = w.scored_at ? ago(w.scored_at) : '';
return `<a class="win-card win-in" href="${esc(w.oracle_url)}" style="animation-delay:${Math.min(idx * 40, 400)}ms">
<div class="win-card-head">
<div class="win-img">${imgSrc ? `<img ${proxyImgAttrs(imgSrc, w.mint)} alt="" style="width:42px;height:42px;border-radius:10px;object-fit:cover" loading="lazy" />` : sym.slice(0, 2)}</div>
<div class="win-id">
<div class="win-sym">$${sym}</div>
${w.name ? `<div class="win-name">${esc(w.name)}</div>` : ''}
</div>
<div class="win-ath">
<span class="win-ath-val">${esc(athStr)}</span>
<span class="win-ath-label">ATH</span>
</div>
</div>
<div class="win-body">
<div class="win-score-row">
<span class="win-score-label">Oracle at entry</span>
<span class="win-score-val" style="color:${scoreColor}">${w.score != null ? w.score : '—'}</span>
<span class="tierpill tp-${tier}" style="margin-left:6px">${tier}</span>
</div>
<div class="win-pillars">
${pil('pedigree', 'ped', 'Who')}${pil('structure', 'str', 'How')}${pil('narrative', 'nar', 'What')}${pil('momentum', 'mom', 'Move')}
</div>
<div class="win-badges">
${w.graduated ? '<span class="win-grad">Graduated</span>' : ''}
<span class="win-when">${esc(when)}</span>
</div>
<div class="win-links">
<a class="win-link" href="${esc(w.pump_url)}" target="_blank" rel="noopener" data-stop-propagation>pump.fun ↗</a>
<a class="win-link" href="${esc(w.oracle_url)}" data-stop-propagation>Oracle ↗</a>
<a class="win-link" style="margin-left:auto;color:var(--muted)" href="${esc(winTweet(w))}" target="_blank" rel="noopener" data-stop-propagation title="Share on X">Share ↗</a>
</div>
</div>
</a>`;
}
function proofSkeletons(n = 6) {
return Array.from({ length: n }, () => '<div class="skel" style="height:220px;border-radius:var(--r)"></div>').join('');
}
async function loadProof(reset = false) {
if (_proofState.loading) return;
_proofState.loading = true;
const grid = $('#proofGrid');
grid.dataset.loaded = '1';
if (reset) { _proofState.cursor = null; grid.innerHTML = proofSkeletons(); }
const url = `/api/oracle/wins?network=${NETWORK}&period=${_proofState.period}&limit=24&min_ath=2`;
const q = url + (_proofState.tier ? `&tier=${_proofState.tier}` : '') + (_proofState.cursor ? `&before=${_proofState.cursor}` : '');
const { ok, status, data } = await api(q);
_proofState.loading = false;
if (!ok || !data?.items) {
if (reset) {
grid.dataset.loaded = '';
renderFailure(grid, {
title: 'Could not load the proof gallery',
status,
retryId: 'proofRetry',
onRetry: () => loadProof(true),
gridSpan: true,
});
} else {
const moreBtn = $('#proofLoadMoreBtn');
if (moreBtn) { moreBtn.disabled = false; moreBtn.textContent = 'Retry loading more'; }
}
return;
}
const items = data.items || [];
if (reset) {
grid.innerHTML = items.length ? items.map(winCardHtml).join('') : `<div class="state" style="grid-column:1/-1"><b>No ${_proofState.tier === 'all' ? '' : 'called '}wins resolved yet in this period.</b><br>${_proofState.tier === 'all'
? 'Try a longer window or check back as more coins resolve.'
: 'This gallery only counts coins Oracle rated Lean or above — no cherry-picking winners it never called. Try a longer window, or switch to “All scored” to see the whole market.'}</div>`;
} else {
items.forEach((w, i) => grid.insertAdjacentHTML('beforeend', winCardHtml(w, i)));
}
_proofState.cursor = data.next_before || null;
const moreWrap = $('#proofLoadMore');
const moreBtn = $('#proofLoadMoreBtn');
moreWrap.style.display = _proofState.cursor ? '' : 'none';
if (moreBtn) { moreBtn.disabled = false; }
// Render KPIs on first load
if (reset && data.summary) {
const kpis = $('#proofKpis');
const s = data.summary;
kpis.style.display = '';
kpis.innerHTML = [
['Wins', s.total_wins ?? 0, 'up'],
['Best ATH', s.best_ath != null ? `${Number(s.best_ath).toFixed(1)}×` : '—', 'up'],
['5× or more', s.five_x_count ?? 0, ''],
['10× or more', s.ten_x_count ?? 0, ''],
['Graduated', s.graduated_count ?? 0, ''],
].map(([l, v, cls]) => `<div class="proof-kpi"><span>${l}</span><b class="${cls}">${v}</b></div>`).join('');
const ctProof = $('#ctProof');
if (ctProof && s.total_wins) ctProof.textContent = s.total_wins;
}
}
// ── coin drawer ──────────────────────────────────────────────────────────────
async function openCoin(mint) {
const dr = $('#drawer');
dr.classList.add('open'); dr.setAttribute('aria-hidden', 'false');
$('#drTitle').textContent = 'Loading…';
$('#drBody').innerHTML = '<div class="state">Reading the order book…</div>';
// Update URL so this conviction view is shareable / bookmarkable.
const url = new URL(location.href);
url.searchParams.set('mint', mint);
history.replaceState(null, '', url.toString());
const { ok, data } = await api(`/api/oracle/coin?mint=${encodeURIComponent(mint)}&network=${NETWORK}`);
if (!ok || !data || !data.conviction) {
$('#drTitle').textContent = 'Not observed yet';
$('#drBody').innerHTML = `<div class="state"><b>This launch hasn't been scored</b>Oracle scores coins as they surface on pump.fun. If it's brand new, it'll appear here within moments — the full coin page already streams its live market and trade tape.
<div style="margin-top:14px"><a class="dr-act" href="/oracle/coin/${encodeURIComponent(mint)}">Open full coin page ↗</a></div></div>`;
return;
}
renderDrawer(data);
}
function structurePanel(st) {
if (!st) return '';
const pct = (n) => (n == null ? '—' : `${Math.round(Number(n))}%`);
const bar = (val, color) => `<div class="str-track"><div class="str-fill" style="width:${Math.max(0,Math.min(100,val||0))}%;background:${color}"></div></div>`;
const organic = Number(st.organicScore ?? 0);
const bundle = Number(st.bundleScore ?? 0);
const top10 = Number(st.top10Pct ?? 0);
const connect = Number(st.bubblemapConnectivity ?? 0);
const devSold = Number(st.devSoldPct ?? 0);
const devBuy = st.creatorHoldPct != null ? `${Math.round(Number(st.creatorHoldPct))}%` : '—';
const buyers = st.uniqueBuyers ?? '—';
const bundleFl = st.bundleFlag;
if (!st.organicScore && !st.bundleScore && !st.top10Pct && !st.bubblemapConnectivity) return '';
return `
<div class="dr-sec">Structure <span style="color:var(--faint);font-weight:400;font-size:10px">wallet graph · buy pattern</span></div>
<div class="str-grid">
<div class="str-row">
<span class="str-lbl">Organic buy</span>
${bar(organic, 'var(--up)')}
<span class="str-val" style="color:var(--up)">${pct(organic)}</span>
</div>
<div class="str-row">
<span class="str-lbl">Bundle / coord</span>
${bar(bundle, bundleFl ? 'var(--down)' : 'var(--amber)')}
<span class="str-val" style="color:${bundleFl ? 'var(--down)' : 'var(--amber)'}">${pct(bundle)}${bundleFl ? ' ⚑' : ''}</span>
</div>
${top10 ? `<div class="str-row">
<span class="str-lbl">Top 10 hold</span>
${bar(top10, top10 > 60 ? 'var(--down)' : 'var(--gold)')}
<span class="str-val" style="color:${top10 > 60 ? 'var(--down)' : 'var(--gold)'}">${pct(top10)}</span>
</div>` : ''}
${connect ? `<div class="str-row">
<span class="str-lbl">Graph density</span>
${bar(connect, connect > 50 ? 'var(--down)' : 'var(--muted)')}
<span class="str-val" style="color:${connect > 50 ? 'var(--down)' : 'var(--muted)'}">${pct(connect)}</span>
</div>` : ''}
</div>
<div class="coin-meta" style="margin-top:10px">
${buyers !== '—' ? `<span class="chip">buyers <b>${buyers}</b></span>` : ''}
${devBuy !== '—' ? `<span class="chip ${devSold > 50 ? 'flag' : ''}">dev hold <b>${devBuy}</b>${devSold > 20 ? ` · sold ${Math.round(devSold)}%` : ''}</span>` : ''}
</div>`;
}
// Oracle's take for the drawer — leads with the tier+score, then weaves the two
// highest-contribution reasons the engine actually computed into one sentence.
function drawerTake(d) {
const c = d.conviction || {};
const lead = TAKE_TIER[c.tier] || 'One to watch';
const rs = (d.reasons || []).map((r) => r.text).filter(Boolean);
if (!rs.length) return '';
const body = rs.slice(0, 2).map((t) => t.replace(/\.$/, '')).join('; ');
return `<div class="coin-take" style="font-size:13.5px;margin:10px 0 4px"><span class="ct-q">“</span><span><b>${esc(lead)} at ${c.score}</b> — ${esc(body)}.</span></div>`;
}
function renderDrawer(d) {
const c = d.conviction; const p = c.pillars || {};
$('#drTitle').innerHTML = `<a href="/oracle/coin/${encodeURIComponent(c.mint)}" style="color:inherit;text-decoration:none" title="Open the full conviction page">${esc(c.symbol || '—')} <span style="color:var(--muted);font:600 13px var(--mono)">${esc(c.name || '')}</span></a>`;
const reasons = (d.reasons || []).map((r) => `<div class="reason"><span class="rdot ${esc(r.pillar)}"></span><span>${esc(r.text)}</span></div>`).join('') || '<div class="state">No breakdown available.</div>';
const narr = d.narrative;
const whos = (d.whos_in || []).map(whoRow).join('') || '<div class="state">No wallet footprint recorded yet.</div>';
const out = d.outcome;
$('#drBody').innerHTML = `
<div style="display:flex;align-items:center;gap:18px;margin-bottom:6px">
<div class="dial ${tierClass(c.tier)}" style="text-align:left">
<b style="font-size:40px">${c.score}</b>
<div class="tierpill ${tierPill(c.tier)}">${esc(c.tier)} conviction</div>
</div>
<div style="flex:1" class="pillars">
${pillar('ped', 'Who', p.pedigree)}
${pillar('str', 'How', p.structure)}
${pillar('nar', 'What', p.narrative)}
${pillar('mom', 'Move', p.momentum)}
</div>
</div>
${drawerTake(d)}
<div class="dr-actions">
<a class="dr-act" href="/oracle/coin/${encodeURIComponent(c.mint)}" title="Open the full conviction page">Full page ↗</a>
<a class="dr-act" href="${pumpUrl(c.mint)}" target="_blank" rel="noopener">pump.fun ↗</a>
<a class="dr-act" href="${gmgnTokenUrl(c.mint)}" target="_blank" rel="noopener" title="Trade on GMGN">GMGN ↗</a>
<a class="dr-act" href="${solscan(c.mint)}" target="_blank" rel="noopener">solscan ↗</a>
<a class="dr-act" href="/launches/${esc(c.mint)}" target="_blank" rel="noopener">Details ↗</a>
<a class="dr-act" href="/coin3d?mint=${encodeURIComponent(c.mint)}" target="_blank" rel="noopener" title="Open the full 3D coin profile">View in 3D ↗</a>
<button class="dr-act dr-watch" id="drWatch" data-mint="${esc(c.mint)}" type="button" aria-pressed="${watchedMints().has(c.mint)}">${watchedMints().has(c.mint) ? '★ Watching' : '☆ Watch'}</button>
<button class="dr-act" id="drCopyMint" type="button" title="Copy mint address" data-mint="${esc(c.mint)}">Copy mint</button>
<button class="dr-act" id="drCopyLink" type="button" title="Copy shareable link" data-link="${esc(coinShareUrl(c.mint))}">Copy link</button>
<a class="dr-act dr-share" href="${tweetConviction(c)}" target="_blank" rel="noopener" title="Share conviction on X">Share ↗</a>
${c.structure_cap != null && c.structure_cap < 60 ? `<span class="note warn">structural cap ${c.structure_cap}</span>` : ''}
${d.components?.pedigree_cap != null && d.components.pedigree_cap < 60 ? `<span class="note warn">creator cap ${d.components.pedigree_cap}</span>` : ''}
${d.components?.confidence != null ? `<span class="note ${d.components.confidence >= 70 ? 'ok' : d.components.confidence >= 45 ? '' : 'warn'}" title="How much of this read rests on real data vs. defaulted inputs">data confidence ${d.components.confidence}% · ${esc(d.components.confidence_label || '')}</span>` : ''}
</div>
<div id="scoreHistoryWrap" style="margin-top:12px"></div>
<div id="marketWrap" class="mkt-loading" aria-busy="true">
<div class="dr-sec">Market <span style="color:var(--faint);font-weight:400;font-size:10px">live</span></div>
<div class="mkt-skel"><span></span><span></span><span></span><span></span><span></span><span></span></div>
</div>
${narr ? `<div class="dr-sec">Narrative</div><div style="font-size:13.5px;color:var(--ink)">${esc(narr.narrative || '')}</div>
<div class="coin-meta" style="margin-top:8px"><span class="chip cat">${esc(narr.category)}</span><span class="chip">virality <b>${narr.virality ?? '—'}</b></span><span class="chip">${esc(narr.source || '')}</span></div>` : ''}
<div class="dr-sec">Why this score</div>${reasons}
<div id="communityPulseWrap"></div>
${structurePanel(d.components?.structure)}
<div class="dr-sec">Who's in <span style="color:var(--faint)">(${(d.whos_in || []).length})</span></div>${whos}
${out ? `<div class="dr-sec">Outcome</div><div class="coin-meta">
<span class="chip ${out.graduated ? 'sm' : out.rugged ? 'flag' : ''}">${out.graduated ? 'graduated ✓' : out.rugged ? 'rugged ✕' : 'live'}</span>
${out.ath_multiple ? `<span class="chip">ATH <b>${Number(out.ath_multiple).toFixed(1)}×</b></span>` : ''}</div>` : ''}
<div class="dr-sec">Live trades</div>
<div id="tradeTape" class="trade-tape"></div>
<div id="drProofTradesWrap"></div>
`;
// Fetch and render conviction score history sparkline + community sentiment.
loadScoreHistory(c.mint);
loadCoinMarket(c.mint);
loadSentimentPulse(c.mint);
loadProofTrades(c.mint);
// Update OG / Twitter meta so shared links carry the coin's conviction card.
const ogImg = `https://three.ws/api/oracle/og?mint=${encodeURIComponent(c.mint)}`;
const ogTitle = `$${c.symbol || c.mint.slice(0, 8)} — ${c.score ?? '?'}/100 ${c.tier || ''} conviction · Oracle`;
const ogDesc = `Oracle scored this launch ${c.score ?? '?'}/100 (${c.tier || 'unscored'}). Who · How · What · Move — all fused into one signal.`;
setMeta('og:title', ogTitle);
setMeta('og:description', ogDesc);
setMeta('og:image', ogImg);
setMeta('og:url', `https://three.ws/oracle/coin/${encodeURIComponent(c.mint)}`);
setMeta('twitter:card', 'summary_large_image');
setMeta('twitter:title', ogTitle);
setMeta('twitter:description', ogDesc);
setMeta('twitter:image', ogImg);
// Tear down any previous tape, then mount fresh for this coin.
state.tape?.destroy();
state.tape = null;
const tapeEl = $('#tradeTape');
if (tapeEl) {
import('./oracle-tape.js').then(({ mountTradeTape }) => {
// Guard: drawer may have been closed while the import was in flight.
if (!$('#tradeTape')) return;
state.tape = mountTradeTape(tapeEl, { mint: c.mint, network: NETWORK });
}).catch(() => {
if (tapeEl) tapeEl.innerHTML = '<div class="state" style="padding:16px 0">Trade feed unavailable.</div>';
});
}
// Watch toggle
const watchBtn = $('#drWatch');
if (watchBtn) {
watchBtn.addEventListener('click', () => {
toggleOracleWatch(c.mint);
const now = watchedMints().has(c.mint);
watchBtn.textContent = now ? '★ Watching' : '☆ Watch';
watchBtn.setAttribute('aria-pressed', String(now));
// Reflect on the coin card in the feed grid if visible.
const cardEl = document.querySelector(`#feedGrid .coin[data-mint="${CSS.escape(c.mint)}"]`);
const cardWatchBtn = cardEl?.querySelector('.oc-watch');
if (cardWatchBtn) {
cardWatchBtn.textContent = now ? '★' : '☆';
cardWatchBtn.classList.toggle('oc-watched', now);
cardWatchBtn.setAttribute('aria-pressed', String(now));
}
});
}
// Copy mint address
const copyMintBtn = $('#drCopyMint');
if (copyMintBtn) {
copyMintBtn.addEventListener('click', () => {
navigator.clipboard.writeText(c.mint).then(() => {
const orig = copyMintBtn.textContent;
copyMintBtn.textContent = 'Copied!';
setTimeout(() => { copyMintBtn.textContent = orig; }, 1800);
}).catch(() => {});
});
}
const copyLinkBtn = $('#drCopyLink');
if (copyLinkBtn) {
copyLinkBtn.addEventListener('click', () => {
const link = copyLinkBtn.dataset.link || coinShareUrl(c.mint);
navigator.clipboard.writeText(link).then(() => {
const orig = copyLinkBtn.textContent;
copyLinkBtn.textContent = 'Copied!';
setTimeout(() => { copyLinkBtn.textContent = orig; }, 1800);
}).catch(() => {});
});
}
// Load related coins in same category (async — does not block drawer)
if (c.category) loadRelatedCoins(c.mint, c.category);
}
async function loadRelatedCoins(mint, category) {
const whosSec = $('#drBody')?.querySelector('.dr-sec:last-of-type');
if (!whosSec || !$('#drBody')) return;
const { ok, data } = await api(
`/api/oracle/feed?network=${NETWORK}&category=${encodeURIComponent(category)}&limit=6&min_score=60`
);
if (!ok || !data?.items?.length) return;
if (!$('#drBody')) return; // drawer closed while fetching
const related = data.items.filter((it) => it.mint !== mint).slice(0, 3);
if (!related.length) return;
const TIER_META = { prime: { color: '#e8ebf2' }, strong: { color: '#e4e8f2' }, lean: { color: '#c4c9d6' }, watch: { color: '#8a92a8' }, avoid: { color: '#6c7280' } };
const html = `<div class="dr-sec" style="margin-top:16px">Related · ${esc(category)}</div>
<div style="display:flex;flex-direction:column;gap:6px">
${related.map((r) => {
const tc = (TIER_META[r.tier] || TIER_META.watch).color;
const imgEl = r.image_uri
? `<img ${proxyImgAttrs(r.image_uri, r.mint)} alt="" style="width:28px;height:28px;border-radius:7px;object-fit:cover;flex:none;border:1px solid var(--line)" loading="lazy">`
: `<div style="width:28px;height:28px;border-radius:7px;background:var(--line);display:grid;place-items:center;font:700 11px/1 var(--mono);color:var(--faint);flex:none">${esc((r.symbol||'?')[0])}</div>`;
return `<button type="button" class="dr-related" data-related-mint="${esc(r.mint)}"
style="display:flex;align-items:center;gap:10px;border:1px solid var(--line);border-radius:8px;padding:8px 10px;cursor:pointer;text-align:left;width:100%">
${imgEl}
<span style="flex:1;min-width:0">
<span style="font-weight:700;font-size:13px;display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${esc(r.symbol || r.mint.slice(0,8))}</span>
<span style="font-size:11px;color:var(--muted)">${esc(r.name||'')}</span>
</span>
<span style="display:flex;flex-direction:column;align-items:flex-end;flex:none">
<span style="font:700 14px/1 var(--mono);color:${tc}">${r.score}</span>
<span class="tierpill tp-${esc(r.tier)}" style="margin-top:3px;padding:1px 5px;font-size:9px">${esc(r.tier)}</span>
</span>
</button>`;
}).join('')}
</div>`;
// Insert before the "Who's in" section.
const body = $('#drBody');
if (!body) return;
if (body.dataset.relatedWired !== '1') {
body.dataset.relatedWired = '1';
body.addEventListener('click', (e) => {
const btn = e.target.closest('.dr-related');
const mint = btn?.dataset?.relatedMint;
if (mint) openCoin(mint);
});
}
const whosSecEl = Array.from(body.querySelectorAll('.dr-sec')).find((el) => el.textContent.startsWith("Who's in"));
if (whosSecEl) {
whosSecEl.insertAdjacentHTML('beforebegin', html);
} else {
body.insertAdjacentHTML('beforeend', html);
}
}
function whoRow(w) {
const title = ARCH_TITLE[w.label] || 'Unproven';
const sub = [
w.is_creator ? 'creator' : null,
w.tag ? `@${w.tag}` : null,
w.source === 'gmgn' ? 'gmgn-known' : (w.score != null ? `rep ${Math.round(w.score)}` : null),
w.win_rate != null ? `${Math.round(w.win_rate)}% win` : null,
].filter(Boolean).join(' · ');
return `<div class="nwallet">
<div class="nw-left">
<span class="nw-addr"><span class="nlabel lb-${esc(w.label)}">${esc(title)}</span><a class="solscan" href="${solscan(w.wallet)}" target="_blank" rel="noopener">${esc(shortAddr(w.wallet))}</a></span>
<span class="nw-sub">${esc(sub || '—')}</span>
</div>
<span class="nw-buy">${fmtSol(w.buy_sol)}</span>
</div>`;
}
async function loadScoreHistory(mint) {
const wrap = $('#scoreHistoryWrap');
if (!wrap) return;
const { ok, data } = await api(`/api/oracle/history?mint=${encodeURIComponent(mint)}&network=${NETWORK}&hours=48`);
if (!ok || !data?.points?.length || data.points.length < 2) { wrap.innerHTML = ''; return; }
wrap.innerHTML = renderSparkline(data.points, data.trend);
}
// Live market intel — the fully-populated market half of the coin page. Fused
// server-side across DexScreener / pump.fun / GeckoTerminal / GoPlus / Birdeye /
// CoinGecko (/api/oracle/market). Lazy so the conviction verdict paints first.
async function loadCoinMarket(mint) {
const wrap = $('#marketWrap');
if (!wrap) return;
const { ok, status, data } = await api(`/api/oracle/market?mint=${encodeURIComponent(mint)}&network=${NETWORK}`, { timeout: 15000 });
if (!$('#marketWrap')) return; // drawer closed mid-fetch
wrap.classList.remove('mkt-loading');
wrap.removeAttribute('aria-busy');
if (!ok || !data || data.price?.usd == null) {
// 404 = no live market yet (brand-new mint); anything else = upstreams down.
wrap.innerHTML = status === 404
? `<div class="dr-sec">Market</div><div class="state" style="padding:14px 0">No live market yet — this mint hasn't started trading. Price, liquidity and holders appear the moment it does.</div>`
: `<div class="dr-sec">Market</div><div class="state" style="padding:14px 0">Live market data is momentarily unavailable. <button type="button" class="dr-act" id="mktRetry" data-mint="${esc(mint)}">Retry</button></div>`;
const retry = $('#mktRetry');
if (retry) retry.addEventListener('click', () => { wrap.classList.add('mkt-loading'); wrap.setAttribute('aria-busy', 'true'); loadCoinMarket(mint); });
return;
}
wrap.innerHTML = renderMarket(data);
}
function statTile(label, value, sub = '') {
return `<div class="mkt-tile"><span class="mkt-tile-lbl">${esc(label)}</span><span class="mkt-tile-val">${value}</span>${sub ? `<span class="mkt-tile-sub">${sub}</span>` : ''}</div>`;
}
function changeChip(label, n) {
const c = changeStr(n);
return `<span class="mkt-chg mkt-${c.cls}"><span class="mkt-chg-lbl">${esc(label)}</span><b>${c.txt}</b></span>`;
}
function secChip(ok, label, warnLabel = null) {
if (ok == null) return `<span class="chip" title="not measured">${esc(label)} <b>?</b></span>`;
return ok
? `<span class="chip sm" title="safe">✓ ${esc(label)}</span>`
: `<span class="chip flag" title="risk">⚠ ${esc(warnLabel || label)}</span>`;
}
function renderMarket(m) {
const p = m.price || {};
const ch = p.change || {};
const changeH24 = changeStr(ch.h24);
const tiles = [
statTile('Price', fmtPrice(p.usd), `<span class="mkt-${changeH24.cls}">${changeH24.txt} 24h</span>`),
statTile('Market cap', fmtUsd(m.market_cap_usd)),
m.fdv_usd != null && m.fdv_usd !== m.market_cap_usd ? statTile('FDV', fmtUsd(m.fdv_usd)) : '',
statTile('Liquidity', fmtUsd(m.liquidity_usd)),
statTile('24h volume', fmtUsd(m.volume?.h24)),
statTile('Holders', fmtInt(m.holders)),
].filter(Boolean).join('');
// Price-change chips across every window we have.
const changeWins = [['5m', ch.m5], ['1h', ch.h1], ['6h', ch.h6], ['24h', ch.h24], ['7d', ch.d7]]
.filter(([, v]) => v != null);
const changeRow = changeWins.length
? `<div class="mkt-chg-row">${changeWins.map(([l, v]) => changeChip(l, v)).join('')}</div>` : '';
// Bonding-curve progress (un-graduated pump coins) or a graduated badge.
const pf = m.pumpfun;
let curveHtml = '';
if (pf?.is_pump) {
if (pf.graduated || pf.complete) {
curveHtml = `<div class="mkt-row"><span class="chip sm">Graduated to DEX ✓</span>${pf.ath_market_cap_usd ? `<span class="chip">ATH mcap <b>${fmtUsd(pf.ath_market_cap_usd)}</b></span>` : ''}</div>`;
} else if (pf.bonding_curve_pct != null) {
const pct = Math.round(pf.bonding_curve_pct);
curveHtml = `<div class="mkt-curve">
<div class="mkt-curve-top"><span>Bonding curve</span><b>${pct}% to graduation</b></div>
<div class="mkt-curve-track"><div class="mkt-curve-fill" style="width:${Math.max(2, Math.min(100, pct))}%"></div></div>
${pf.real_sol_reserves != null ? `<div class="mkt-curve-sub">${pf.real_sol_reserves.toFixed(1)} ◎ in curve${pf.reply_count ? ` · ${fmtInt(pf.reply_count)} replies` : ''}${pf.is_live ? ' · <span class="mkt-up">live now</span>' : ''}</div>` : ''}
</div>`;
}
}
// 24h buy/sell activity split.
const act = m.activity;
let activityHtml = '';
if (act && act.txns_24h) {
const buyPct = Math.round((act.buy_ratio ?? 0.5) * 100);
activityHtml = `<div class="mkt-act">
<div class="mkt-act-top"><span>24h activity</span><span class="mkt-faint">${fmtInt(act.txns_24h)} txns</span></div>
<div class="mkt-act-track"><div class="mkt-act-buy" style="width:${buyPct}%"></div></div>
<div class="mkt-act-legend"><span class="mkt-up">${fmtInt(act.buys_24h)} buys</span><span class="mkt-down">${fmtInt(act.sells_24h)} sells</span></div>
</div>`;
}
// Supply.
const sup = m.supply || {};
const supplyChips = [
sup.total != null ? `<span class="chip">supply <b>${fmtInt(sup.total)}</b></span>` : '',
sup.circulating != null && Math.abs((sup.circulating || 0) - (sup.total || 0)) > (sup.total || 0) * 0.01
? `<span class="chip">circulating <b>${fmtInt(sup.circulating)}</b></span>` : '',
m.identity?.created_at ? `<span class="chip" title="First trade / launch">age <b>${ago(m.identity.created_at)}</b></span>` : '',
].filter(Boolean).join('');
// Security posture.
const sec = m.security;
const secHtml = sec
? `<div class="dr-sec">Security <span style="color:var(--faint);font-weight:400;font-size:10px">GoPlus</span></div>
<div class="coin-meta">
${secChip(sec.mint_authority_revoked, 'Mint revoked', 'Mint authority live')}
${secChip(sec.freeze_authority_revoked, 'Freeze revoked', 'Can freeze')}
${secChip(sec.metadata_mutable === false ? true : (sec.metadata_mutable === true ? false : null), 'Metadata locked', 'Mutable metadata')}
${sec.transfer_fee_pct != null ? (sec.transfer_fee_pct > 0 ? `<span class="chip flag" title="transfer tax">⚠ ${sec.transfer_fee_pct}% fee</span>` : `<span class="chip sm">No transfer fee</span>`) : ''}
${sec.top10_holder_pct != null ? `<span class="chip ${sec.top10_holder_pct > 50 ? 'flag' : ''}" title="Top 10 holder concentration">top 10 <b>${Math.round(sec.top10_holder_pct)}%</b></span>` : ''}
${sec.trusted_token ? '<span class="chip sm" title="GoPlus verified list">Trusted ✓</span>' : ''}
</div>` : '';
// Listing — only for coins CoinGecko tracks (rank / ATH / ATL / categories).
const lst = m.listing;
let listingHtml = '';
if (lst && (lst.market_cap_rank != null || lst.ath_usd != null || (lst.categories && lst.categories.length))) {
const athChg = changeStr(lst.ath_change_pct);
listingHtml = `<div class="dr-sec">Listed market <span style="color:var(--faint);font-weight:400;font-size:10px">CoinGecko</span></div>
<div class="coin-meta">
${lst.market_cap_rank != null ? `<span class="chip">rank <b>#${lst.market_cap_rank}</b></span>` : ''}
${lst.ath_usd != null ? `<span class="chip" title="All-time high (${lst.ath_date ? new Date(lst.ath_date).toLocaleDateString() : ''})">ATH <b>${fmtPrice(lst.ath_usd)}</b> <span class="mkt-${athChg.cls}">${athChg.txt}</span></span>` : ''}
${lst.atl_usd != null ? `<span class="chip" title="All-time low">ATL <b>${fmtPrice(lst.atl_usd)}</b></span>` : ''}
</div>
${lst.categories && lst.categories.length ? `<div class="coin-meta" style="margin-top:6px">${lst.categories.slice(0, 5).map((c) => `<span class="chip cat">${esc(c)}</span>`).join('')}</div>` : ''}`;
}
// DEX pairs.
const pairs = Array.isArray(m.pairs) ? m.pairs.filter((pr) => pr.url) : [];
const pairsHtml = pairs.length
? `<div class="dr-sec">Markets <span style="color:var(--faint);font-weight:400;font-size:10px">${pairs.length} pair${pairs.length > 1 ? 's' : ''}</span></div>
<div class="mkt-pairs">${pairs.slice(0, 5).map((pr) => `
<a class="mkt-pair" href="${esc(pr.url)}" target="_blank" rel="noopener">
<span class="mkt-pair-dex">${esc(pr.dex || 'dex')}${pr.quote_symbol ? ` <span class="mkt-faint">/${esc(pr.quote_symbol)}</span>` : ''}</span>
<span class="mkt-pair-liq">${fmtUsd(pr.liquidity_usd)} liq</span>
<span class="mkt-pair-arrow">↗</span>
</a>`).join('')}</div>` : '';
// Chart + explorer + social links.
const lk = m.links || {};
const linkBtns = [
lk.gmgn ? `<a class="dr-act" href="${esc(lk.gmgn)}" target="_blank" rel="noopener">GMGN ↗</a>` : '',
lk.dextools ? `<a class="dr-act" href="${esc(lk.dextools)}" target="_blank" rel="noopener">DEXTools ↗</a>` : '',
lk.dexscreener ? `<a class="dr-act" href="${esc(lk.dexscreener)}" target="_blank" rel="noopener">DexScreener ↗</a>` : '',
lk.geckoterminal ? `<a class="dr-act" href="${esc(lk.geckoterminal)}" target="_blank" rel="noopener">GeckoTerminal ↗</a>` : '',
lk.birdeye ? `<a class="dr-act" href="${esc(lk.birdeye)}" target="_blank" rel="noopener">Birdeye ↗</a>` : '',
lk.website ? `<a class="dr-act" href="${esc(lk.website)}" target="_blank" rel="noopener">Website ↗</a>` : '',
lk.twitter ? `<a class="dr-act" href="${esc(lk.twitter)}" target="_blank" rel="noopener">X ↗</a>` : '',
lk.telegram ? `<a class="dr-act" href="${esc(lk.telegram)}" target="_blank" rel="noopener">Telegram ↗</a>` : '',
].filter(Boolean).join('');
const srcNote = Array.isArray(m.sources) && m.sources.length
? `<div class="mkt-src">Live · ${m.sources.map(esc).join(' · ')}</div>` : '';
return `<div class="dr-sec">Market <span style="color:var(--faint);font-weight:400;font-size:10px">live${p.native_sol ? ` · ${p.native_sol < 0.0001 ? p.native_sol.toExponential(2) : p.native_sol.toFixed(6)} ◎` : ''}</span></div>
<div class="mkt-stats">${tiles}</div>
${changeRow}
${curveHtml}
${activityHtml}
${supplyChips ? `<div class="coin-meta" style="margin-top:10px">${supplyChips}</div>` : ''}
${secHtml}
${listingHtml}
${pairsHtml}
${linkBtns ? `<div class="dr-actions" style="margin-top:12px">${linkBtns}</div>` : ''}
${srcNote}`;
}
async function loadSentimentPulse(mint) {
const wrap = $('#communityPulseWrap');
if (!wrap) return;
try {
const res = await fetch('/api/social/sentiment-pulse', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ token: mint }),
signal: AbortSignal.timeout(10000),
});
if (!res.ok) { if ($('#communityPulseWrap')) $('#communityPulseWrap').innerHTML = ''; return; }
const d = await res.json();
const el = $('#communityPulseWrap');
if (!el) return;
if (!d.ok || !d.overall || d.overall.count < 3) { el.innerHTML = ''; return; }
const o = d.overall;
const scoreColor = o.score >= 60 ? 'var(--up)' : o.score <= 40 ? 'var(--down)' : 'var(--muted)';
const sentLabel = o.score >= 60 ? 'bullish' : o.score <= 40 ? 'bearish' : 'mixed';
const sentChipCls = o.score >= 60 ? 'sm' : o.score <= 40 ? 'flag' : '';
const exHtml = (o.examples || []).slice(0, 2).map(
(ex) => `<div class="reason" style="font-size:11.5px;opacity:.75"><span class="rdot nar"></span><span>${esc(ex)}</span></div>`
).join('');
el.innerHTML = `
<div class="dr-sec">Community pulse <span style="color:var(--faint);font-weight:400;font-size:10px">pump.fun · ${o.count} comments</span></div>
<div class="coin-meta" style="margin-bottom:8px">
<span class="chip ${sentChipCls}" style="color:${scoreColor}">${sentLabel} · ${o.score}</span>
</div>
<div class="str-grid">
<div class="str-row">
<span class="str-lbl">Positive</span>
<div class="str-track"><div class="str-fill" style="width:${Math.round(o.posPct)}%;background:var(--up)"></div></div>
<span class="str-val" style="color:var(--up)">${Math.round(o.posPct)}%</span>
</div>
<div class="str-row">
<span class="str-lbl">Negative</span>
<div class="str-track"><div class="str-fill" style="width:${Math.round(o.negPct)}%;background:var(--down)"></div></div>
<span class="str-val" style="color:var(--down)">${Math.round(o.negPct)}%</span>
</div>
<div class="str-row">
<span class="str-lbl">Neutral</span>
<div class="str-track"><div class="str-fill" style="width:${Math.round(o.neuPct)}%;background:var(--muted)"></div></div>
<span class="str-val" style="color:var(--muted)">${Math.round(o.neuPct)}%</span>
</div>
</div>
${exHtml}`;
} catch {
const el = $('#communityPulseWrap');
if (el) el.innerHTML = '';
}
}
function renderSparkline(points, trend) {
const W = 220; const H = 40; const PAD = 4;
const scores = points.map((p) => Number(p.score));
const min = Math.max(0, Math.min(...scores) - 5);
const max = Math.min(100, Math.max(...scores) + 5);
const range = max - min || 1;
const n = scores.length;
const xs = scores.map((_, i) => PAD + (i / (n - 1)) * (W - PAD * 2));
const ys = scores.map((s) => PAD + (1 - (s - min) / range) * (H - PAD * 2));
const d = xs.map((x, i) => `${i === 0 ? 'M' : 'L'}${x.toFixed(1)},${ys[i].toFixed(1)}`).join(' ');
const trendColor = trend === 'rising' ? '#e4e8f2' : trend === 'falling' ? '#6c7280' : '#8a92a8';
const trendArrow = trend === 'rising' ? '↑' : trend === 'falling' ? '↓' : '→';
const lastScore = scores[n - 1];
const firstScore = scores[0];
const delta = lastScore - firstScore;
const deltaStr = delta > 0 ? `+${delta}` : `${delta}`;
return `<div style="display:flex;align-items:center;gap:8px;padding:8px 0 4px">
<svg width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" style="flex-shrink:0;overflow:visible" aria-label="Conviction history">
<polyline points="${xs.map((x, i) => `${x.toFixed(1)},${ys[i].toFixed(1)}`).join(' ')}" fill="none" stroke="${trendColor}" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" opacity="0.9"/>
<circle cx="${xs[n-1].toFixed(1)}" cy="${ys[n-1].toFixed(1)}" r="2.5" fill="${trendColor}"/>
</svg>
<div style="font-size:11px;line-height:1.4;flex-shrink:0">
<div style="color:${trendColor};font-weight:700;letter-spacing:.02em">${trendArrow} ${deltaStr} pts</div>
<div style="color:var(--muted)">${points.length} readings · 48 h</div>
</div>
</div>`;
}
// Load closed proof trades from agent_sniper_positions for this specific coin.
// Surfaces after the live tape so users can see: real exits, P&L, and the agent
// who made it — with a direct link to copy that trader.
async function loadProofTrades(mint) {
const wrap = $('#drProofTradesWrap');
if (!wrap) return;
try {
const r = await fetch(`/api/trades/feed?mint=${encodeURIComponent(mint)}&min_pnl_pct=0&limit=8`);
if (!r.ok) return;
const { items = [] } = await r.json();
if (!$('#drProofTradesWrap')) return; // drawer closed mid-fetch
if (!items.length) { wrap.innerHTML = ''; return; }
const rows = items.map((t) => {
const sym = esc((t.symbol || t.mint?.slice(0, 6) || '?').toUpperCase());
const agent = esc(t.agent_name || t.agent_id?.slice(0, 8) || 'Agent');
const mult = t.multiple != null ? `${t.multiple.toFixed(2)}×` : null;
const pct = t.realized_pnl_pct != null ? `+${Math.round(t.realized_pnl_pct)}%` : null;
const pnlSol = t.realized_pnl_sol != null ? `+${t.realized_pnl_sol.toFixed(3)} ◎` : null;
const isPos = (t.realized_pnl_sol ?? 0) >= 0;
const color = isPos ? 'var(--up, #e4e8f2)' : 'var(--down, #6c7280)';
return `<div class="dr-ptrade">
<span class="dr-ptrade-mult" style="color:${color}">${mult || pct || pnlSol || '+?'}</span>
<div class="dr-ptrade-mid">
<span class="dr-ptrade-agent">${agent}</span>
${pnlSol ? `<span style="color:${color};font-size:11px">${pnlSol}</span>` : ''}
</div>
<a class="dr-act" href="/trader/${encodeURIComponent(t.agent_id || '')}" style="font-size:11.5px;padding:4px 8px">Copy →</a>
</div>`;
}).join('');
wrap.innerHTML = `<div class="dr-sec" style="margin-top:16px">Agent exits on this coin <span style="color:var(--faint);font-weight:400;font-size:10px">${items.length} found</span></div>
<div style="display:flex;flex-direction:column;gap:4px">${rows}</div>`;
} catch { /* non-fatal */ }
}
function closeDrawer() {
const dr = $('#drawer'); dr.classList.remove('open'); dr.setAttribute('aria-hidden', 'true');
// Tear down the trade tape so the PumpPortal SSE connection closes.
state.tape?.destroy();
state.tape = null;
// Clear the mint param so the URL reflects the closed state.
const url = new URL(location.href);
if (url.searchParams.has('mint')) {
url.searchParams.delete('mint');
history.replaceState(null, '', url.toString());
}
}
async function openWallet(wallet) {
switchView('feed'); // close any drawer context; wallets open in drawer too
const dr = $('#drawer');
dr.classList.add('open'); dr.setAttribute('aria-hidden', 'false');
$('#drTitle').textContent = shortAddr(wallet);
$('#drBody').innerHTML = '<div class="state">Pulling track record…</div>';
const { ok, data } = await api(`/api/oracle/wallet?address=${encodeURIComponent(wallet)}&network=${NETWORK}`);
if (!ok || !data) { $('#drBody').innerHTML = '<div class="state">Could not load this wallet.</div>'; return; }
const r = data.reputation; const a = data.archetype || {};
$('#drTitle').innerHTML = `<span class="nlabel lb-${esc(a.label)}">${esc(a.title || 'Unproven')}</span> ${esc(shortAddr(wallet))}`;
const recent = (data.recent || []).map((c) => `<div class="nwallet"><div class="nw-left"><span class="nw-addr">${esc(c.symbol || c.mint.slice(0, 6))} ${c.is_creator ? '<span class="nlabel lb-rugger">created</span>' : ''}</span><span class="nw-sub">${esc(c.category || '')}</span></div><span class="nw-buy">${fmtSol(c.buy_sol)}</span></div>`).join('') || '<div class="state">No recent coins recorded.</div>';
$('#drBody').innerHTML = `
<div style="font-size:13px;color:var(--muted);margin-bottom:14px">${esc(a.blurb || '')}</div>
${r ? `<div class="pillars" style="grid-template-columns:repeat(2,1fr);gap:12px">
${pillar('ped', 'Smart score', Math.round(r.score))}
${pillar('str', 'Win rate', Math.round(r.win_rate))}
${pillar('nar', 'Early win', Math.round(r.early_win_rate))}
${pillar('mom', 'Dump rate', Math.round(r.dump_rate))}
</div>
<div class="coin-meta" style="margin-top:14px">
<span class="chip">coins <b>${r.coins_traded ?? 0}</b></span>
<span class="chip">early <b>${r.early_entries ?? 0}</b></span>
<span class="chip sm">wins <b>${r.wins ?? 0}</b></span>
<span class="chip flag">duds <b>${r.duds ?? 0}</b></span>
${r.creator_count ? `<span class="chip">created <b>${r.creator_count}</b></span>` : ''}
</div>` : '<div class="state">This wallet has no judged history yet.</div>'}
<div class="dr-sec">Recent footprint</div>${recent}
<div class="dr-actions" style="margin-top:16px">
<a class="dr-act" href="/trader/${encodeURIComponent(wallet)}" rel="noopener">Trader profile ↗</a>
<a class="dr-act" href="/trader/${encodeURIComponent(wallet)}#copy" rel="noopener" style="background:rgba(255,255,255,.12);border-color:rgba(255,255,255,.28)">Copy trades →</a>
<a class="dr-act solscan" href="${solscan(wallet)}" target="_blank" rel="noopener">Solscan ↗</a>
</div>
`;
}
// ── agent arm panel ──────────────────────────────────────────────────────────
// Configuration lives on the dedicated /oracle/arm page (the trading-bot setup
// surface). Here we show a compact status summary + the live action ledger, and
// hand off to that page to change anything.
async function loadAgentPanel() {
const body = $('#armBody');
body.dataset.loaded = '1';
body.innerHTML = '<div class="state">Loading your agents…</div>';
const { ok, data } = await api('/api/agents');
const agents = ok && data ? (data.agents || data.items || data || []) : [];
state.agents = Array.isArray(agents) ? agents : [];
if (!state.agents.length) {
body.innerHTML = `<div class="state"><b>Sign in and create a 3D agent</b>Your agent needs its own custodial Solana wallet to act on conviction. Create one in the studio, then come back to arm it.
<div style="margin-top:16px"><a class="btn" href="/create/studio">Create an agent →</a></div></div>`;
return;
}
const opts = state.agents.map((a) => `<option value="${esc(a.id)}">${esc(a.name || a.id)}</option>`).join('');
body.innerHTML = `
<div class="field"><label>Agent</label><select id="agSel">${opts}</select></div>
<div id="armSummary"><div class="state" style="padding:18px 0">Loading configuration…</div></div>
<a class="btn primary" href="/oracle/arm" style="margin-top:14px;text-decoration:none">Open full setup →</a>`;
$('#agSel').addEventListener('change', () => loadWatch($('#agSel').value));
state.agentId = state.agents[0].id;
loadWatch(state.agentId);
}
function armSummaryHtml(w) {
if (!w) return '<div class="state" style="padding:18px 0">Not configured yet — open the full setup to arm this agent.</div>';
const min = w.min_score >= 86 ? 'Prime (≥86)' : w.min_score >= 72 ? 'Strong+ (≥72)' : 'Lean+ (≥56)';
const live = w.mode === 'live';
const dotCls = !w.armed ? 'off' : live ? 'live' : 'sim';
const statusLab = !w.armed ? 'Disarmed' : live ? 'Armed · Live' : 'Armed · Simulate';
const cats = (w.categories && w.categories.length) ? w.categories.map((c) => `<span class="cchip on" style="pointer-events:none">${esc(c)}</span>`).join('') : '<span style="color:var(--faint)">any narrative</span>';
const row = (k, v) => `<div class="arm-srow"><span>${k}</span><b>${v}</b></div>`;
return `
<div class="arm-status arm-${dotCls}"><i></i>${esc(statusLab)}</div>
<div class="arm-sgrid">
${row('Min conviction', esc(min))}
${row('Size / trade', fmtSol(w.per_trade_sol))}
${row('Max daily', fmtSol(w.max_daily_sol))}
${row('Max open', w.max_open ?? 5)}
${row('Smart money', w.require_smart_money !== false ? 'Required' : 'Optional')}
${row('Size scaling', w.size_scaling ? 'On' : 'Off')}
</div>
<div class="arm-cats">${cats}</div>
${w.telegram_chat_id ? '<div class="arm-tg">✓ Telegram alerts active</div>' : ''}`;
}
async function loadWatch(agentId) {
state.agentId = agentId;
const sum = $('#armSummary');
const { ok, data } = await api(`/api/oracle/watch?agent_id=${encodeURIComponent(agentId)}&network=${NETWORK}`);
const w = ok && data ? data.watch : null;
state.watch = w;
if (sum) sum.innerHTML = armSummaryHtml(w);
loadActions(agentId);
}
async function loadActions(agentId) {
const body = $('#actionsBody');
const { ok, data } = await api(`/api/oracle/watch?agent_id=${encodeURIComponent(agentId)}&network=${NETWORK}`);
const actions = ok && data ? (data.actions || []) : [];
const s = (ok && data && data.summary) || null;
const pnlSign = (v) => v >= 0 ? '+' : '';
const statline = s && s.total ? `
<div class="act-kpis">
<div class="act-kpi"><span>Total</span><b>${s.total}</b></div>
<div class="act-kpi"><span>Wins</span><b class="${s.wins > 0 ? 'up' : ''}">${s.wins}</b></div>
<div class="act-kpi"><span>Losses</span><b class="${s.losses > 0 ? 'dn' : ''}">${s.losses}</b></div>
<div class="act-kpi"><span>Win rate</span><b>${s.win_rate == null ? '—' : s.win_rate + '%'}</b></div>
<div class="act-kpi"><span>Realized PnL</span><b class="${s.realized_pnl_sol >= 0 ? 'up' : 'dn'}">${pnlSign(s.realized_pnl_sol)}${fmtSol(s.realized_pnl_sol)}</b></div>
${s.roi_pct != null ? `<div class="act-kpi"><span>ROI</span><b class="${s.roi_pct >= 0 ? 'up' : 'dn'}">${pnlSign(s.roi_pct)}${s.roi_pct}%</b></div>` : ''}
${s.open > 0 ? `<div class="act-kpi"><span>Open</span><b>${s.open}</b></div>` : ''}
</div>` : '';
if (!actions.length) {
body.innerHTML = `${statline}<div class="state">No actions yet — once armed, every buy lands here and gets graded against the outcome in real time.</div>`;
return;
}
const rows = actions.map(actionRow).join('');
body.innerHTML = `
${statline}
<div class="act-wrap">
<table class="act-table">
<thead><tr>
<th scope="col">Coin</th><th scope="col">Tier</th><th scope="col">Conv.</th>
<th scope="col">Size</th><th scope="col">Outcome</th><th scope="col">PnL</th><th scope="col">When</th>
</tr></thead>
<tbody>${rows}</tbody>
</table>
</div>`;
}
function actionRow(a) {
const outcome = a.outcome || 'open';
const outCls = outcome === 'win' ? 'up' : outcome === 'loss' ? 'dn' : '';
let outLabel;
if (outcome === 'win') outLabel = `✓ Win${a.peak_multiple ? ` · ${Number(a.peak_multiple).toFixed(1)}×` : ''}`;
else if (outcome === 'loss') outLabel = '✗ Loss';
else if (a.exit_signal) outLabel = `<span class="act-exit act-exit-${esc(a.exit_signal.urgency || 'normal')}" title="${esc(a.exit_signal.reason)}">⚠ Exit</span>`;
else outLabel = 'Open';
const pnl = a.realized_pnl_sol != null ? `${Number(a.realized_pnl_sol) >= 0 ? '+' : ''}${fmtSol(a.realized_pnl_sol)}` : '—';
const pnlCls = a.realized_pnl_sol != null ? (Number(a.realized_pnl_sol) >= 0 ? 'up' : 'dn') : '';
const modeBadge = a.mode === 'live' ? '<span class="act-live">live</span>' : '<span class="act-sim">sim</span>';
// For open positions show current conviction score alongside entry, with delta.
let convCell;
if (outcome === 'open' && a.current_score != null) {
const entry = Number(a.conviction) || 0;
const cur = Number(a.current_score);
const delta = cur - entry;
const deltaCls = delta > 0 ? 'up' : delta < 0 ? 'dn' : '';
const deltaStr = delta !== 0 ? `<span class="act-delta ${deltaCls}">${delta > 0 ? '+' : ''}${delta}</span>` : '';
const curCls = tierPill(a.current_tier);
convCell = `<span class="${curCls}" style="padding:1px 4px;font-size:11px">${cur}</span>${deltaStr}`;
} else {
convCell = a.conviction ?? '—';
}
return `<tr class="act-row" data-outcome="${esc(outcome)}">
<td class="act-coin"><a href="https://pump.fun/coin/${esc(a.mint)}" target="_blank" rel="noopener">${esc(a.symbol || a.mint.slice(0, 6))}</a> ${modeBadge}</td>
<td><span class="tierpill ${tierPill(a.tier)}">${esc(a.tier || '—')}</span></td>
<td class="act-mono">${convCell}</td>
<td class="act-mono">${fmtSol(a.size_sol)}</td>
<td class="act-mono ${outCls}">${outLabel}</td>
<td class="act-mono ${pnlCls}">${pnl}</td>
<td class="act-when" title="${esc(a.acted_at || '')}">${ago(a.acted_at)} ago</td>
</tr>`;
}
document.addEventListener('DOMContentLoaded', boot);