LESSONS 9: AssertionError: expected '0x00000000000000000000000000000000000…' to equal '0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c…'

[cryptocambi]

Hi,

I am at the staging test stage and running the command, "yarn hardhat test --network sepolia", and I have got this error:

Raffle unit test
FulfillRandomWord
AssertionError: expected '0x00000000000000000000000000000000000…' to equal '0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c…'
at C:\Users\K\hh-fcc\hardhat-smartcontract-lottary-fcc\test\staging\Raffle.staging.js:32:34
at processTicksAndRejections (node:internal/process/task_queues:95:5) {
showDiff: true,
actual: '0x0000000000000000000000000000000000000000',
expected: '0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c71D51',
operator: 'strictEqual'
}
1) works with live chainlink keepers and Chainlink VRF, we get a random winner

0 passing (3s)
1 failing

1. Raffle unit test
   FulfillRandomWord
   works with live chainlink keepers and Chainlink VRF, we get a random winner:

   AssertionError: expected '0x00000000000000000000000000000000000…' to equal '0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c…'

   • expected - actual

   -0x0000000000000000000000000000000000000000
   +0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c71D51

   at C:\Users\K\hh-fcc\hardhat-smartcontract-lottary-fcc\test\staging\Raffle.staging.js:32:34
   at processTicksAndRejections (node:internal/process/task_queues:95:5)

here below, my raffle.staging.js file:

const { developmentChains, networkConfig } = require("../../helper-hardhat-config")
const { getNamedAccounts, deployments, ethers, network } = require("hardhat")
const { assert, expect } = require("chai")

developmentChains.includes(network.name)
? describe.skip
: describe("Raffle unit test", function () {
let raffle, raffleEntranceFee, deployer

      beforeEach(async function () {
          deployer = (await getNamedAccounts()).deployer
          raffle = await ethers.getContract("Raffle", deployer)
          raffleEntranceFee = await raffle.getEntranceFee()
      })

      describe("FulfillRandomWord", function () {
          it("works with live chainlink keepers and Chainlink VRF, we get a random winner", async () => {
              const startingTimeStamp = await raffle.getLastTimeStamp()
              const accounts = await ethers.getSigners()
              await new Promise(async (resolve, reject) => {
                  raffle.once("WinnerPicked", async () => {
                      console.log("Winner event as been fired!")
                  })

                  try {
                      const recentWinner = await raffle.getRecentWinner()
                      const raffleState = await raffle.getRaffleState()
                      const winnerEndingBalance = await accounts[0].getBalance()
                      const endingTimeStamp = await raffle.getLastTimeStamp()

                      await expect(raffle.getPlayer(0)).to.be.reverted
                      assert.equal(recentWinner.toString(), accounts[0].address)
                      assert.equal(raffleState, 0)
                      assert.equal(
                          winnerEndingBalance.toString(),
                          winnerStartingBalance.add(raffleEntranceFee).toSting()
                      )
                      assert(endingTimeStamp > startingTimeStamp)
                      resolve()
                  } catch (error) {
                      reject(error)
                      console.log(error)
                  }
              })
              //await raffle.enterRaffle({ value: raffleEntranceFee })
              //const winnerStartingBalance = await accounts[0].getBalance()
              console.log("Entering Raffle...")
              const tx = await raffle.enterRaffle({ value: raffleEntranceFee }) // changes on this line.
              txReceipt = await tx.wait(1) // changes on this line.
              console.log("Ok, time to wait...")
              const winnerStartingBalance = await accounts[0].getBalance()
          })
      })
  })

I thought that the zero address was due to some mistake on the subscription or to the upkeep stages, but are both active and fund it

here my hardhat.config.js file:

/** @type import('hardhat/config').HardhatUserConfig */
require("@nomiclabs/hardhat-waffle")
require("@nomiclabs/hardhat-etherscan")
require("hardhat-deploy")
require("solidity-coverage")
require("hardhat-gas-reporter")
require("hardhat-contract-sizer")
require("dotenv").config()

const SEPOLIA_RPC_URL =
process.env.SEPOLIA_RPC_URL ||
"https://eth-sepolia.g.alchemy.com/v2/-eThWc9tsabKX_oPoSJg97lC2vaDYpRT"
const PRIVATE_KEY = process.env.PRIVATE_KEY
const COINMARKETCAP_API_KEY = process.env.COINMARKETCAP_API_KEY
const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY

module.exports = {
defaultNetwork: "hardhat",
networks: {
hardhat: {
chainId: 31337,
blockConfermation: 1,
},
sepolia: {
chainId: 11155111,
blockConfermation: 6,
url: SEPOLIA_RPC_URL,
accounts: [PRIVATE_KEY],
},
},
etherscan: {
apiKey: {
sepolia: "7S6BRMF83C5TY4VX2SFIAGZAXIX4NPQ5D4",
},
},
gasReporter: {
enabled: false,
currency: "USD",
outputFile: "gas-report.txt",
noColors: true,
// coinmarketcap: COINMARKETCAP_API_KEY,
},
solidity: {
compilers: [
{
version: "0.8.7",
},
{
version: "0.8.0",
},
{
version: "0.8.4",
},
],
},
namedAccounts: {
deployer: {
default: 0,
},
player: {
default: 1,
},
},
mocha: {
timeout: 300000,
},
}
and also my helper-hardhat-config.js file:

const { ethers } = require("hardhat")

const networkConfig = {
11155111: {
name: "sepolia",
vrfCoordinatorV2: "0x8103B0A8A00be2DDC778e6e7eaa21791Cd364625",
subscriptionId: "2319",
gasLane: "0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c",
interval: "30",
entranceFee: ethers.utils.parseEther("0.01"),
callbackGasLimit: "500000",
},
31337: {
name: "hardhat",
entranceFee: ethers.utils.parseEther("0.01"),
gasLane: "0x474e34a077df58807dbe9c96d3c009b23b3c6d0cce433e59bbf5b34f823bc56c",
callbackGasLimit: "500000",
interval: "30",
},
}
const developmentChains = ["hardhat", "localhost"]

module.exports = {
networkConfig,
developmentChains,
}

Here my repo

any clue what I am missing?

[cryptocambi]

My repo sorry: https://github.com/cryptocambi/Hardhat-SmartContract-Lottery

[cryptocambi]

I have add console.log to see if the balances are the same:
const { developmentChains, networkConfig } = require("../../helper-hardhat-config")
const { getNamedAccounts, deployments, ethers, network } = require("hardhat")
const { assert, expect } = require("chai")

developmentChains.includes(network.name)
? describe.skip
: describe("Raffle unit test", function () {
let raffle, raffleEntranceFee, deployer

      beforeEach(async function () {
          deployer = (await getNamedAccounts()).deployer
          raffle = await ethers.getContract("Raffle", deployer)
          raffleEntranceFee = await raffle.getEntranceFee()
      })

      describe("FulfillRandomWord", function () {
          it("works with live chainlink keepers and Chainlink VRF, we get a random winner", async () => {
              const startingTimeStamp = await raffle.getLastTimeStamp()
              const accounts = await ethers.getSigners()
              console.log("Accounts:", accounts[0])

              await new Promise(async (resolve, reject) => {
                  raffle.once("WinnerPicked", async () => {
                      console.log("Winner event as been fired!")
                  })

                  try {
                      const recentWinner = await raffle.getRecentWinner()
                      const raffleState = await raffle.getRaffleState()
                      const winnerEndingBalance = await accounts[0].getBalance()
                      const winnerStartingBalance = await accounts[0].getBalance()
                      console.log("Winner's ending balance:", winnerEndingBalance.toString())
                      console.log(
                          "Winner's starting balance:",
                          winnerStartingBalance.toString()
                      )
                      const endingTimeStamp = await raffle.getLastTimeStamp()

                      await expect(raffle.getPlayer(0)).to.be.reverted
                      assert.equal(recentWinner.toString(), accounts[0].address)
                      assert.equal(raffleState, 0)
                      assert.equal(
                          winnerEndingBalance.toString(),
                          winnerStartingBalance.add(raffleEntranceFee).toSting()
                      )
                      assert(endingTimeStamp > startingTimeStamp)
                      resolve()
                  } catch (error) {
                      reject(error)
                      console.log(error)
                  }
              })
              //await raffle.enterRaffle({ value: raffleEntranceFee })
              //const winnerStartingBalance = await accounts[0].getBalance()
              console.log("Entering Raffle...")
              const tx = await raffle.enterRaffle({ value: raffleEntranceFee }) // changes on this line.
              txReceipt = await tx.wait(1) // changes on this line.
              console.log("Ok, time to wait...")
              const winnerStartingBalance = await accounts[0].getBalance()
          })
      })
  })

this is the result, the two balance are actually equal:

Raffle unit test
FulfillRandomWord
Accounts: SignerWithAddress {
_isSigner: true,
address: '0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c71D51',
_signer: JsonRpcSigner {
_isSigner: true,
provider: EthersProviderWrapper {
_isProvider: true,
_events: [],
_emitted: [Object],
disableCcipRead: false,
formatter: [Formatter],
anyNetwork: false,
_networkPromise: [Promise],
_maxInternalBlockNumber: -1024,
_lastBlockNumber: -2,
_maxFilterBlockRange: 10,
_pollingInterval: 4000,
_fastQueryDate: 0,
connection: [Object],
_nextId: 42,
_hardhatProvider: [BackwardsCompatibilityProviderAdapter],
_eventLoopCache: [Object],
_network: [Object]
},
_address: '0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c71D51',
_index: null
},
provider: EthersProviderWrapper {
_isProvider: true,
_events: [],
_emitted: { block: -2 },
disableCcipRead: false,
formatter: Formatter { formats: [Object] },
anyNetwork: false,
_networkPromise: Promise { [Object] },
_maxInternalBlockNumber: -1024,
_lastBlockNumber: -2,
_maxFilterBlockRange: 10,
_pollingInterval: 4000,
_fastQueryDate: 0,
connection: { url: 'http://localhost:8545' },
_nextId: 42,
_hardhatProvider: BackwardsCompatibilityProviderAdapter {
_wrapped: [ChainIdValidatorProvider],
_provider: [ChainIdValidatorProvider],
sendAsync: [Function: bound sendAsync],
send: [Function: bound send],
_sendJsonRpcRequest: [Function: bound _sendJsonRpcRequest] AsyncFunction
},
_eventLoopCache: { detectNetwork: null },
_network: {
name: 'sepolia',
chainId: 11155111,
ensAddress: null,
_defaultProvider: [Function]
}
}
}
Winner's ending balance: 986269876793741654
Winner's starting balance: 986269876793741654
AssertionError: expected '0x00000000000000000000000000000000000…' to equal '0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c…'
at C:\Users\K\hh-fcc\hardhat-smartcontract-lottary-fcc\test\staging\Raffle.staging.js:40:34
at processTicksAndRejections (node:internal/process/task_queues:95:5) {
showDiff: true,
actual: '0x0000000000000000000000000000000000000000',
expected: '0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c71D51',
operator: 'strictEqual'
}
1) works with live chainlink keepers and Chainlink VRF, we get a random winner

0 passing (3s)
1 failing

1. Raffle unit test
   FulfillRandomWord
   works with live chainlink keepers and Chainlink VRF, we get a random winner:

   AssertionError: expected '0x00000000000000000000000000000000000…' to equal '0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c…'

   • expected - actual

   -0x0000000000000000000000000000000000000000
   +0x97e8C38f71B99eec9017eF9Bc01AA8Ee81c71D51

   at C:\Users\K\hh-fcc\hardhat-smartcontract-lottary-fcc\test\staging\Raffle.staging.js:40:34
   at processTicksAndRejections (node:internal/process/task_queues:95:5)

[cryptocambi]

Actually should not be equal because I have to add raffleEntranceFee to the starting balance in order to be equal

[ezescigo]

Format the code please.

[alfaqi]

Re-order the steps of testing, like enter the lottery with pay the fees (with specific account), then pick up the winner.

[cryptocambi]

Hi alfaqi,

Do you mean something like this:

const { developmentChains, networkConfig } = require("../../helper-hardhat-config")
const { getNamedAccounts, deployments, ethers, network } = require("hardhat")
const { assert, expect } = require("chai")

developmentChains.includes(network.name)
? describe.skip
: describe("Raffle unit test", function () {
let raffle, raffleEntranceFee, deployer

      beforeEach(async function () {
          deployer = (await getNamedAccounts()).deployer
          raffle = await ethers.getContract("Raffle", deployer)
          raffleEntranceFee = await raffle.getEntranceFee()
      })

      describe("FulfillRandomWord", function () {
          it("works with live chainlink keepers and Chainlink VRF, we get a random winner", async () => {
              const startingTimeStamp = await raffle.getLastTimeStamp()
              const accounts = await ethers.getSigners()

              console.log("Entering Raffle...")
              const tx = await raffle.enterRaffle({ value: raffleEntranceFee })
              const txReceipt = await tx.wait(1)
              console.log("Ok, time to wait...")
              const winnerStartingBalance = await accounts[0].getBalance()

              await new Promise(async (resolve, reject) => {
                  raffle.once("WinnerPicked", async () => {
                      console.log("Winner event has been fired!")

                      try {
                          const recentWinner = await raffle.getRecentWinner()
                          const raffleState = await raffle.getRaffleState()
                          const winnerEndingBalance = await accounts[0].getBalance()
                          const endingTimeStamp = await raffle.getLastTimeStamp()

                          await expect(raffle.getPlayer(0)).to.be.reverted
                          assert.equal(recentWinner.toString(), accounts[0].address)
                          assert.equal(raffleState, 0)
                          assert.equal(
                              winnerEndingBalance.toString(),
                              winnerStartingBalance.add(raffleEntranceFee).toString()
                          )
                          assert(endingTimeStamp > startingTimeStamp)
                          resolve()
                      } catch (error) {
                          reject(error)
                          console.log(error)
                      }
                  })
              })
          })
      })
  })

I run it and got run time issue:

Raffle unit test
FulfillRandomWord
Entering Raffle...
Ok, time to wait...
1) works with live chainlink keepers and Chainlink VRF, we get a random winner

0 passing (5m)
1 failing

1. Raffle unit test
   FulfillRandomWord
   works with live chainlink keepers and Chainlink VRF, we get a random winner:
   Error: Timeout of 300000ms exceeded. For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves. (C:\Users\K\hh-fcc\hardhat-smartcontract-lottary-fcc\test\staging\Raffle.staging.js)
   at listOnTimeout (node:internal/timers:569:17)
   at processTimers (node:internal/timers:512:7)

[cryptocambi]

Thank alfaqi,
is actually working. I had to fix few things on VRF sub and automation.
Basically changing the order I made sure that trunk of the program get process before the promise. But it should not behave in the same way even without the change?

pls, is someone can explain me, I would really appreciate