fulfillRandomWords callback is not getting executed after calling fulfillRandomWords on the VRF v2 contract locally when unit testing

[alatiqueeagle]

When doing unit tests, the fulfillRandomWords on my contract is not executing after manually calling fulfillRandomWords from the VRF v2 mock contract. The unit test just times out without emitting an event that's in my contract's fulfillRandomWords. I am following lesson 14 and this happened to me in lesson 9 also.

Here is my contract:

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

import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol";

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

error RandomApeYachtClub__NotOwner();
error RandomApeYachtClub__BreedNotFound();
error RandomApeYachtClub__NotEnoughFeeToMint();
error RandomApeYachtClub__NotAbleToWithdraw();

contract RandomApeYachtClub is ERC721URIStorage, VRFConsumerBaseV2 {
  enum ApeBreed {
    CHIMP,
    GORILLA,
    BABOON,
    BLACK_HOWLER
  }

  // VRF helpers
  VRFCoordinatorV2Interface immutable private COORDINATOR;
  address immutable private i_vrfCoordinator;
  bytes32 immutable private i_keyHash;
  uint32 immutable private i_callbackGasLimit;
  uint64 immutable private i_subscriptionId;
  mapping (uint256 => address) s_requestIdToMinter;

  // NFT helper
  uint256 constant private MAX_RARITY = 500;
  uint256 private s_tokenId;
  string[4] private s_tokenURIs;
  mapping (uint256 => string) tokenIdToTokenURI;

  uint256 private i_mintFee;
  address immutable private i_owner;

  // Events
  event NFTRequested(uint256 requestId, address sender);
  event NFTMinted(uint256 requestId, uint256 tokenId, ApeBreed breed, address minter);

  constructor (
    address vrfCoordinator,
    bytes32 keyHash,
    uint32 callbackGasLimit,
    uint64 subscriptionId,
    string[4] memory tokenURIs,
    uint256 mintFee
  )
  ERC721("RandomApeYachtClub", "RAYC")
  VRFConsumerBaseV2(vrfCoordinator)
  {
    i_owner = msg.sender;
    COORDINATOR = VRFCoordinatorV2Interface(vrfCoordinator);
    i_vrfCoordinator = vrfCoordinator;
    i_keyHash = keyHash;
    i_callbackGasLimit = callbackGasLimit;
    i_subscriptionId = subscriptionId;
    s_tokenURIs = tokenURIs;
    i_mintFee = mintFee;
  }
  
  // ETH fee to mint, random nft minted
  function mintNft() payable external returns (uint256 requestId) {
    if(msg.value < i_mintFee)
      revert RandomApeYachtClub__NotEnoughFeeToMint();

    requestId = COORDINATOR.requestRandomWords(
      i_keyHash,
      i_subscriptionId,
      3,
      i_callbackGasLimit,
      1
    );

    s_requestIdToMinter[requestId] = msg.sender;
    emit NFTRequested(requestId, msg.sender);
  }

  // randomness
  function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal override {
    address minter = s_requestIdToMinter[requestId];
    uint256 tokenId = s_tokenId;

    uint256 randomNumber = randomWords[0] % MAX_RARITY;
    ApeBreed apeBreed = getApeFromNumber(randomNumber);
    string memory _tokenURI = s_tokenURIs[uint256(apeBreed)];
    _safeMint(minter, tokenId);
    _setTokenURI(tokenId, _tokenURI);
    tokenIdToTokenURI[tokenId] = _tokenURI;
    s_tokenId++;
    emit NFTMinted(requestId, tokenId, apeBreed, minter);
  }

  function getApeFromNumber(uint256 randomNumber) public pure returns (ApeBreed) {
    uint256[4] memory rarityChance = getRarityChance();
    uint256 accu = 0;
    for (uint i = 0; i < rarityChance.length; i++) {
      if((randomNumber >= rarityChance[i]) && (randomNumber < (rarityChance[i] + accu))) {
        return ApeBreed(i);
      }
      accu += rarityChance[i];
    }
    revert RandomApeYachtClub__BreedNotFound();
  }

  function getRarityChance() internal pure returns (uint256[4] memory) {
    return [10, 30, 120, MAX_RARITY];
  }

  // owner of the contract can withdraw
  function withdraw () external ownerOnly {
    uint256 balance = address(this).balance;

    (bool success, ) = i_owner.call{value: balance}("");
    if(!success)
      revert RandomApeYachtClub__NotAbleToWithdraw();
  }

  // tokenURI to return the NFT's uri
  function tokenURI(uint256 tokenId) public view override returns (string memory) {
    return tokenIdToTokenURI[tokenId];
  }

  modifier ownerOnly () {
    if(i_owner != msg.sender) {
        revert RandomApeYachtClub__NotOwner();
    }
    _;
  }

  function getMaxRarity() public pure returns (uint256) {
    return MAX_RARITY;
  }

  function getTokenURIs() public view returns (string[4] memory) {
    return s_tokenURIs;
  }

  function getMintFee() public view returns (uint256) {
    return i_mintFee;
  }
}

Here is my unit test file (the last test is the issue):

const { expect, assert } = require('chai');
const { ethers, deployments, network, getNamedAccounts } = require('hardhat');
const { devChains, networkConfig } = require('../../network.config');

!devChains.includes(network.name) ?
describe.skip : 
describe('RAYC', function () {
  let randomApeYachtClub, vrfCoordinatorV2Mock, deployer;
  const mintFee = networkConfig[network.config.chainId].mintFee;

  beforeEach(async function() {
    accounts = await ethers.getSigners();
    deployer = accounts[0];
    await deployments.fixture(['mocks', 'RAYC']);

    vrfCoordinatorV2Mock = await ethers.getContract("VRFCoordinatorV2Mock");
    randomApeYachtClub = await ethers.getContract("RandomApeYachtClub");
  });

  describe('constructor', function () {
    it('tokenURIs is assigned', async function() {
      const tokenURIs = await randomApeYachtClub.getTokenURIs();
      expect(tokenURIs).to.have.lengthOf(4);
    });

    it('mint fee is assigned', async function() {
      const contractMintFee = await randomApeYachtClub.getMintFee();
      assert.equal(ethers.utils.formatEther(contractMintFee), ethers.utils.formatEther(mintFee));
    })
  });

  describe('minNft', function() {
    it('if paid less than mint fee, an error is thrown', async function() {
      const smallFee = ethers.utils.parseEther('0.09');
      await expect(randomApeYachtClub.mintNft({ value: smallFee })).to.be.revertedWith('RandomApeYachtClub__NotEnoughFeeToMint');
    });

    it('NFTRequested event is fired', async function () {
      await expect(randomApeYachtClub.mintNft({ value: mintFee })).to.emit(randomApeYachtClub, 'NFTRequested');
    });
  });

  describe('withdraw', function() {
    it('the amount of the contract is 0 after withdrawing', async function() {
      await randomApeYachtClub.withdraw();
      const provider = ethers.provider;
      const balance = await provider.getBalance(randomApeYachtClub.address);
      expect(balance).to.equal(0);
    });
  });

  describe('fulfillRandomWords', function() {
    it('reverts if no valid requestId is provided', async function () {
      await expect(vrfCoordinatorV2Mock.fulfillRandomWords(0, randomApeYachtClub.address)).to.be.revertedWith('nonexistent request');
    });

    it('emits RandomWordsFulfilled', async function () {
      // mint NFT
      const tx = await randomApeYachtClub.mintNft({ value: mintFee });
      const receipt = await tx.wait(1);
      const requestId = receipt.events.find(e => e.event === 'NFTRequested').args['requestId'];
      // call fulfillRandomWords
      // and watch for the event
      await expect(vrfCoordinatorV2Mock.fulfillRandomWords(requestId, randomApeYachtClub.address))
      .to.emit(vrfCoordinatorV2Mock, 'RandomWordsFulfilled');
    });

    it('the vrf fulfillRandomWords sends the randomWords and emits NFTMinted', async function () {
      await new Promise(async (resolve, reject) => {
        randomApeYachtClub.on('NFTMinted', () => {
          try {
            // This right here is never executed
          } catch (error) {
            console.log(erro);
          }
        });
        try {
          // mint NFT
          const tx = await randomApeYachtClub.mintNft({ value: mintFee });
          const receipt = await tx.wait(1);
          const requestId = receipt.events.find(e => e.event === 'NFTRequested').args['requestId'];
          // call fulfillRandomWords
          // and watch for the event
          await vrfCoordinatorV2Mock.fulfillRandomWords(requestId, randomApeYachtClub.address);
        } catch (error) {
          console.log(error);
        }
      })
    });
  });
});

I am not sure what I'm doing wrong. Any help or guidance is appreciated.

[othaime-en]

Hey @alatiqueeagle first, change the category of this discussion to be Q&A its more appropriate that way.

Second, There should be an async anonymous function here randomApeYachtClub.on('NFTMinted', () => { not just a normal function. You should also use once (as in once the event is emitted) not on Change it to randomApeYachtClub.once('NFTMinted', async () => {

[alatiqueeagle]

That did not fix it. This is my updated test:

it('the vrf fulfillRandomWords sends the randomWords and emits NFTMinted', async function () {
  await new Promise(async (resolve, reject) => {
    randomApeYachtClub.once('NFTMinted', async () => {
      try {
        // This right here is never executed
        console.log('NFTMinted');
      } catch (error) {
        console.log(erro);
      }
    });
    try {
      // mint NFT
      const tx = await randomApeYachtClub.mintNft({ value: mintFee });
      const receipt = await tx.wait(1);
      const requestId = receipt.events.find(e => e.event === 'NFTRequested').args['requestId'];
      // call fulfillRandomWords
      // and watch for the event
      await vrfCoordinatorV2Mock.fulfillRandomWords(requestId, randomApeYachtClub.address);
    } catch (error) {
      console.log(error);
    }
  })
});

That event is still not running.

[alatiqueeagle]

@othaime-en This is the timeout result

[othaime-en]

@alatiqueeagle I noticed your try catches don't resolve or reject. Might be a stretch but, add resolve() and reject() appropriately and try again. If it fails, push the code to github we'll look into it.

The code should be something like this.

it('the vrf fulfillRandomWords sends the randomWords and emits NFTMinted', async function () {
  await new Promise(async (resolve, reject) => {
    randomApeYachtClub.once('NFTMinted', async () => {
      try {
        // This right here is never executed
        console.log('NFTMinted');
        resolve();
      } catch (error) {
        reject(error);
      }
    });
    try {
      // mint NFT
      const tx = await randomApeYachtClub.mintNft({ value: mintFee });
      const receipt = await tx.wait(1);
      const requestId = receipt.events.find(e => e.event === 'NFTRequested').args['requestId'];
      // call fulfillRandomWords
      // and watch for the event
      await vrfCoordinatorV2Mock.fulfillRandomWords(requestId, randomApeYachtClub.address);
    } catch (error) {
      console.log(error);
      reject(error);
    }
  })
});

[adityabhattad2021]

I got the exact problem It is most probably due to reslove statement missing.

[krakxn]

Hey, assuming @othaime-en looked into the logic already, are you running on Rinkeby? If so, that is precisely the problem. Use Goerli/Kovan and let me know if it persists.

Note: in accordance with the network in your subscriptionId (also check if this is correct) as well as the funds if it is insufficient :)

[alatiqueeagle]

Hello, no I am using localhost.

[krakxn]

Push to GitHub; we will look into it

[chainxvi]

I pushed it https://github.com/chainxvi/nft-hardhat

[krakxn]

Is this resolved--via the other replies--yet?

[chainxvi]

Sadly, no.

[adityabhattad2021]

The error is,

 it('the vrf fulfillRandomWords sends the randomWords and emits NFTMinted', async function () {
      await new Promise(async (resolve, reject) => {
        randomApeYachtClub.on('NFTMinted', () => {
          try {
            // This right here is never executed
          } catch (error) {
            console.log(error);
          }
        });
        try {
          // mint NFT
          const tx = await randomApeYachtClub.mintNft({ value: mintFee });
          const receipt = await tx.wait(1);
          const requestId = receipt.events.find(e => e.event === 'NFTRequested').args['requestId'];
          // call fulfillRandomWords
          // and watch for the event
          await vrfCoordinatorV2Mock.fulfillRandomWords(requestId, randomApeYachtClub.address);
        } catch (error) {
          console.log(error);
        }
      })
    });
  });

Here resolve statement is missing, which results in promise never getting resolved and the execution exceeding time out duration.
Try this instead:

it('the vrf fulfillRandomWords sends the randomWords and emits NFTMinted', async function () {
      await new Promise(async (resolve, reject) => {
        randomApeYachtClub.on('NFTMinted', () => {
          try {
            // This right here is never executed
          } catch (error) {
            console.log(error);
            reject(error);
          }
          reslove();
        });
        try {
          // mint NFT
          const tx = await randomApeYachtClub.mintNft({ value: mintFee });
          const receipt = await tx.wait(1);
          const requestId = receipt.events.find(e => e.event === 'NFTRequested').args['requestId'];
          // call fulfillRandomWords
          // and watch for the event
          await vrfCoordinatorV2Mock.fulfillRandomWords(requestId, randomApeYachtClub.address);
        } catch (error) {
          console.log(error);
        }
      })
    });
  });

[chainxvi]

Hello I'm the same person as @alatiqueeagle. That also didn't solve it. I pushed the code to a repo.

@othaime-en @krakxn @adityabhattad2021