GOAT Network VRF Contracts

// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
 
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 
contract MyRandomContract is IRandomnessCallback {
    using SafeERC20 for IERC20;
 
    // GoatVRF contract address
    address public goatVRF;
 
    constructor(address goatVRF_) {
        goatVRF = goatVRF_;
    }
 
    /**
     * @dev Request randomness from GoatVRF
     * @param maxAllowedGasPrice Maximum allowed gas price for fulfillment
     * @return requestId Unique identifier for the request
     */
   function getNewRandom(uint256 maxAllowedGasPrice) external onlyOwner returns (uint256 requestId) {
      // Get the WGOATBTC token address from GoatVRF
      address tokenAddress = IGoatVRF(goatVRF).feeToken();
      // Gas limit for the callback function, this should be set to a reasonable value
      uint256 callbackGas = 600000;
 
      // Calculate fee with sufficient gas for callback
      // The callback is simple, but we allocate extra gas to be safe
      uint256 fee = IGoatVRF(goatVRF).calculateFeeWithGasPrice(callbackGas, maxAllowedGasPrice);
 
      // Transfer tokens from caller to this contract if needed
      // This step is optional depending on your token handling strategy
 
      // Approve GoatVRF to spend tokens
      IERC20 token = IERC20(tokenAddress);
      // Since the underlying token is WGOATBTC (wrapped BTC in GOAT network), and the price is fetched from the price feed oracle in realtime,
      // we need to ensure that the contract has enough allowance for the fee. So it is better to apply a safety margin
      // to avoid any issues with gas price fluctuations. 50% is just a suggested value, you can adjust it as needed.
      // If you do not want to approve the token every time, you can also approve all of your budget at once.
      // Even if you approved the contract with a higher amount, the fee will be calculated based on
      // the gas price at the time of the request and actual usage, so you will not be charged more than the fee.
      uint256 safetyMargin = fee * 3 / 2;
      token.forceApprove(goatVRF, safetyMargin);
 
      // Get beacon for deadline calculation
      IDrandBeacon beacon = IDrandBeacon(IGoatVRF(goatVRF).beacon());
 
      // Request randomness with appropriate deadline
      uint256 deadline = block.timestamp + beacon.period();
      requestId = IGoatVRF(goatVRF).getNewRandom(deadline, maxAllowedGasPrice, callbackGas);
   }
 
    /**
     * @dev Callback function used by GoatVRF to deliver randomness
     * @param requestId Unique identifier for the randomness request
     * @param randomness The random value
     */
    function receiveRandomness(uint256 requestId, uint256 randomness) external override {
        // Only GoatVRF can call this function, make sure you add this check
        require(msg.sender == goatVRF, "Only GoatVRF can fulfill randomness");
 
        // Use randomness in your application
        // For example: selectWinner(randomness);
    }
}
 
interface IRandomnessCallback {
   function receiveRandomness(uint256 requestId, uint256 randomness) external;
}
 
interface IDrandBeacon {
   function period() external view returns (uint256);
}
 
interface IGoatVRF {
   function calculateFee(uint256 gas)
   external
   view
   returns (uint256 totalFee);
 
   function calculateFeeWithGasPrice(uint256 gas, uint256 gasPrice)
   external
   view
   returns (uint256 totalFee);
 
   function getNewRandom(uint256 deadline, uint256 maxAllowedGasPrice, uint256 callbackGas)
   external
   returns (uint256 requestId);
 
   function cancelRequest(uint256 requestId) external;
 
   function beacon() external view returns (address beaconAddr);
 
   function feeToken() external view returns (address tokenAddr);
}

// Calculate fee with sufficient gas and current tx.gasprice for callback
uint256 fee = IGoatVRF(goatVRF).calculateFee(600000);
 
// Calculate fee with sufficient gas and desired gas price for callback
uint256 fee = IGoatVRF(goatVRF).calculateFeeWithGasPrice(600000, 0.01 gwei);

// Get token address
address tokenAddress = IGoatVRF(goatVRF).feeToken();
IERC20 token = IERC20(tokenAddress);
 
// Approve fee
require(token.approve(goatVRF, fee), "Token approval failed");

IDrandBeacon beacon = IDrandBeacon(IGoatVRF(goatVRF).beacon());
uint256 deadline = block.timestamp + beacon.period();

# Build contracts
forge build
 
# Run tests
forge test
 
# Deploy contracts
forge script script/Deploy.s.sol --rpc-url <your_rpc_url> --private-key <your_private_key>