Medium Stakes

import {VEOConsumerBase} from "./VEOConsumerBase.sol";

contract MyGame is VEOConsumerBase {
    constructor(address _veo)
        VEOConsumerBase(_veo, true) {} // true = enable anti-squatting

    function startGame(bytes32 gameId) external payable {
        // Request entropy bound to this contract
        bytes32 requestId = requestRandom{value: msg.value}(gameId);
    }

    function finishGame(bytes32 requestId) external {
        // Consume and trigger callback
        finalizeRandom(requestId);
    }

    function _onEntropy(
        bytes32 requestId,
        address requester,
        bytes32 entropy,
        bytes32 gameId
    ) internal override {
        // Your game logic here
        uint256 result = uint256(entropy) % 100;
    }
}

// Setup: Enable authorization in constructor
veo.setRequiresAuthorization(true);
veo.setRequesterAuthorization(address(this), true);

// 1. Request (bound to your contract + actionId)
bytes32 actionId = keccak256(abi.encodePacked("game", gameId));
bytes32 requestId = veo.requestEntropyForConsumer{value: price}(
    address(this),  // consumer = your contract
    actionId        // one active request per actionId
);

// 2. Wait for keeper fulfillment (~75 seconds)

// 3. Consume (only your contract can call this)
bytes32 salt = keccak256(abi.encodePacked(address(this), requestId, block.chainid));
bytes32 entropy = veo.consumeEntropy(requestId, salt);

contract MyGame {
    IVEO public veo;
    mapping(bytes32 => bool) public pendingRequests;

    function startGame(bytes32 gameId) external payable {
        bytes32 actionId = keccak256(abi.encodePacked("game", gameId));
        bytes32 requestId = veo.requestEntropyForConsumer{value: msg.value}(
            address(this),
            actionId
        );
        pendingRequests[requestId] = true;
        // Keeper will call fulfillEntropy() - you don't need to!
    }

    function finishGame(bytes32 requestId) external {
        require(pendingRequests[requestId], "Not pending");

        // Check if keeper has fulfilled (optional - consumeEntropy will revert if not)
        (bytes32 entropy, bool fulfilled) = veo.getEntropy(requestId);
        require(fulfilled, "Wait for keeper");

        // Consume to get derived entropy (only your contract can call this)
        bytes32 salt = keccak256(abi.encodePacked(address(this), requestId, block.chainid));
        bytes32 derivedEntropy = veo.consumeEntropy(requestId, salt);

        pendingRequests[requestId] = false;

        // Use the entropy
        uint256 result = uint256(derivedEntropy) % 100;
    }
}

import { keccak256, AbiCoder, solidityPackedKeccak256 } from "ethers";

// Track pending requests locally
const pendingRequests = new Map(); // requestId -> { userAddress, chainId }

// 1. Request entropy (Medium tier)
async function requestEntropy(userAddress, actionId) {
    const price = await veo.getPrice();
    const tx = await veo.requestEntropyForConsumer(userAddress, actionId, { value: price });
    const receipt = await tx.wait();

    // Parse EntropyRequested event to get requestId
    const event = receipt.logs.find(log => {
        const parsed = veo.interface.parseLog(log);
        return parsed?.name === "EntropyRequested";
    });
    const requestId = veo.interface.parseLog(event).args.requestId;

    // Track locally for keeper detection
    const chainId = (await provider.getNetwork()).chainId;
    pendingRequests.set(requestId, { userAddress, chainId });

    return requestId;
}

// 2. Poll for keeper fulfillment
async function pollForFulfillment() {
    for (const [requestId, { userAddress, chainId }] of pendingRequests) {
        const [baseEntropy, fulfilled] = await veo.getEntropy(requestId);

        if (fulfilled) {
            // 3. Derive entropy client-side (same formula as contract)
            const abiCoder = new AbiCoder();
            const salt = keccak256(
                abiCoder.encode(
                    ["address", "bytes32", "uint256"],
                    [userAddress, requestId, chainId]
                )
            );

            const derivedEntropy = solidityPackedKeccak256(
                ["bytes32", "address", "address", "bytes32", "uint256"],
                [baseEntropy, userAddress, userAddress, salt, chainId]
            );

            pendingRequests.delete(requestId);
            onEntropyReady(derivedEntropy); // Your callback
        }
    }
}

// Poll every 5 seconds
setInterval(pollForFulfillment, 5000);