Quickstart

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

interface IKeeperCoordinator {
    // Request a PoFR event. Returns eventId.
    // Fee must be >= MIN_FEE. Rate limited: 1 request per 10 blocks per address.
    function requestRandomness(bytes32 userSeed) external payable returns (bytes32 eventId);

    // Check if an event has been fulfilled
    function isFulfilled(bytes32 eventId) external view returns (bool);

    // Get the RandProof artifact for a fulfilled event
    function getRandProof(bytes32 eventId) external view returns (
        bytes32 seed,
        bytes memory aggregatedBLSSig,
        address[] memory signers,
        uint256 fulfillBlock,
        uint256 fulfillTimestamp
    );
}

contract MyRaffle is IRandProofConsumer {
    IKeeperCoordinator public coordinator;
    mapping(bytes32 => uint256) public pendingDraws; // eventId => totalEntrants

    constructor(address _coordinator) {
        coordinator = IKeeperCoordinator(_coordinator);
    }

    // Step 1: request randomness when the draw is ready
    function requestDraw(uint256 totalEntrants) external payable {
        bytes32 userSeed = keccak256(abi.encode(block.number, msg.sender, totalEntrants));
        bytes32 eventId = coordinator.requestRandomness{value: msg.value}(userSeed);
        pendingDraws[eventId] = totalEntrants;
    }

    // Step 2: receive the fulfilled randomness (called by KeeperCoordinator)
    function fulfillRandomness(bytes32 eventId, bytes32 seed) external override {
        require(msg.sender == address(coordinator), "Only coordinator");
        uint256 totalEntrants = pendingDraws[eventId];
        require(totalEntrants > 0, "Unknown event");
        uint256 winnerIndex = uint256(seed) % totalEntrants;
        // ... settle the draw
    }
}