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
// Event Markets rollup: turns resolved markets into scores, stats, ranks, badges
// and season payout proposals. Called by api/cron/event-markets-rollup.js.
//
// Idempotent end to end. A settled pick is written to event_market_scores once
// (primary key market_id + account_id, insert ... on conflict do nothing), stats
// are recomputed from that ledger only for the seasons that gained rows, badges
// are unique per (user, code), and payout proposals are unique per (season,
// account). A rerun with nothing new changes nothing. Paying a proposal is
// owner-gated and is never done here.
import { sql } from '../db.js';
import { unlockBadge } from '../streaks.js';
import { impliedOdds } from './index.js';
import { loadAccountSignals, rankedVerdict } from './fairness.js';
import {
CONFIG, clampStake, scorePick, pickProbability, seasonFor, seasonById, computeStats, rankAccounts, pickBadgesFor, rewardForRank,
} from './scoring.js';
const MARKET_BATCH = 200;
/**
* Fallback for a pick that carries no odds_at_pick (placed before the column
* existed): the odds each account saw when it made its standing pick, replayed from the
* append-only pick log with the same impliedOdds the market page uses. The odds
* are those of the market right before the pick, without the account's own
* earlier pick, so staking on an outcome never lowers its own payout. PURE.
* @param {{outcome_id:string, account_id:string, points:number, action:string}[]} log ordered by id
* @param {string[]} outcomeIds
* @returns {Map<string, number>} account id -> probability of the picked outcome at pick time
*/
export function oddsAtPickFromLog(log, outcomeIds) {
const live = new Map();
const seen = new Map();
for (const e of log) {
if (e.action === 'withdraw' || e.action === 'void') {
live.delete(e.account_id);
seen.delete(e.account_id);
continue;
}
live.delete(e.account_id);
const tally = new Map(outcomeIds.map((id) => [id, { id, points: 0, picks: 0 }]));
for (const p of live.values()) {
const t = tally.get(p.outcome_id);
if (t) {
t.points += p.points;
t.picks += 1;
}
}
const share = impliedOdds([...tally.values()]).outcomes.find((o) => o.outcome_id === e.outcome_id)?.share;
seen.set(e.account_id, Number(share));
live.set(e.account_id, { outcome_id: e.outcome_id, points: e.points });
}
return seen;
}
/** Ledger rows for picks on resolved markets that have not been scored. PURE. */
export function buildScoreRows(picks, oddsByMarket, verdictFor) {
return picks.map((p) => {
const stored = p.odds_at_pick == null ? null : Number(p.odds_at_pick);
const odds = pickProbability(stored ?? oddsByMarket.get(p.market_id)?.get(p.account_id), p.outcome_count);
const correct = p.outcome_id === p.winner_outcome_id;
const verdict = verdictFor(p);
const settled = p.resolved_at || p.updated_at;
return {
market_id: p.market_id,
account_id: p.account_id,
source_kind: p.source_kind,
season_id: seasonFor(p.locks_at).id,
correct,
points_staked: clampStake(p.points),
odds_at_pick: odds,
delta: scorePick({ correct, points: p.points, odds, outcomeCount: p.outcome_count }),
ranked: verdict.ranked,
unranked_reason: verdict.reason,
settled_at: new Date(settled).toISOString(),
};
});
}
async function settleResolvedMarkets() {
const markets = await sql`
select distinct m.id, m.resolved_at
from event_markets m
join event_market_picks k on k.market_id = m.id and k.agent_id is null
where m.status = 'resolved' and m.winner_outcome_id is not null
and not exists (select 1 from event_market_scores s where s.market_id = m.id and s.account_id = k.account_id)
order by m.resolved_at nulls last, m.id
limit ${MARKET_BATCH}
`;
if (!markets.length) return { inserted: 0, accounts: new Set(), seasons: new Set() };
const ids = markets.map((m) => m.id);
const picks = await sql`
select k.market_id, k.account_id, k.outcome_id, k.points, k.created_at as picked_at, k.odds_at_pick, k.ranked,
m.source_kind, m.locks_at, m.updated_at, m.resolved_at, m.winner_outcome_id,
(select count(*)::int from event_market_outcomes o where o.market_id = m.id) as outcome_count
from event_market_picks k
join event_markets m on m.id = k.market_id
where k.market_id = any(${ids}::uuid[]) and k.agent_id is null
and not exists (select 1 from event_market_scores s where s.market_id = k.market_id and s.account_id = k.account_id)
`;
const outcomes = await sql`select id, market_id from event_market_outcomes where market_id = any(${ids}::uuid[])`;
const log = await sql`
select market_id, outcome_id, account_id, points, action
from event_market_pick_log where market_id = any(${ids}::uuid[]) order by id asc
`;
const outcomeIds = new Map();
for (const o of outcomes) outcomeIds.set(o.market_id, [...(outcomeIds.get(o.market_id) || []), o.id]);
const logByMarket = new Map();
for (const e of log) logByMarket.set(e.market_id, [...(logByMarket.get(e.market_id) || []), e]);
const oddsByMarket = new Map(ids.map((id) => [id, oddsAtPickFromLog(logByMarket.get(id) || [], outcomeIds.get(id) || [])]));
const unranked = picks.filter((p) => !p.ranked);
const signals = await loadAccountSignals([...new Set(unranked.map((p) => p.account_id))]);
const verdictFor = (p) => (p.ranked ? { ranked: true, reason: null } : { ranked: false, reason: rankedVerdict(signals.get(p.account_id), p.picked_at).reason || 'unranked_at_pick' });
const rows = buildScoreRows(picks, oddsByMarket, verdictFor);
return writeScores(rows);
}
async function writeScores(rows) {
const inserted = await sql`
insert into event_market_scores (market_id, account_id, source_kind, season_id, correct, points_staked, odds_at_pick, delta, ranked, unranked_reason, settled_at)
select * from unnest(
${rows.map((r) => r.market_id)}::uuid[], ${rows.map((r) => r.account_id)}::uuid[], ${rows.map((r) => r.source_kind)}::text[],
${rows.map((r) => r.season_id)}::text[], ${rows.map((r) => r.correct)}::boolean[], ${rows.map((r) => r.points_staked)}::int[],
${rows.map((r) => r.odds_at_pick)}::numeric[], ${rows.map((r) => r.delta)}::int[], ${rows.map((r) => r.ranked)}::boolean[],
${rows.map((r) => r.unranked_reason)}::text[], ${rows.map((r) => r.settled_at)}::timestamptz[]
)
on conflict (market_id, account_id) do nothing
returning account_id, season_id
`;
return {
inserted: inserted.length,
accounts: new Set(inserted.map((r) => r.account_id)),
seasons: new Set(inserted.map((r) => r.season_id)),
};
}
/** Stats rows for one scope: every source kind plus 'all', ranked. PURE. */
export function statsForScope(ledger, { scope_kind, season_id }) {
const inScope = ledger.filter((r) => r.ranked && (scope_kind === 'all' || r.season_id === season_id));
const kinds = ['all', ...new Set(inScope.map((r) => r.source_kind))];
const minCalls = scope_kind === 'season' ? CONFIG.seasons.min_calls_to_rank : 1;
const out = [];
for (const kind of kinds) {
const byAccount = new Map();
for (const r of inScope) {
if (kind !== 'all' && r.source_kind !== kind) continue;
if (!byAccount.has(r.account_id)) byAccount.set(r.account_id, []);
byAccount.get(r.account_id).push(r);
}
const entries = [...byAccount].map(([account_id, rows]) => ({ account_id, ...computeStats(rows) }));
const ranked = new Map(rankAccounts(entries, { minCalls }).map((e) => [e.account_id, e.rank]));
for (const e of entries) {
out.push({ scope_kind, season_id: scope_kind === 'all' ? '' : season_id, source_kind: kind, ...e, rank: ranked.get(e.account_id) ?? null });
}
}
return out;
}
async function writeStats(rows) {
for (let i = 0; i < rows.length; i += 500) {
const b = rows.slice(i, i + 500);
await sql`
insert into event_market_stats (scope_kind, season_id, source_kind, account_id, calls, hits, score, avg_odds, best_call_delta, best_call_market, current_streak, longest_streak, rank, updated_at)
select *, now() from unnest(
${b.map((r) => r.scope_kind)}::text[], ${b.map((r) => r.season_id)}::text[], ${b.map((r) => r.source_kind)}::text[],
${b.map((r) => r.account_id)}::uuid[], ${b.map((r) => r.calls)}::int[], ${b.map((r) => r.hits)}::int[], ${b.map((r) => r.score)}::int[],
${b.map((r) => r.avg_odds)}::numeric[], ${b.map((r) => r.best_call_delta)}::int[], ${b.map((r) => r.best_call_market)}::uuid[],
${b.map((r) => r.current_streak)}::int[], ${b.map((r) => r.longest_streak)}::int[], ${b.map((r) => r.rank)}::int[]
)
on conflict (scope_kind, season_id, source_kind, account_id) do update set
calls = excluded.calls, hits = excluded.hits, score = excluded.score, avg_odds = excluded.avg_odds,
best_call_delta = excluded.best_call_delta, best_call_market = excluded.best_call_market,
current_streak = excluded.current_streak, longest_streak = excluded.longest_streak,
rank = excluded.rank, updated_at = now()
`;
}
}
async function awardPickBadges(accountIds) {
const fresh = [];
for (const accountId of accountIds) {
const rows = await sql`
select market_id, correct, odds_at_pick, delta, settled_at
from event_market_scores where account_id = ${accountId} and ranked
`;
for (const code of pickBadgesFor(rows)) {
if (await unlockBadge(accountId, code)) fresh.push({ accountId, code });
}
}
return fresh;
}
/** Badges and payout proposals for seasons that have ended. */
async function finalizeEndedSeasons(now) {
const seasonRows = await sql`select distinct season_id from event_market_stats where scope_kind = 'season' and source_kind = 'all'`;
const ended = seasonRows.map((r) => seasonById(r.season_id, now)).filter((s) => s && s.ended);
let badges = 0;
let proposals = 0;
for (const season of ended) {
const top = await sql`
select s.account_id, s.rank, s.score, u.deleted_at
from event_market_stats s join users u on u.id = s.account_id
where s.scope_kind = 'season' and s.season_id = ${season.id} and s.source_kind = 'all'
and s.rank is not null and s.score > 0 and s.rank <= ${CONFIG.badges.season_top_n} and u.deleted_at is null
order by s.rank, s.account_id
`;
for (const r of top) {
if (await unlockBadge(r.account_id, 'em_season_top10', { season: season.id, rank: r.rank })) badges += 1;
if (r.rank === 1 && (await unlockBadge(r.account_id, 'em_season_champion', { season: season.id }))) badges += 1;
}
const rewarded = top.filter((r) => rewardForRank(r.rank));
for (const r of rewarded) {
const tier = rewardForRank(r.rank);
const [wallet] = await sql`
select address from user_wallets where user_id = ${r.account_id} and chain_type = 'solana'
order by is_primary desc, last_used_at desc nulls last, created_at limit 1
`;
const ins = await sql`
insert into event_market_season_payouts (season_id, rank, account_id, wallet_address, amount, token, chain, perk, note)
values (${season.id}, ${r.rank}, ${r.account_id}, ${wallet?.address ?? null}, ${tier.three}, ${CONFIG.rewards.token}, ${CONFIG.rewards.chain}, ${tier.perk},
${wallet ? null : 'No linked Solana wallet: the winner must link one before this can be paid.'})
on conflict (season_id, account_id) do nothing
returning account_id
`;
proposals += ins.length;
}
}
return { badges, proposals, endedSeasons: ended.map((s) => s.id) };
}
/**
* Seasons whose stored stats no longer match the ledger, e.g. after an admin
* override deleted a market's scores so the winner can be re-scored. Compares
* ranked-call counts per season in the ledger with the sum of calls in stats.
*/
async function staleSeasons() {
const rows = await sql`
select coalesce(l.season_id, t.season_id) as season_id, coalesce(l.n, 0) as ledger, coalesce(t.n, 0) as stored
from (select season_id, count(*)::int as n from event_market_scores where ranked group by season_id) l
full join (select season_id, sum(calls)::int as n from event_market_stats where scope_kind = 'season' and source_kind = 'all' group by season_id) t
on t.season_id = l.season_id
`;
return rows.filter((r) => r.ledger !== r.stored).map((r) => r.season_id);
}
/**
* Run the rollup. `full` recomputes every season and the all-time scope from the
* ledger even when nothing new settled (used after a scoring-config change).
*/
export async function runRollup({ now = Date.now(), full = false } = {}) {
const settled = await settleResolvedMarkets();
const seasons = new Set(settled.seasons);
for (const id of await staleSeasons()) seasons.add(id);
if (full) {
for (const r of await sql`select distinct season_id from event_market_scores`) seasons.add(r.season_id);
}
let statRows = 0;
if (seasons.size || full) {
const ledger = await sql`
select market_id, account_id, source_kind, season_id, correct, odds_at_pick, delta, ranked, settled_at
from event_market_scores where ranked
`;
const rows = [
...statsForScope(ledger, { scope_kind: 'all', season_id: '' }),
...[...seasons].flatMap((id) => statsForScope(ledger, { scope_kind: 'season', season_id: id })),
];
await clearStaleStats(ledger, seasons);
await writeStats(rows);
statRows = rows.length;
}
const accounts = full
? new Set((await sql`select distinct account_id from event_market_scores where ranked`).map((r) => r.account_id))
: settled.accounts;
const fresh = accounts.size ? await awardPickBadges(accounts) : [];
const fin = await finalizeEndedSeasons(now);
return { scored: settled.inserted, statRows, badgesAwarded: fresh.length + fin.badges, payoutProposals: fin.proposals, endedSeasons: fin.endedSeasons };
}
/** Remove stats rows for accounts that no longer have any ranked call in a recomputed scope. */
async function clearStaleStats(ledger, seasons) {
const keep = (seasonId) => new Set(ledger.filter((r) => seasonId === '' || r.season_id === seasonId).map((r) => r.account_id));
for (const [scope, seasonId] of [['all', ''], ...[...seasons].map((id) => ['season', id])]) {
const accounts = [...keep(seasonId)];
await sql`
delete from event_market_stats
where scope_kind = ${scope} and season_id = ${seasonId} and not (account_id = any(${accounts}::uuid[]))
`;
}
}