const bytes = crypto.randomBytes(len);

let s = '';

for (const b of bytes) s += B62[b % 62];

return s;

try {

return fs.readFileSync(file);

} catch {

const s = crypto.randomBytes(32);

fs.writeFileSync(file, s, { mode: 0o600 });

return s;

}

if (typeof s !== 'string' || !s || s.length > 512) return false;

if (s.startsWith('did:')) return /^did:[a-z0-9]+:[\w.:%-]+$/i.test(s);

try {

const u = new URL(s);

return u.protocol === 'http:' || u.protocol === 'https:';

} catch { return false; }

const prefix = api.prefix ?? '/markets'; // '' = site root (standalone host)

const cfg = api.config || {};

// ------------------------------------------------------------ config

const num = (v, d) => (v === undefined ? d : v);

const grantMicro = Math.round(num(cfg.grantCredits, 1000) * MICRO);

const accountsUi = !!cfg.accountsUi; // standalone hosts: register/login form instead of pod-bearer paste

const feeBps = num(cfg.feeBps, 100);

const houseFeeShareBps = num(cfg.houseFeeShareBps, 5000);

const disputeWindowMs = num(cfg.disputeWindowMs, 60 * 60 * 1000);

const disputeBondMicro = Math.round(num(cfg.disputeBondCredits, 25) * MICRO);

const disputeBondBps = num(cfg.disputeBondBps, 2000); // 20% of the disputed position

const disputeGraceMs = num(cfg.disputeGraceMs, 7 * 24 * 3600 * 1000);

const settlementWindowMs = num(cfg.settlementWindowMs, 7 * 24 * 3600 * 1000);

const twapWindowMs = num(cfg.twapWindowMs, 30 * 60 * 1000);

const sessionTtlMs = num(cfg.sessionTtlMs, 12 * 3600 * 1000);

const rateCapacity = num(cfg.rateCapacity, 120);

const rateRefillPerSec = num(cfg.rateRefillPerSec, 2);

const allowInsiderTrading = cfg.allowInsiderTrading === true;

const admins = new Set(Array.isArray(cfg.admins) ? cfg.admins : []);

if (!Number.isInteger(feeBps) || feeBps < 0 || feeBps > 1000) {

throw new Error('markets: config.feeBps must be an integer 0..1000 (basis points)');

}

if (!Number.isInteger(houseFeeShareBps) || houseFeeShareBps < 0 || houseFeeShareBps > 10_000) {

throw new Error('markets: config.houseFeeShareBps must be an integer 0..10000');

}

if (!Number.isFinite(grantMicro) || grantMicro < 0) {

throw new Error('markets: config.grantCredits must be a non-negative number');

}

for (const a of admins) {

if (!isAgentId(a)) throw new Error(`markets: config.admins contains a non-agent id: ${a}`);

}

// These windows are load-bearing, not cosmetic: twapWindowMs = 0 makes

// voidPrices() degenerate to the SPOT price, which resurrects the

// buy-then-void arbitrage the TWAP exists to prevent. Refuse to boot on

// a value that would silently disable a defence.

for (const [name, v] of Object.entries({

disputeWindowMs, disputeGraceMs, settlementWindowMs, twapWindowMs, sessionTtlMs,

snapshotIntervalMs: num(cfg.snapshotIntervalMs, 30_000),

})) {

if (!Number.isFinite(v) || v <= 0) {

throw new Error(`markets: config.${name} must be a positive number of milliseconds (got ${v})`);

}

}

// "> 0" is not the property that matters: a 1ms window gives the last

// price full weight, i.e. the TWAP IS spot — the very arbitrage the

// window exists to prevent.

if (twapWindowMs < 60_000) {

throw new Error('markets: config.twapWindowMs must be at least 60000ms — a shorter window is spot pricing in disguise');

}

// Get these two the wrong way round and a resolution is still inside

// its dispute window when the abandoned-market backstop opens — which

// made every resolution voidable by every loser.

if (disputeWindowMs >= settlementWindowMs) {

throw new Error(

`markets: config.disputeWindowMs (${disputeWindowMs}) must be shorter than `

+ `settlementWindowMs (${settlementWindowMs})`,

);

}

if (!Number.isFinite(disputeBondBps) || disputeBondBps < 0 || disputeBondBps > 10_000) {

throw new Error('markets: config.disputeBondBps must be 0..10000');

}

if (!Number.isFinite(rateCapacity) || rateCapacity <= 0

|| !Number.isFinite(rateRefillPerSec) || rateRefillPerSec <= 0) {

throw new Error('markets: config.rateCapacity and config.rateRefillPerSec must be positive');

}

if (twapWindowMs > TWAP_PROTECT_MS) {

throw new Error(

`markets: config.twapWindowMs (${twapWindowMs}) must not exceed ${TWAP_PROTECT_MS}ms — beyond that, `

+ 'price-history thinning reaches inside the redemption window and makes the void price steerable by trade timing',

);

}

if (!Number.isFinite(disputeBondMicro) || disputeBondMicro < 0) {

throw new Error('markets: config.disputeBondCredits must be a non-negative number');

}

if (/["'<>]/.test(prefix)) throw new Error(`markets: refusing an unsafe prefix: ${prefix}`);

// -------------------------------------------------- store & security

const dir = api.storage.pluginDir();

const store = createStore({ dir, log: api.log, prices: lmsrPrices });

const { state } = store;

const sessions = createSessions({ dir, ttlMs: sessionTtlMs });

const pseudonymSalt = readOrCreateSecret(path.join(dir, 'pseudonym.salt'));

const limiter = createRateLimiter({ capacity: rateCapacity, refillPerSec: rateRefillPerSec });

/** agent → Set(marketId) — so /api/me is O(your markets), not O(all). */

const byAgent = new Map();

const indexPosition = (agent, id) => {

let s = byAgent.get(agent);

if (!s) byAgent.set(agent, (s = new Set()));

s.add(id);

};

for (const m of Object.values(state.markets)) {

for (const agent of Object.keys(m.positions)) indexPosition(agent, m.id);

}

const ownOrigin = () => {

try {

if (typeof api.serverInfo === 'function') {

const info = api.serverInfo();

if (info && info.baseUrl) return info.baseUrl;

}

} catch { /* not listening yet */ }

return cfg.baseUrl || null;

};

// ------------------------------------------------------------- auth

const cookieName = 'markets_session';

function cookieToken(request) {

const raw = request.headers.cookie;

if (!raw) return null;

for (const part of raw.split(';')) {

const [k, ...v] = part.trim().split('=');

if (k === cookieName) return decodeURIComponent(v.join('='));

}

return null;

}

/**

/** Resolve a session token to an agent id. A session is live only

function liveSession(token) {

const claims = sessions.verify(token);

if (!claims) return null;

const row = state.ledger[claims.agent];

if ((row ? row.epoch || 0 : 0) !== claims.epoch) return null;

return claims.agent;

}

/**

async function resolveAgentFull(request) {

const cookie = cookieToken(request);

if (cookie) {

const agent = liveSession(cookie);

if (agent) return { agent, ambient: true };

}

const auth = request.headers.authorization;

if (auth && auth.startsWith('Bearer v1.')) {

const agent = liveSession(auth.slice(7));

if (agent) return { agent, ambient: false };

}

const agent = await api.auth.getAgent(request);

// getAgent may have authenticated from an ambient TLS client

// certificate; only an explicit Authorization header proves the

// caller actually held a secret.

return { agent, ambient: agent ? !auth : false };

}

async function resolveAgent(request) {

return (await resolveAgentFull(request)).agent;

}

// ------------------------------------------------------------ replies

const err = (reply, code, error, extra) => reply.code(code).send({ error, ...extra });

/** Guard for every mutating route: same-origin required whenever the

/** The origin to compare against, preferring configured/serverInfo and

function originFor(request) {

const known = ownOrigin();

if (known) return known;

const host = request.headers.host;

if (!host) return null;

// Fastify reports the SOCKET's protocol unless trustProxy is on,

// which a plugin cannot set; behind nginx/Caddy that is 'http' while

// the browser's Origin says https, and every mutation would 403.

const proto = request.headers['x-forwarded-proto'] || request.protocol || 'https';

return `${String(proto).split(',')[0].trim()}://${host}`;

}

function csrfOk(request) {

// A session cookie makes the request ambient REGARDLESS of any

// Authorization header: resolveAgent checks the cookie first, so an

// attacker could otherwise bolt on a junk bearer to look

// "explicitly credentialed", skip this check, and still be

// authenticated by the victim's cookie.

if (!cookieToken(request) && !isAmbientCredential(request)) return true;

return isSameOrigin(request, originFor(request));

}

async function authed(request, reply, { mutating = true } = {}) {

// Resolve first so an anonymous caller gets a 401 rather than a

// confusing 403; nothing is acted on before the CSRF check below.

const { agent, ambient } = await resolveAgentFull(request);

if (!agent) { err(reply, 401, 'authentication required'); return null; }

if (mutating && ambient && !isSameOrigin(request, originFor(request))) {

err(reply, 403, 'cross-origin request refused — this endpoint is same-origin only');

return null;

}

if (state.ledger[agent] && state.ledger[agent].frozen) {

err(reply, 403, 'this account is frozen; contact the operator');

return null;

}

return agent;

}

/** Grant the signup credits the first time we ever see an agent. */

function ensureAccount(agent) {

const row = state.ledger[agent];

if (row && row.created) return row;

store.commit({ type: 'grant', agent, amountMicro: grantMicro });

api.log.info(`markets: granted ${grantMicro / MICRO} credits to ${agent}`);

return state.ledger[agent];

}

const balanceOf = (agent) => (state.ledger[agent] ? state.ledger[agent].balanceMicro : 0);

// ------------------------------------------------- rate limit + CORS

//

// FINDING: hooks added via api.fastify are NOT scoped to the plugin's

// own routes — they run for EVERY request the server handles, including

// other plugins' and core's. An unguarded rate-limit hook here 429'd

// the metrics and dashboard plugins in the compose suite. Every hook

// below therefore gates on `mine(request)` first. (metrics/ hit the

// same edge from the other side and documented it as "scope: all

// plugins, never core".)

const mine = (request) => {

const u = request.url;

return u === prefix || u.startsWith(`${prefix}/`) || u.startsWith(`${prefix}?`);

};

api.fastify.addHook('onRequest', async (request, reply) => {

if (!mine(request)) return undefined;

const key = liveSession(cookieToken(request) || '') || request.ip;

const cost = request.method === 'GET' || request.method === 'HEAD' ? 1 : 4;

const waitMs = limiter.take(key, cost);

if (waitMs) {

return reply.code(429)

.header('retry-after', Math.ceil(waitMs / 1000))

.send({ error: 'rate limit exceeded — slow down' });

}

return undefined;

});

// The host reflects arbitrary Origins with Allow-Credentials on its LDP

// routes; those defaults must not apply to money endpoints. Pin ACAO to

// our own origin and drop credential sharing entirely.

api.fastify.addHook('onSend', async (request, reply, payload) => {

if (!mine(request)) return payload;

const origin = ownOrigin();

reply.header('access-control-allow-origin', origin || 'null');

reply.removeHeader('access-control-allow-credentials');

if (request.url.startsWith(`${prefix}/api`)) {

for (const [k, v] of Object.entries(API_HEADERS)) reply.header(k, v);

}

return payload;

});

// ------------------------------------------------------- projections

const tradable = (m) => m.status === 'open' && Date.now() < m.closesAt;

const displayStatus = (m) => (m.status === 'open' && !tradable(m) ? 'closed' : m.status);

function positionOut(m, pos) {

const prices = lmsrPrices(m.q, m.bMicro);

const shares = pos.shares.map((s) => s / MICRO);

const cost = pos.costMicro.map((c) => c / MICRO);

// Value a live position at what the AMM would actually pay to close

// it (proceeds net of fee), not at mark — "cash out" must not quote a

// number the sell path won't honour.

const value = pos.shares.map((s, i) => (s > 0 ? sellQuote(m, i, s).totalMicro / MICRO : 0));

const totalValue = value.reduce((a, x) => a + x, 0);

const totalCost = cost.reduce((a, x) => a + x, 0);

return {

shares,

cost,

prices: prices.map((p) => Number(p.toFixed(6))),

value,

totalCost: Number(totalCost.toFixed(6)),

totalValue: Number(totalValue.toFixed(6)),

unrealizedPnl: Number((totalValue - totalCost).toFixed(6)),

};

}

function marketOut(m, { agent = null, history = false } = {}) {

const prices = lmsrPrices(m.q, m.bMicro);

const out = {

id: m.id,

title: m.title,

description: m.description,

category: m.category || null,

outcomes: m.outcomes,

prices: prices.map((p) => Number(p.toFixed(6))),

status: displayStatus(m),

// The RAW lifecycle state, distinct from the display status: a

// market past closesAt displays as 'closed' while its raw status is

// still 'open', and that is exactly when the oracle must resolve.

// Without this a client can't tell "closed, awaiting resolution"

// from "settled", and hides the resolve controls at the only moment

// they matter.

rawStatus: m.status,

tradable: tradable(m),

canResolve: m.status === 'open',

canVoid: m.status === 'open' && !tradable(m),

closesAt: new Date(m.closesAt).toISOString(),

createdAt: m.createdAt,

creator: m.creator,

oracle: m.oracle,

b: m.bMicro / MICRO,

volume: m.volumeMicro / MICRO,

fees: m.feesMicro / MICRO,

trades: m.trades,

liquidity: (m.subsidyMicro + m.collectedMicro) / MICRO,

resolvedOutcome: m.resolvedOutcome ?? null,

settleAt: m.settleAt ? new Date(m.settleAt).toISOString() : null,

resolvedAt: m.resolvedAt ?? null,

settledPrices: m.settledPrices ?? null,

disputes: (m.disputes || []).length,

hidden: !!m.hidden,

};

if (agent && m.positions[agent]) out.position = positionOut(m, m.positions[agent]);

if (history) out.history = m.history.map((h) => ({ t: h.t, p: h.p.map((x) => Number(x.toFixed(6))) }));

return out;

}

// ------------------------------------------------------------ pricing

function buyQuote(m, i, sharesMicro) {

const costMicro = Math.ceil(tradeCostRaw(m.q, m.bMicro, i, sharesMicro));

const feeMicro = Math.ceil((costMicro * feeBps) / 10_000);

return { sharesMicro, costMicro, feeMicro, totalMicro: costMicro + feeMicro };

}

function sellQuote(m, i, sharesMicro) {

const proceedsMicro = Math.floor(-tradeCostRaw(m.q, m.bMicro, i, -sharesMicro));

const feeMicro = Math.ceil((proceedsMicro * feeBps) / 10_000);

return { sharesMicro, proceedsMicro, feeMicro, totalMicro: proceedsMicro - feeMicro };

}

/** Validate a trade request into micro units. Returns { error } or the

function priceTrade(m, side, outcomeRaw, sharesRaw, spendRaw) {

const outcome = Number(outcomeRaw);

if (!Number.isInteger(outcome) || outcome < 0 || outcome >= m.outcomes.length) {

return { error: 'outcome must be a valid outcome index' };

}

if (side !== 'buy' && side !== 'sell') return { error: "side must be 'buy' or 'sell'" };

let sharesMicro;

if (spendRaw !== undefined && spendRaw !== null && spendRaw !== '') {

if (side !== 'buy') return { error: 'spend is only meaningful for a buy' };

const spend = Number(spendRaw);

if (!Number.isFinite(spend) || spend <= 0) return { error: 'spend must be a positive number of credits' };

const budget = Math.floor(spend * MICRO);

sharesMicro = sharesForBudget(m.q, m.bMicro, outcome, budget,

(x) => buyQuote(m, outcome, x).totalMicro, LIMITS.maxTradeShares * MICRO);

if (sharesMicro <= 0) return { error: 'that stake is too small to buy any shares' };

} else {

const shares = Number(sharesRaw);

if (!Number.isFinite(shares) || shares <= 0 || shares > LIMITS.maxTradeShares) {

return { error: `shares must be > 0 and ≤ ${LIMITS.maxTradeShares}` };

}

sharesMicro = Math.round(shares * MICRO);

if (sharesMicro <= 0) return { error: 'shares too small (min 0.000001)' };

}

const t = side === 'buy' ? buyQuote(m, outcome, sharesMicro) : sellQuote(m, outcome, sharesMicro);

return { ...t, outcome, side };

}

/** The consumer-facing framing: stake in, payout out, decimal odds. */

function quoteOut(m, t) {

const shares = t.sharesMicro / MICRO;

const stake = t.totalMicro / MICRO;

const base = {

side: t.side,

outcome: t.outcome,

outcomeLabel: m.outcomes[t.outcome],

shares: Number(shares.toFixed(6)),

fee: Number((t.feeMicro / MICRO).toFixed(6)),

total: Number(stake.toFixed(6)),

};

if (t.side === 'buy') {

base.cost = Number((t.costMicro / MICRO).toFixed(6));

base.toWin = Number(shares.toFixed(6)); // a winning share pays 1 credit

base.profit = Number((shares - stake).toFixed(6));

base.avgPrice = shares > 0 ? Number((stake / shares).toFixed(6)) : null;

base.odds = stake > 0 ? Number((shares / stake).toFixed(3)) : null; // decimal odds

} else {

base.proceeds = Number((t.proceedsMicro / MICRO).toFixed(6));

base.avgPrice = shares > 0 ? Number((stake / shares).toFixed(6)) : null;

}

return base;

}

// ----------------------------------------------------------- lifecycle

// The settlement state machine lives in lifecycle.js — see that file

// for why it is not inline here (a state change that skipped the

// reducer made the audit trail contradict the money).

const {

voidPrices, settleResolved, settleVoid, tick, tickOne, maybeTick, disputeDeadline,

} = createLifecycle({

state,

commit: store.commit,

broadcast: (type, m) => broadcast(type, m),

log: api.log,

cfg: { twapWindowMs, houseFeeShareBps, settlementWindowMs, disputeGraceMs, HOUSE },

});

// --------------------------------------------------------- websocket

const sockets = new Set();

const perIp = new Map();

await api.ws.route(`${prefix}/ws`, (socket, request) => {

// Reject cross-origin upgrades: public data today, but an unchecked

// origin makes any future per-agent field on the wire a leak.

const wsOrigin = request.headers && request.headers.origin;

if (wsOrigin && !isSameOrigin({ headers: { origin: wsOrigin } }, originFor(request))) {

try { socket.close(1008, 'cross-origin'); } catch { /* gone */ }

return;

}

const ip = request.socket ? request.socket.remoteAddress : 'unknown';

const n = perIp.get(ip) || 0;

if (sockets.size >= LIMITS.maxSockets || n >= LIMITS.maxSocketsPerIp) {

try { socket.close(1013, 'too many connections'); } catch { /* gone */ }

return;

}

// A live price feed is public (prices are public), but an unbounded,

// never-reaped socket set is a memory DoS — hence the caps, the idle

// reaper below, and the backpressure check in broadcast().

perIp.set(ip, n + 1);

socket.isAlive = true;

socket.on('pong', () => { socket.isAlive = true; });

const drop = () => {

sockets.delete(socket);

const c = (perIp.get(ip) || 1) - 1;

if (c <= 0) perIp.delete(ip); else perIp.set(ip, c);

};

socket.on('close', drop);

socket.on('error', drop);

sockets.add(socket);

});

const reaper = setInterval(() => {

for (const s of sockets) {

if (!s.isAlive) { try { s.terminate ? s.terminate() : s.close(); } catch { /* gone */ } continue; }

s.isAlive = false;

try { s.ping ? s.ping() : null; } catch { /* gone */ }

}

}, 30_000);

reaper.unref?.();

const ticker = setInterval(tick, 15_000);

ticker.unref?.();

function broadcast(type, m) {

// A withdrawn market must not push its title and description to

// every connected client when it settles.

if (m.hidden) return;

const msg = JSON.stringify({ type, market: marketOut(m) });

for (const s of sockets) {

// Drop a client that isn't draining rather than buffering without

// bound on its behalf.

if (s.bufferedAmount > LIMITS.wsBufferBytes) { try { s.close(1013, 'too slow'); } catch { /* gone */ } continue; }

try { s.send(msg); } catch { /* dead socket; close event reaps it */ }

}

}

// ------------------------------------------------------- idempotency

// A retried trade (double-click, network timeout) must not execute

// twice. Keyed by agent + Idempotency-Key; the original response is

// replayed verbatim.

const idem = new Map();

const fingerprint = (request) => crypto.createHash('sha256')

.update(`${request.method} ${request.url} ${JSON.stringify(request.body || {})}`)

.digest('hex');

/** @returns {{code,body}|'conflict'|null} */

function idemGet(agent, key, fp) {

if (!key) return null;

const hit = idem.get(`${agent}${key}`);

if (!hit) return null;

if (Date.now() - hit.at > LIMITS.idempotencyTtlMs) { idem.delete(`${agent}${key}`); return null; }

// A key reused for a DIFFERENT request is an error, never a replay:

// otherwise a client deriving keys per session or per market silently

// loses trades and is told they succeeded.

if (hit.fp !== fp) return 'conflict';

return hit;

}

function idemPut(agent, key, code, body, fp) {

if (!key) return;

if (idem.size >= LIMITS.maxIdempotencyKeys) {

for (const k of idem.keys()) { idem.delete(k); if (idem.size < LIMITS.maxIdempotencyKeys * 0.9) break; }

}

idem.set(`${agent}${key}`, { at: Date.now(), code, body, fp });

}

const idemKey = (request) => {

const k = request.headers['idempotency-key'];

return typeof k === 'string' && k.length <= 128 ? k : null;

};

// ============================================================ routes

const jsonOpts = (bodyLimit) => ({ bodyLimit });

// ---- session: exchange a pod bearer for a scoped, expiring token ----

// The browser never stores the pod bearer (see guard.js): it posts it

// once and gets an HttpOnly cookie scoped to this plugin.

api.fastify.post(`${prefix}/api/session`, jsonOpts(2048), async (request, reply) => {

if (!csrfOk(request)) return err(reply, 403, 'cross-origin request refused');

const agent = await api.auth.getAgent(request);

if (!agent) return err(reply, 401, 'a pod bearer token is required to start a session');

ensureAccount(agent);

const token = sessions.mint(agent, state.ledger[agent].epoch || 0);

const secure = (ownOrigin() || '').startsWith('https:') ? ' Secure;' : '';

reply.header('set-cookie',

`${cookieName}=${encodeURIComponent(token)}; Path=${prefix}; HttpOnly; SameSite=Strict;${secure} Max-Age=${Math.floor(sessionTtlMs / 1000)}`);

return reply.send({ agent, expiresIn: Math.floor(sessionTtlMs / 1000), balance: balanceOf(agent) / MICRO });

});

api.fastify.delete(`${prefix}/api/session`, async (request, reply) => {

if (!csrfOk(request)) return err(reply, 403, 'cross-origin request refused');

// Clearing the cookie is cosmetic on its own — the token is

// self-verifying, so a captured copy still worked for the full TTL.

// Bump the epoch so every token minted before now stops verifying.

const who = await resolveAgent(request);

if (who && state.ledger[who]) store.commit({ type: 'session.revoke', agent: who });

reply.header('set-cookie', `${cookieName}=; Path=${prefix}; HttpOnly; SameSite=Strict; Max-Age=0`);

return reply.send({ ok: true });

});

// ---- me: balance, positions (O(your markets)), settlement receipts ---

api.fastify.get(`${prefix}/api/me`, async (request, reply) => {