Read onchain randomness

import { parseAbi } from 'viem'

const beacon = '0x00000000000000000000000000000000000000ff' as const
const beaconAbi = parseAbi([
  'function hasKey() view returns (bool)',
  'function groupKey() view returns (bytes)',
  'function keySet() view returns (bytes32)',
  'function latestSlot() view returns (uint64)',
  'function keyAt(uint64 slot) view returns (bytes)',
  'function randomness(uint64 slot) view returns (bytes32)',
  'error NoKey()',
  'error NotInRing()',
])
const block = await client.getBlock({ blockTag: 'finalized' })
const hasKey = await client.readContract({
  address: beacon, abi: beaconAbi, functionName: 'hasKey', blockNumber: block.number,
})
if (!hasKey) throw new Error('Beacon key unavailable')

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IBeacon {
    function hasKey() external view returns (bool);
    function randomness(uint64 slot) external view returns (bytes32);
}

contract FutureSelection {
    IBeacon constant BEACON = IBeacon(0x00000000000000000000000000000000000000ff);
    address public immutable owner = msg.sender;
    address[] public participants;
    bytes32 public commitment;
    uint64 public slot;
    uint64 public deadline;
    bool public committed;
    bool public resolved;
    bool public cancelled;
    address public winner;
    event Committed(bytes32 indexed commitment, uint64 slot, uint64 deadline);
    event Selected(bytes32 indexed commitment, address winner, uint256 index);
    event Cancelled(bytes32 indexed commitment);

    function commit(bytes32 decisionId, address[] calldata choices, uint64 futureSlot,
        uint64 deadline_) external {
        require(msg.sender == owner && !committed, "authority or duplicate");
        require(BEACON.hasKey(), "no key");
        require(futureSlot >= block.timestamp + 30, "slot too soon");
        require(deadline_ > futureSlot && deadline_ <= uint256(futureSlot) + 120, "deadline");
        require(choices.length > 1 && choices.length <= 256, "participant count");
        for (uint256 i = 0; i < choices.length; i++) {
            require(choices[i] != address(0), "zero participant");
            for (uint256 j = 0; j < i; j++) require(choices[i] != choices[j], "duplicate participant");
        }
        participants = choices;
        slot = futureSlot;
        deadline = deadline_;
        commitment = keccak256(abi.encode(block.chainid, address(this), decisionId,
            futureSlot, deadline_, choices));
        committed = true;
        emit Committed(commitment, futureSlot, deadline_);
    }

    function finish() external {
        require(committed && !resolved && !cancelled, "state");
        require(block.timestamp <= deadline, "deadline elapsed");
        bytes32 entropy = BEACON.randomness(slot);
        uint256 n = participants.length;
        uint256 threshold = addmod(type(uint256).max, 1, n);
        for (uint256 counter = 0; counter < 16; counter++) {
            uint256 candidate = uint256(keccak256(abi.encode(entropy, commitment, counter)));
            if (candidate < threshold) continue;
            uint256 index = candidate % n;
            winner = participants[index];
            resolved = true;
            emit Selected(commitment, winner, index);
            return;
        }
        revert("sampling limit");
    }

    function cancelExpired() external {
        require(committed && !resolved && !cancelled, "state");
        require(block.timestamp > deadline, "deadline active");
        cancelled = true;
        emit Cancelled(commitment);
    }
}

import { encodeAbiParameters, keccak256, parseAbiParameters, type Hex } from 'viem'

function selectIndex(entropy: Hex, commitment: Hex, count: number): number {
  if (!Number.isInteger(count) || count < 2 || count > 256) throw new Error('Count')
  const n = BigInt(count)
  const threshold = (1n << 256n) % n
  for (let counter = 0n; counter < 16n; counter++) {
    const candidate = BigInt(keccak256(encodeAbiParameters(
      parseAbiParameters('bytes32, bytes32, uint256'), [entropy, commitment, counter],
    )))
    if (candidate >= threshold) return Number(candidate % n)
  }
  throw new Error('Sampling limit')
}