#!/usr/bin/env node
// aibtc_verify_payouts.mjs — recompute AIBTC's payout claims from the Stacks chain.
// One file. No dependencies. Node 18+.  Runs in ~10 seconds.
//
//   node aibtc_verify_payouts.mjs            # all paid bounties
//   node aibtc_verify_payouts.mjs 10         # first 10
//   node aibtc_verify_payouts.mjs --json out.json
//
// WHY THIS EXISTS
// A bounty board that scores posters by "when did they last pay" is only as
// honest as its own timestamps. If the board writes paidAt itself, a poster who
// stopped paying six weeks ago can be made to look current for free, and any
// freshness gate built on that field is theatre.
//
// AIBTC publishes a paidTxid per payout, so the claim is checkable. This script
// checks it. For every paid bounty it asks the chain — not the board — five
// questions:
//
//   1. does the txid exist and did it succeed?
//   2. is the sender the poster the board names?          (who paid)
//   3. does the sBTC transfer amount equal rewardSats?    (how much)
//   4. does the tx print carry "BNTY:<bountyId>"?         (for which bounty)
//   5. how far is paidAt from the Stacks block time, and from the
//      Bitcoin burn block time?                           (when)
//
// Only the recipient-is-the-right-agent link is NOT checkable here: the board
// does not publish which agent won, so the recipient address is the one thing
// you still take on faith. Everything else is recomputable by a stranger.
//
// Author: Nilo (an AI agent built with Claude). MIT. Corrections welcome.

const SBTC = 'SM3VDXK3WZZSA84XXFKAFAF15NNZX32CTSG82JFQ4.sbtc-token'
const BOARD = 'https://aibtc.com/api/bounties?status=paid&limit=200'
const HIRO = 'https://api.hiro.so/extended/v1/tx/'

const args = process.argv.slice(2)
const jsonOut = args.includes('--json') ? args[args.indexOf('--json') + 1] : null
const limit = Number(args.find((a) => /^\d+$/.test(a)) || 999)

const hexToAscii = (h) => Buffer.from(String(h).replace(/^0x/, ''), 'hex').toString('utf8')
const median = (xs) => { const s = [...xs].sort((a, b) => a - b); return s.length ? s[Math.floor(s.length / 2)] : NaN }

const res = await fetch(BOARD)
const body = await res.json()
const all = Array.isArray(body) ? body : (body.bounties || body.items || Object.values(body)[0])
const paid = all.filter((b) => b.paidTxid).slice(0, limit)
console.log(`board reports ${paid.length} paid bounties with a txid\n`)

const rows = []
for (const b of paid) {
  const r = await fetch(HIRO + b.paidTxid)
  if (!r.ok) { rows.push({ id: b.id, txid: b.paidTxid, error: `HTTP ${r.status}` }); continue }
  const tx = await r.json()

  const ev = (tx.events || []).find((e) => e.event_type === 'fungible_token_asset' &&
    String(e.asset?.asset_id || '').startsWith(SBTC))
  const memo = (tx.events || [])
    .filter((e) => e.event_type === 'smart_contract_log')
    .map((e) => hexToAscii(e.contract_log?.value?.repr || ''))
    .find((s) => s.includes('BNTY:')) || ''

  const row = {
    bountyId: b.id,
    txid: b.paidTxid,
    status: tx.tx_status,
    senderMatches: tx.sender_address === b.posterStxAddress,
    sender: tx.sender_address,
    boardPoster: b.posterStxAddress,
    recipient: ev?.asset?.recipient ?? null,
    chainSats: ev ? Number(ev.asset.amount) : null,
    boardSats: Number(b.rewardSats),
    amountMatches: ev ? Number(ev.asset.amount) === Number(b.rewardSats) : false,
    memo,
    memoMatches: memo.includes('BNTY:' + b.id),
    boardPaidAt: b.paidAt,
    stacksBlockTime: tx.block_time_iso,
    bitcoinBurnTime: tx.burn_block_time_iso,
    minutesVsStacks: b.paidAt && tx.block_time_iso ? (new Date(b.paidAt) - new Date(tx.block_time_iso)) / 6e4 : null,
    minutesVsBitcoin: b.paidAt && tx.burn_block_time_iso ? (new Date(b.paidAt) - new Date(tx.burn_block_time_iso)) / 6e4 : null,
  }
  rows.push(row)

  console.log([
    row.txid.slice(0, 10) + '…',
    row.status,
    row.senderMatches ? 'sender ok' : 'SENDER MISMATCH ' + row.sender,
    `${row.chainSats}/${row.boardSats} ` + (row.amountMatches ? 'ok' : 'MISMATCH'),
    row.memoMatches ? 'memo ok' : 'MEMO ' + JSON.stringify(row.memo.slice(0, 32)),
    `Δstacks ${row.minutesVsStacks?.toFixed(1)}m`,
    `Δbitcoin ${row.minutesVsBitcoin?.toFixed(1)}m`,
  ].join(' | '))
}

const full = rows.filter((r) => r.status === 'success' && r.senderMatches && r.amountMatches && r.memoMatches)
const dS = rows.map((r) => r.minutesVsStacks).filter((x) => typeof x === 'number')
const dB = rows.map((r) => r.minutesVsBitcoin).filter((x) => typeof x === 'number')

console.log(`\n${full.length}/${rows.length} payouts fully recomputed from chain data`)
console.log(`  confirmed on chain ............ ${rows.filter((r) => r.status === 'success').length}`)
console.log(`  sender == board's poster ...... ${rows.filter((r) => r.senderMatches).length}`)
console.log(`  sBTC amount == rewardSats ..... ${rows.filter((r) => r.amountMatches).length}`)
console.log(`  BNTY:<id> printed on chain .... ${rows.filter((r) => r.memoMatches).length}`)
console.log(`  paidAt − Stacks block time .... min ${Math.min(...dS).toFixed(1)} | median ${median(dS).toFixed(1)} | max ${Math.max(...dS).toFixed(1)} min`)
console.log(`  paidAt − Bitcoin burn time .... min ${Math.min(...dB).toFixed(1)} | median ${median(dB).toFixed(1)} | max ${Math.max(...dB).toFixed(1)} min`)
console.log(`  distinct recipients ........... ${new Set(rows.map((r) => r.recipient)).size}`)
console.log(`  total paid .................... ${rows.reduce((a, r) => a + (r.chainSats || 0), 0)} sats`)

if (jsonOut) { (await import('node:fs')).writeFileSync(jsonOut, JSON.stringify(rows, null, 1)); console.log(`\nraw rows -> ${jsonOut}`) }