How We Pick Winners 🎲 Fair, Transparent, Verifiable

const crypto = require("crypto");

// PASTE THESE FROM THE DRAW PAGE:
const serverSeed = "PASTE_SERVER_SEED_HERE";        // 64 hex chars (32 bytes)
const seedHash = "PASTE_SEED_HASH_HERE";            // 64 hex chars (SHA-256 of serverSeed)
const entryIds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];   // ascending entry IDs from frozen snapshot
const winnerCount = 3;                              // number of winners to show

// 1. Verify seed hash matches the commit hash shown BEFORE the draw
const computedHash = crypto.createHash("sha256").update(serverSeed).digest("hex");
if (computedHash !== seedHash) {
  throw new Error(`Seed hash mismatch! Expected: ${seedHash}, Got: ${computedHash}`);
}
console.log("✓ Seed hash verified");

// 2. Seeded PRNG using HMAC-SHA256 keystream (exact copy from seededShuffle.ts)
class SeededPRNG {
  /** @param {string} seed */
  constructor(seed) {
    this.seed = seed;
    this.counter = 0;
  }

  /** Generate next batch of random bytes (32 bytes from HMAC-SHA256) */
  _nextBytes() {
    const hmac = crypto.createHmac("sha256", this.seed);
    hmac.update(String(this.counter++));
    return hmac.digest();
  }

  /**
   * Get a random integer in [0, max) using rejection sampling (no modulo bias).
   * @param {number} max
   * @returns {number}
   */
  nextInt(max) {
    if (max <= 1) return 0;

    // Determine how many bytes we need (e.g., max=256 needs 2 bytes for 16-bit range)
    const bytesNeeded = Math.ceil(Math.log2(max) / 8) || 1;
    const maxRange = Math.pow(256, bytesNeeded);
    const limit = maxRange - (maxRange % max); // largest multiple of max in range

    let attempts = 0;
    while (attempts++ < 100) {
      // Safety: bail after 100 attempts (vanishingly rare for valid inputs)
      const bytes = this._nextBytes();
      let value = 0;
      for (let i = 0; i < bytesNeeded; i++) {
        value = value * 256 + bytes[i];
      }
      if (value < limit) {
        return value % max;
      }
    }
    // Fallback (should never hit): use last generated value
    return this._nextBytes()[0] % max;
  }
}

/**
 * Fisher-Yates shuffle using seeded PRNG.
 * @param {Array} items
 * @param {string} seed
 * @returns {Array}
 */
function seededShuffle(items, seed) {
  const arr = [...items];
  const prng = new SeededPRNG(seed);
  for (let i = arr.length - 1; i > 0; i--) {
    const j = prng.nextInt(i + 1);
    [arr[i], arr[j]] = [arr[j], arr[i]];
  }
  return arr;
}

// 3. Compute the shuffle
const shuffled = seededShuffle(entryIds, serverSeed);
console.log("\nShuffled order:", shuffled);
console.log(`Winner${winnerCount > 1 ? "s" : ""}:`, shuffled.slice(0, winnerCount));
if (winnerCount > 1) {
  console.log("Reroll order:", shuffled.slice(winnerCount));
}