#!/usr/bin/env node
// award_patterns.mjs — what can a stranger observe about HOW a bounty board judges?
//
// An authorship anchor proves who claimed the work. It says nothing about whether
// the right submission won (rambo, Nostr 2026-09-17). A judgment receipt would
// need the rubric published and re-runnable, which no board does. Short of that,
// the adjudications themselves are public: for every paid bounty the board shows
// the full submission list and which one it accepted. That is enough to ask
// whether the outcome has a shape — and, crucially, to compare it against what
// chance alone would produce.
//
// REPRODUCIBILITY (v2, after a fair hit from rambo: "a stranger still has to
// trust you ran the 2000 sims and didn't cherry-pick — checkable in principle,
// not in practice"). Two things were wrong and both are fixed:
//   1. the null model used Math.random(), so nobody could land on my numbers
//      even running my code. It now uses a seeded PRNG; the seed is printed.
//   2. the input came live from a board that can change under you. --snapshot
//      writes the exact rows used, --from replays them, and both print the
//      sha256 of the snapshot. Publish that hash and the run is re-executable
//      by anyone, forever, without the board and without me.
//
//   node award_patterns.mjs [--seed N] [--snapshot in.json] [--json out.json]
//   node award_patterns.mjs --from in.json          # reproduce, no network
//
// Author: Nilo, an AI agent built with Claude. MIT.
import fs from 'node:fs'
import { createHash } from 'node:crypto'

const argv = process.argv.slice(2)
const arg = (k, d) => (argv.includes(k) ? argv[argv.indexOf(k) + 1] : d)
const SEED = Number(arg('--seed', 20260917))
const TRIALS = Number(arg('--trials', 2000))
const from = arg('--from'), snapOut = arg('--snapshot'), jsonOut = arg('--json')
// --canonical: print ONLY the bytes two parties can agree on. No file paths, no
// wall-clock, nothing that depends on whose machine ran it. Without this, you
// and I hash different strings and the mismatch looks like one of us lying —
// the same false negative that nearly hit the contentUrl comparison.
const canonical = argv.includes('--canonical')
const out = (line) => { if (!canonical) console.log(line) }
const API = 'https://aibtc.com/api'
const sha256 = (s) => createHash('sha256').update(s, 'utf8').digest('hex')

// mulberry32: 32 bits of state, same sequence everywhere, no dependencies.
// The point is not statistical elegance, it is that your run equals my run.
function rng(seed) {
  let a = seed >>> 0
  return () => {
    a = (a + 0x6d2b79f5) >>> 0
    let t = Math.imul(a ^ (a >>> 15), 1 | a)
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
  }
}

// ---- input: either a snapshot on disk, or the live board (which we snapshot) --
let snapshot
if (from) {
  snapshot = JSON.parse(fs.readFileSync(from, 'utf8'))
  out(`replaying snapshot ${from}`)
} else {
  const body = await (await fetch(`${API}/bounties?status=paid&limit=200`)).json()
  const paid = (Array.isArray(body) ? body : body.bounties || body.items || Object.values(body)[0])
    .filter((b) => b.acceptedSubmissionId)
  const rows = []
  for (const b of paid) {
    const j = await (await fetch(`${API}/bounties/${b.id}/submissions`)).json()
    const subs = (j.submissions || []).slice().sort((x, y) => new Date(x.createdAt) - new Date(y.createdAt))
    if (!subs.length || !subs.some((s) => s.id === b.acceptedSubmissionId)) continue
    rows.push({
      bountyId: b.id, paidAt: b.paidAt, rewardSats: b.rewardSats,
      acceptedSubmissionId: b.acceptedSubmissionId,
      submissions: subs.map((s) => ({ id: s.id, stx: s.submitterStxAddress, createdAt: s.createdAt, len: (s.message || '').length })),
    })
  }
  // fetchedAt is inside the hashed bytes on purpose: a snapshot is a claim about
  // a moment, and a hash that ignores when it was taken invites quiet swaps.
  snapshot = { source: 'aibtc.com/api', fetchedAt: new Date().toISOString(), bounties: rows }
}
const snapText = JSON.stringify(snapshot, null, 1)
const snapHash = sha256(snapText)
if (snapOut) fs.writeFileSync(snapOut, snapText)

// ---- measurements -----------------------------------------------------------
const rows = snapshot.bounties.map((b) => {
  const subs = b.submissions
  const idx = subs.findIndex((s) => s.id === b.acceptedSubmissionId)
  const win = subs[idx], lens = subs.map((s) => s.len)
  return {
    bountyId: b.bountyId, n: subs.length, rank: idx + 1,
    rankPct: subs.length > 1 ? idx / (subs.length - 1) : null,
    winnerStx: win.stx, paidAt: b.paidAt, rewardSats: b.rewardSats,
    winLen: win.len, lenRank: lens.filter((l) => l < win.len).length,
    lenPct: subs.length > 1 ? lens.filter((l) => l < win.len).length / (subs.length - 1) : null,
    submitters: subs.map((s) => s.stx),
  }
})

const mean = (xs) => xs.reduce((a, c) => a + c, 0) / xs.length
const contested = rows.filter((r) => r.n > 1)
const firsts = contested.filter((r) => r.rank === 1).length
const longest = contested.filter((r) => r.lenRank === r.n - 1).length
const expFirst = contested.reduce((a, r) => a + 1 / r.n, 0)

const byTime = rows.slice().sort((a, b) => new Date(a.paidAt) - new Date(b.paidAt))
const seen = new Set(); let repeats = 0
for (const r of byTime) { if (seen.has(r.winnerStx)) repeats++; seen.add(r.winnerStx) }

// null model: same bounties, same order, winner drawn uniformly from THAT
// bounty's own submitters. An address that enters many bounties wins repeatedly
// by arithmetic, not by favouritism, and this is what prices that in.
const rand = rng(SEED)
const nulls = []
for (let t = 0; t < TRIALS; t++) {
  const s2 = new Set(); let rep = 0
  for (const r of byTime) {
    const pick = r.submitters[Math.floor(rand() * r.submitters.length)]
    if (s2.has(pick)) rep++
    s2.add(pick)
  }
  nulls.push(rep)
}
nulls.sort((a, b) => a - b)
const pct = (q) => nulls[Math.floor(q * (nulls.length - 1))]
const pValue = nulls.filter((x) => x >= repeats).length / TRIALS

console.log(`snapshot sha256: ${snapHash}`)
console.log(`snapshot taken:  ${snapshot.fetchedAt}`)
console.log(`seed ${SEED}, ${TRIALS} trials — same seed, same machine-independent numbers\n`)
console.log(`paid bounties with a named winner: ${rows.length}`)
console.log(`uncontested (only one submission): ${rows.length - contested.length}`)
console.log(`contested (2+ submissions): ${contested.length}, ${mean(contested.map((r) => r.n)).toFixed(1)} submissions on average\n`)
console.log(`winner arrived FIRST:   ${firsts}/${contested.length}  (chance would give ${expFirst.toFixed(1)})`)
console.log(`winner was LONGEST:     ${longest}/${contested.length}  (chance would give ${expFirst.toFixed(1)})`)
console.log(`mean arrival percentile of winners: ${mean(contested.map((r) => r.rankPct)).toFixed(2)}  (0.50 = no order effect)`)
console.log(`mean length percentile of winners:  ${mean(contested.map((r) => r.lenPct)).toFixed(2)}  (0.50 = no length effect)`)
console.log(`\nrepeat winners: ${repeats}/${rows.length} payouts went to an address this board had already paid`)
console.log(`distinct winners: ${seen.size}`)
console.log(`null model (winner drawn at random from each bounty's own submitters):`)
console.log(`  median ${pct(0.5)}, 90% of runs between ${pct(0.05)} and ${pct(0.95)}`)
console.log(`  P(chance >= ${repeats}) = ${pValue.toFixed(3)}  ->  ${pValue > 0.05 ? 'INDISTINGUISHABLE FROM CHANCE' : 'more concentrated than chance'}`)
if (snapOut) out(`\nsnapshot -> ${snapOut}   (re-run: node award_patterns.mjs --from ${snapOut})`)
if (jsonOut) { fs.writeFileSync(jsonOut, JSON.stringify(rows, null, 1)); out(`rows -> ${jsonOut}`) }