Contract

// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.28;

import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title Commit-Reveal Randomness
 * @notice A contract that provides a commit-reveal mechanism for generating random numbers
 * @dev Uses future block hash as a source of randomness
 */
contract CommitRevealRandomness is Ownable {
  // Struct to store randomization request details
  struct RandomizationRequest {
    string id;
    uint256 numberFrom;
    uint256 numberTo;
    uint256 targetBlock;
    bool revealed;
    uint256 result;
  }

  // Mapping from id to randomization request
  mapping(string => RandomizationRequest) private _requests;

  // Events
  event RandomizationRequested(
    string id,
    uint256 numberFrom,
    uint256 numberTo,
    uint256 targetBlock
  );
  event RandomizationRevealed(string id, uint256 randomNumber);

  // Custom errors
  error InvalidRange();
  error RequestNotFound();
  error BlockNotReached();
  error AlreadyRequested();
  error RequestAlreadyRevealed();
  error BlockTooOld();
  error ResultNotRevealed();

  /**
   * @notice Initializes the CommitRevealRandomness contract
   */
  constructor() Ownable(msg.sender) {}

  /**
   * @notice Requests randomization for a given id and range
   * @param id The unique identifier for this randomization request
   * @param numberFrom The inclusive lower bound of the random number range
   * @param numberTo The inclusive upper bound of the random number range
   * @return The target block number for the reveal phase
   */
  function randomize(
    string calldata id,
    uint256 numberFrom,
    uint256 numberTo
  ) external returns (uint256) {
    // Validate input parameters
    if (numberFrom > numberTo) revert InvalidRange();

    // Calculate target block (current block + 100)
    uint256 targetBlock = block.number + 100;

    if (_requests[id].targetBlock != 0) revert AlreadyRequested();

    // Store the request
    _requests[id] = RandomizationRequest({
      id: id,
      numberFrom: numberFrom,
      numberTo: numberTo,
      targetBlock: targetBlock,
      revealed: false,
      result: 0
    });

    // Emit event
    emit RandomizationRequested(id, numberFrom, numberTo, targetBlock);

    return targetBlock;
  }

  /**
   * @notice Reveals and permanently saves the random number for a given id
   * @param id The unique identifier for the randomization request
   * @return The generated random number within the specified range
   */
  function reveal(string calldata id) external returns (uint256) {
    // Get the request
    RandomizationRequest storage request = _requests[id];

    // Validate request exists
    if (request.targetBlock == 0) revert RequestNotFound();

    // Validate request is not already revealed
    if (request.revealed) revert RequestAlreadyRevealed();

    // Validate target block has been reached
    if (block.number < request.targetBlock) revert BlockNotReached();

    // Validate block is not too old (blockhash only works for 256 most recent blocks)
    if (block.number - request.targetBlock >= 256) revert BlockTooOld();

    // Get the block hash of the target block
    bytes32 blockHash = blockhash(request.targetBlock);

    // Generate random number using block hash, id, and timestamp
    uint256 randomNumber = uint256(
      keccak256(abi.encodePacked(blockHash, id, block.timestamp))
    );

    // Scale the random number to the desired range (inclusive)
    uint256 range = request.numberTo - request.numberFrom + 1;
    uint256 result = request.numberFrom + (randomNumber % range);

    // Save the result and mark as revealed
    request.result = result;
    request.revealed = true;

    // Emit event
    emit RandomizationRevealed(id, result);

    return result;
  }

  /**
   * @notice Checks if a randomization request exists
   * @param id The unique identifier for the randomization request
   * @return True if the request exists, false otherwise
   */
  function requestExists(string calldata id) external view returns (bool) {
    return _requests[id].targetBlock != 0;
  }

  /**
   * @notice Gets the target block for a randomization request
   * @param id The unique identifier for the randomization request
   * @return The target block number
   */
  function getTargetBlock(string calldata id) external view returns (uint256) {
    if (_requests[id].targetBlock == 0) revert RequestNotFound();
    return _requests[id].targetBlock;
  }

  /**
   * @notice Shows the result of a randomization request if it has been revealed
   * @param id The unique identifier for the randomization request
   * @return The revealed random number
   */
  function showResult(string calldata id) external view returns (uint256) {
    // Get the request
    RandomizationRequest memory request = _requests[id];

    // Validate request exists
    if (request.targetBlock == 0) revert RequestNotFound();

    // Validate request has been revealed
    if (!request.revealed) revert ResultNotRevealed();

    return request.result;
  }
}