Integration pattern

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

import {IVRFSystem} from "@rollcodes/interfaces/IVRFSystem.sol";
import {IVRFSystemCallback} from "@rollcodes/interfaces/IVRFSystemCallback.sol";

contract ExampleConsumer is IVRFSystemCallback {
    error Unauthorized();
    error RequestNotFound(uint256 requestId);
    error AlreadySettled(uint256 requestId);

    IVRFSystem public immutable vrfSystem;

    struct Pending {
        address player;
        bool settled;
        uint256 randomNumber;
    }

    mapping(uint256 => Pending) public pendingByRequestId;

    constructor(address coordinatorAddress) {
        vrfSystem = IVRFSystem(coordinatorAddress);
    }

    function play() external payable returns (uint256 requestId) {
        uint256 fee = vrfSystem.requestFee();
        require(msg.value == fee, "fee mismatch");

        uint256 traceId = 0;
        requestId = vrfSystem.requestRandomNumberWithTraceId{ value: fee }(traceId);

        pendingByRequestId[requestId] = Pending({
            player: msg.sender,
            settled: false,
            randomNumber: 0
        });
    }

    function randomNumberCallback(uint256 requestId, uint256 randomNumber) external override {
        if (msg.sender != address(vrfSystem)) revert Unauthorized();

        Pending storage p = pendingByRequestId[requestId];
        if (p.player == address(0)) revert RequestNotFound(requestId);
        if (p.settled) revert AlreadySettled(requestId);

        p.settled = true;
        p.randomNumber = randomNumber;

        // settle your game or app logic here
    }
}