gas estimation errored with message: "execution reverted: Below agreed payment"

Question

I am having issues when trying to use the Chainlink random number generator and deploying to Rinkeby. Relevant code pieces are the following:

Constructor from the importing contract (should be working fine).

// RandomNumberConsumer parameters for RINKEBY testnet
    address _vrfCoordinator = 0xb3dCcb4Cf7a26f6cf6B120Cf5A73875B7BBc655B;
    address _link =     0x01BE23585060835E02B77ef475b0Cc51aA1e0709;
    bytes32 _keyHash = 0x2ed0feb3e7fd2022120aa84fab1945545a9f2ffc9076fd6156fa96eaff4c1311;
    uint256 _fee = 0.1 * 10 ** 18; // 0.1 LINK
    constructor() RandomNumberConsumer(_vrfCoordinator, _link, _keyHash, _fee) {}

RandomNumberConsumer.sol. As specified in the chainlink docs, with a few tweaks needed for my approach.

pragma solidity ^0.8.7;

import "@chainlink/contracts/src/v0.8/VRFConsumerBase.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "hardhat/console.sol";

contract RandomNumberConsumer is VRFConsumerBase, Ownable{
    // Variables
    bytes32 internal s_keyHash;
    uint256 internal s_fee;
    uint256 private constant ROLL_IN_PROGRESS = 150;
    mapping(bytes32 => address) private s_rollers;
    mapping(address => uint256) private s_results;
    //address vrfCoordinator = 0x3d2341ADb2D31f1c5530cDC622016af293177AE0;
    //address link = 0xb0897686c545045aFc77CF20eC7A532E3120E0F1;

    // Events
    event DiceRolled(bytes32 indexed requestId, address indexed roller);
    event DiceLanded(bytes32 indexed requestId, uint256 indexed result);

    /**
     * Constructor inherits VRFConsumerBase
     *
     * Network: Rinkeby
     * Chainlink VRF Coordinator address: 0xb3dCcb4Cf7a26f6cf6B120Cf5A73875B7BBc655B
     * LINK token address:                0x01BE23585060835E02B77ef475b0Cc51aA1e0709
     * Key Hash: 0x2ed0feb3e7fd2022120aa84fab1945545a9f2ffc9076fd6156fa96eaff4c1311
     */
    constructor(address vrfCoordinator, address link, bytes32 keyHash, uint256 fee)
      VRFConsumerBase(vrfCoordinator, link){
        s_keyHash = keyHash;
        s_fee = fee;
      }

    // Functions
    function rollDice(address roller) public onlyOwner returns (bytes32 requestId){
        console.log("RNG Contract address",address(this));
        // Checking LINK balance
        require(LINK.balanceOf(address(this)) >= s_fee, "Not enough LINK in contract.");
        // Checking if roller has already rolled dice since each roller can only ever be assigned to a single house. TODO: this can be changed
        require(s_results[roller] == 0, "Already rolled");
        // Requesting randomness
        requestId = requestRandomness(s_keyHash, s_fee); // Error is happening here!
        // Storing requestId and roller address
        s_rollers[requestId] = roller;
        // Emitting event to signal rolling of dice
        s_results[roller] = ROLL_IN_PROGRESS;
        emit DiceRolled(requestId, roller);
    }

    // fulfillRandomness is a special function defined within the VRFConsumerBase contract that our contract extends from.
    // The coordinator sends the result of our generated randomness back to fulfillRandomness.
    function fulfillRandomness(bytes32 requestId, uint256 randomness) override internal {
        // Transform the result to a number between 0 and 100, both included. Using % as modulo
        require(randomness!=0, "Modulo zero!");
        uint256 d100Value = (randomness % 100) + 1; // +1 so s_results[player] can be 0 if no dice has been rolled
        // Assign the transformed value to the address in the s_results mapping variable.
        s_results[s_rollers[requestId]] = d100Value;
        // Emit a DiceLanded event.
        emit DiceLanded(requestId, d100Value);
    }

    // playerWins determines whether the player wins or lose the battle, based on a fixed chance (0-100)
    function playerWins (address player, uint8 chance) internal view returns (bool wins){
        require(s_results[player] != 0, "Player has not engaged in battle!");
        require(s_results[player] != ROLL_IN_PROGRESS, "Battle in progress!");
        return s_results[player] <= (chance + 1); //+1 because dice is 1-101
    }
}

RNG call from the importing contract(simplified to relevant part only. _player address is working correctly).

        address _player = ownerOf(_monId);
        rollDice(_player);

I have the certainty that the error occurs inside the rollDice function, more specifically in the call to requestRandomness. Apart from that, I cannot seem to find why the error is hapenning, nor any references to the error message (Below agreed payment) inside any of the dependency contracts. Cannot find any references online either.

Any help is appreciated, thanks.

Answer 1

Below agreed payment error message comes from the sufficientLINK modifier of the VRFCoordinator.sol contract. You can see it here and here.

Double-check the constructor parameters, especially the fee value.

Also, make sure to fund your smart contract with Rinkeby LINK tokens which you can claim from the faucet.