Raffle

weighted claimed USD = Σ(claimed USD from campaign × campaign multiplier)

weekly entries = floor(weighted claimed USD × tier multiplier)

GET https://api-tbi.boost.xyz/raffles/{raffleId}/snapshot

{
  "version": 2,
  "raffleId": 3,
  "numberOfWinners": 3,
  "rows": [
    {
      "canonicalIndex": 0,
      "walletAddress": "0x1111111111111111111111111111111111111111",
      "ticketCount": "50"
    },
    {
      "canonicalIndex": 1,
      "walletAddress": "0x2222222222222222222222222222222222222222",
      "ticketCount": "75"
    }
  ],
  "totalTickets": "125"
}

drawHash[i] = keccak256(
  abi.encodePacked(randomNumber, uint256(i))
)

target[i] = uint256(drawHash[i]) mod remainingEntries

npm install viem tsx

npx tsx verify-raffle.mts \
  https://api-tbi.boost.xyz/raffles/2/snapshot \
  0xbd4452ca27e71c9bd00fac9da50460d617d5d3ff \
  https://mainnet.base.org

import {
  createPublicClient,
  encodePacked,
  http,
  keccak256,
  toBytes,
  type Address,
  type Hex,
} from "viem";
import { base } from "viem/chains";

type SnapshotRow = {
  canonicalIndex: number;
  walletAddress: Address;
  ticketCount: string;
};

type Snapshot = {
  version: 2;
  raffleId: number;
  numberOfWinners: number;
  rows: SnapshotRow[];
  totalTickets: string;
};

const [snapshotUrl, managerAddress, rpcUrl] = process.argv.slice(2);
if (!snapshotUrl || !managerAddress || !rpcUrl) {
  throw new Error("Usage: tsx verify-raffle.mts <snapshot-url> <manager-address> <rpc-url>");
}

const response = await fetch(snapshotUrl);
if (!response.ok) throw new Error(`Snapshot request failed: ${response.status}`);
const input = (await response.json()) as Snapshot;

const rows = input.rows.map((row, index) => {
  const walletAddress = row.walletAddress.toLowerCase() as Address;
  if (row.canonicalIndex !== index) throw new Error("Invalid canonicalIndex order");
  if (row.walletAddress !== walletAddress) throw new Error("Wallet is not lowercase");
  if (index > 0 && input.rows[index - 1]!.walletAddress >= walletAddress) {
    throw new Error("Wallets are not in lexicographic order");
  }
  if (BigInt(row.ticketCount) <= 0n) throw new Error("Invalid ticketCount");
  return { canonicalIndex: index, walletAddress, ticketCount: row.ticketCount };
});

const totalTickets = rows.reduce((sum, row) => sum + BigInt(row.ticketCount), 0n);
if (totalTickets !== BigInt(input.totalTickets)) throw new Error("totalTickets mismatch");
if (input.numberOfWinners < 1 || input.numberOfWinners > rows.length) {
  throw new Error("Invalid numberOfWinners");
}

const snapshot: Snapshot = {
  version: input.version,
  raffleId: input.raffleId,
  numberOfWinners: input.numberOfWinners,
  rows,
  totalTickets: input.totalTickets,
};
const computedHash = keccak256(toBytes(JSON.stringify(snapshot)));

const client = createPublicClient({ chain: base, transport: http(rpcUrl) });
const raffle = await client.readContract({
  address: managerAddress as Address,
  abi: [{
    type: "function",
    name: "getRaffle",
    stateMutability: "view",
    inputs: [{ name: "raffleId", type: "uint256" }],
    outputs: [{
      name: "",
      type: "tuple",
      components: [
        { name: "snapshotHash", type: "bytes32" },
        { name: "randomNumber", type: "bytes32" },
        { name: "sequenceNumber", type: "uint64" },
        { name: "requestedAt", type: "uint64" },
        { name: "status", type: "uint8" },
      ],
    }],
  }] as const,
  functionName: "getRaffle",
  args: [BigInt(snapshot.raffleId)],
});

if (computedHash.toLowerCase() !== raffle.snapshotHash.toLowerCase()) {
  throw new Error(`Snapshot hash mismatch: ${computedHash} != ${raffle.snapshotHash}`);
}
if (raffle.randomNumber === `0x${"00".repeat(32)}`) {
  throw new Error("Randomness has not been fulfilled");
}

let pool = rows.map((row) => ({ ...row, entries: BigInt(row.ticketCount) }));
const winners: Array<{ prizeRank: number; walletAddress: Address }> = [];

for (let i = 0; i < snapshot.numberOfWinners; i += 1) {
  const remainingEntries = pool.reduce((sum, row) => sum + row.entries, 0n);
  const drawHash = keccak256(
    encodePacked(["bytes32", "uint256"], [raffle.randomNumber as Hex, BigInt(i)]),
  );
  const target = BigInt(drawHash) % remainingEntries;
  let cumulative = 0n;
  const winnerIndex = pool.findIndex((row) => {
    cumulative += row.entries;
    return target < cumulative;
  });
  if (winnerIndex === -1) throw new Error("No winner found");
  const [winner] = pool.splice(winnerIndex, 1);
  winners.push({ prizeRank: i + 1, walletAddress: winner!.walletAddress });
}

console.log({ raffleId: snapshot.raffleId, snapshotHash: computedHash, winners });