TypeError: gasUsed.mul is not a function

[SamarthBagga]

Getting this error cannot find a solution. This is while writing tests thsi is the code for the test file -

const { deployments, ethers, getNamedAccounts } = require("hardhat")
const { assert, expect } = require("chai")
describe("FundMe", async function () {
    let fundMe
    let deployer
    let mockV3Aggregator
    const sendValue = ethers.parseEther("1")
    beforeEach(async function () {
        // const accounts = await ethers.getSigners()
        // const accountZero = accounts[0]
        deployer = (await getNamedAccounts()).deployer
        await deployments.fixture(["all"])
        fundMe = await ethers.getContract("FundMe", deployer)
        mockV3Aggregator = await ethers.getContract(
            "MockV3Aggregator",
            deployer
        )
    })
    describe("constructor", async function () {
        it("sets the aggregator addresses correctly", async function () {
            const response = await fundMe.getPriceFeed()
            assert.equal(response, await mockV3Aggregator.getAddress())
        })
    })

    describe("fund", async function () {
        it("Fails if you dont send enough ETH", async function () {
            await expect(fundMe.fund()).to.be.revertedWith(
                "You need to spend more ETH!"
            )
        })
        it("amount funded", async function () {
            await fundMe.fund({ value: sendValue })
            const response = await fundMe.getAddressToAmountFunded(deployer)
            assert.equal(response.toString(), sendValue.toString())
        })
        it("Adds funder to array of funders", async function () {
            await fundMe.fund({ value: sendValue })
            const funder = await fundMe.getFunder(0)
            assert.equal(funder, deployer)
        })
    })

    describe("withdraw", async function () {
        beforeEach(async function () {
            await fundMe.fund({ value: sendValue })
        })

        it("withdraw ETH from a single founder", async function () {
            //Arrange
            const startingFundMeBalance = await ethers.provider.getBalance(
                await fundMe.getAddress()
            )
            const startingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            //Act
            const transactionResponse = await fundMe.withdraw()
            const transactionReceipt = await transactionResponse.wait(1)
            const {gasUsed, effectiveGasPrice} = transactionReceipt
            const gasCost = gasUsed.mul(effectiveGasPrice)

            const endingFundMeBalance = await fundMe.provider.getBalance(
                await fundMe.getAddress()
            )
            const endingDeployerBalance = await fundMe.provider.getBalance(
                deployer
            )
            //gasCost
            //Assert
            assert.equal(endingFundMeBalance, 0)
            assert.equal(
                startingFundMeBalance.add(startingDeployerBalance),
                endingDeployerBalance.add(gasCost).toString()
            )
        })
    })
})

[alfaqi]

One of the biggest changes in v6 is that the BigNumber class has been replaced with the built-in ES2020 BigInt offered by modern JavaScript environments.
There is plenty of online documentation to get you started with JavaScript ES2020 BigInt. Keep in mind, just like BigNumber, a ES2020 BigInt can only operate on integers.
The FixedNumber class still exists for performing fixed-point maths.

According to Ethers Docs Big Numbers

means that you can't use those functions add, sub, mul and div and so on,
but you can use +, - and so on
I think that.

change this const gasCost = gasUsed.mul(effectiveGasPrice)
to this const gasCost = gasUsed * effectiveGasPrice

and also change this

startingFundMeBalance.add(startingDeployerBalance),
endingDeployerBalance.add(gasCost).toString()

to this

startingFundMeBalance + startingDeployerBalance,
endingDeployerBalance + gasCost

replace await fundMe.provider.getBalance by await ethers.provider.getBalance

by the way, there is issue with effectiveGasPrice

[SamarthBagga]

Hi @alfaqi I have made the changes you have mentioned but now there is a completely different error related to something about misxing BigInt and other types-

FundMe
    constructor
      ✓ sets the aggregator addresses correctly
    fund
      ✓ Fails if you dont send enough ETH
      ✓ amount funded
      ✓ Adds funder to array of funders
    withdraw

      1) withdraw ETH from a single founder

      2) allows us to withdraw with multiple funders
      ✓ Only allows the owner to withdraw


  5 passing (4s)
  2 failing

  1) FundMe
       withdraw
         withdraw ETH from a single founder:
     TypeError: Cannot mix BigInt and other types, use explicit conversions
      at Context.<anonymous> (test/unit/FundMe.test.js:61:37)
      at processTicksAndRejections (internal/process/task_queues.js:95:5)

  2) FundMe
       withdraw
         allows us to withdraw with multiple funders:
     TypeError: Cannot mix BigInt and other types, use explicit conversions
      at Context.<anonymous> (test/unit/FundMe.test.js:97:37)
      at processTicksAndRejections (internal/process/task_queues.js:95:5)



error Command failed with exit code 2.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

Here is the updated code-

const { deployments, ethers, getNamedAccounts } = require("hardhat")
const { assert, expect } = require("chai")
describe("FundMe", async function () {
    let fundMe
    let deployer
    let mockV3Aggregator
    const sendValue = ethers.parseEther("1")
    beforeEach(async function () {
        // const accounts = await ethers.getSigners()
        // const accountZero = accounts[0]
        deployer = (await getNamedAccounts()).deployer
        await deployments.fixture(["all"])
        fundMe = await ethers.getContract("FundMe", deployer)
        mockV3Aggregator = await ethers.getContract(
            "MockV3Aggregator",
            deployer
        )
    })
    describe("constructor", async function () {
        it("sets the aggregator addresses correctly", async function () {
            const response = await fundMe.getPriceFeed()
            assert.equal(response, await mockV3Aggregator.getAddress())
        })
    })

    describe("fund", async function () {
        it("Fails if you dont send enough ETH", async function () {
            await expect(fundMe.fund()).to.be.revertedWith(
                "You need to spend more ETH!"
            )
        })
        it("amount funded", async function () {
            await fundMe.fund({ value: sendValue })
            const response = await fundMe.getAddressToAmountFunded(deployer)
            assert.equal(response.toString(), sendValue.toString())
        })
        it("Adds funder to array of funders", async function () {
            await fundMe.fund({ value: sendValue })
            const funder = await fundMe.getFunder(0)
            assert.equal(funder, deployer)
        })
    })

    describe("withdraw", async function () {
        beforeEach(async function () {
            await fundMe.fund({ value: sendValue })
        })

        it("withdraw ETH from a single founder", async function () {
            //Arrange
            const startingFundMeBalance = await ethers.provider.getBalance(
                await fundMe.getAddress()
            )
            const startingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            //Act
            const transactionResponse = await fundMe.withdraw()
            const transactionReceipt = await transactionResponse.wait(1)
            const { gasUsed, effectiveGasPrice } = transactionReceipt
            const gasCost = gasUsed * (effectiveGasPrice)

            const endingFundMeBalance = await ethers.provider.getBalance(
                await fundMe.getAddress()
            )
            const endingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            //gasCost
            //Assert
            assert.equal(endingFundMeBalance, 0)
            assert.equal(
                startingFundMeBalance + (startingDeployerBalance),
                endingDeployerBalance + (gasCost)
            )
        })
        it("allows us to withdraw with multiple funders", async function () {
            const accounts = await ethers.getSigners()
            for (let i = 1; i < 6; i++) {
                const fundMeConnectedContract = await fundMe.connect(
                    accounts[i]
                )
                await fundMeConnectedContract.fund({ value: sendValue })
            }
            const startingFundMeBalance = await ethers.provider.getBalance(
                await fundMe.getAddress()
            )
            const startingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )

            //Act

            const transactionResponse = await fundMe.withdraw()
            const transactionReceipt = await transactionResponse.wait(1)
            const { gasUsed, effectiveGasPrice } = transactionReceipt
            const gasCost = gasUsed * (effectiveGasPrice)

            //Assert
            assert.equal(endingFundMeBalance, 0)
            assert.equal(
                startingFundMeBalance + (startingDeployerBalance),
                endingDeployerBalance + (gasCost)
            )

            //Make sure the funders are reset properly
            await expect(fundMe.funders(0)).to.be.reverted

            for (i = 1; i < 6; i++) {
                assert.equal(
                    await fundMe.addressToAmountFunded(accounts[i].address)
                )
            }
        })

        it("Only allows the owner to withdraw", async function (){
            const accounts = await ethers.getSigners()
            const attacker = accounts[1]
            const attackerConnectedContract = await fundMe.connect(attacker)
            await expect(attackerConnectedContract.withdraw()).to.be.reverted
        })
    })
})

[alfaqi]

Since the new version (ethersV6) contains many modifications, it is better to revert to the old version (ethersV5).
I apologize if I made you confused.
here full code with modifications
package.json

{
  "devDependencies": {
    "@nomicfoundation/hardhat-toolbox": "^2.0.2",
    "@nomicfoundation/hardhat-verify": "^1.0.2",
    "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers",
    "dotenv": "^16.3.1",
    "ethers": "^5.7.2",
    "hardhat": "^2.16.1",
    "hardhat-deploy": "^0.11.34"
  },
  "dependencies": {
    "@chainlink/contracts": "^0.6.1"
  }
}

FundMe.test.js

const { deployments, ethers, getNamedAccounts } = require("hardhat")
const { assert, expect } = require("chai")
describe("FundMe", async function () {
    let fundMe
    let deployer
    let mockV3Aggregator
    const sendValue = ethers.utils.parseEther("1")
    beforeEach(async function () {
        // const accounts = await ethers.getSigners()
        // const accountZero = accounts[0]
        deployer = (await getNamedAccounts()).deployer
        await deployments.fixture(["all"])
        fundMe = await ethers.getContract("FundMe", deployer)
        mockV3Aggregator = await ethers.getContract(
            "MockV3Aggregator",
            deployer
        )
    })
    describe("constructor", async function () {
        it("sets the aggregator addresses correctly", async function () {
            const response = await fundMe.getPriceFeed()
            assert.equal(response, await mockV3Aggregator.address)
        })
    })

    describe("fund", async function () {
        it("Fails if you dont send enough ETH", async function () {
            await expect(fundMe.fund()).to.be.revertedWith(
                "You need to spend more ETH!"
            )
        })
        it("amount funded", async function () {
            await fundMe.fund({ value: sendValue })
            const response = await fundMe.getAddressToAmountFunded(deployer)
            assert.equal(response.toString(), sendValue.toString())
        })
        it("Adds funder to array of funders", async function () {
            await fundMe.fund({ value: sendValue })
            const funder = await fundMe.getFunder(0)
            assert.equal(funder, deployer)
        })
    })

    describe("withdraw", async function () {
        beforeEach(async function () {
            await fundMe.fund({ value: sendValue })
        })

        it("withdraw ETH from a single founder", async function () {
            //Arrange
            const startingFundMeBalance = await ethers.provider.getBalance(
                await fundMe.address
            )
            const startingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            //Act
            const transactionResponse = await fundMe.withdraw()
            const transactionReceipt = await transactionResponse.wait(1)
            const { gasUsed, effectiveGasPrice } = transactionReceipt
            const gasCost = gasUsed.mul(effectiveGasPrice)

            const endingFundMeBalance = await ethers.provider.getBalance(
                await fundMe.address
            )
            const endingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            //gasCost
            //Assert
            assert.equal(endingFundMeBalance, 0)
            assert.equal(
                startingFundMeBalance.add(startingDeployerBalance).toString(),
                endingDeployerBalance.add(gasCost).toString()
            )
        })
        it("allows us to withdraw with multiple funders", async function () {
            const accounts = await ethers.getSigners()
            for (let i = 1; i < 6; i++) {
                const fundMeConnectedContract = await fundMe.connect(
                    accounts[i]
                )
                await fundMeConnectedContract.fund({ value: sendValue })
            }
            const startingFundMeBalance = await ethers.provider.getBalance(
                await fundMe.address
            )
            const startingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )

            //Act

            const transactionResponse = await fundMe.withdraw()
            const transactionReceipt = await transactionResponse.wait(1)
            const { gasUsed, effectiveGasPrice } = transactionReceipt
            const gasCost = gasUsed.mul(effectiveGasPrice)

            // console.log(transactionReceipt)
            const endingFundMeBalance = await ethers.provider.getBalance(
                await fundMe.address
            )
            const endingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )

            //Assert
            assert.equal(
                startingFundMeBalance.add(startingDeployerBalance).toString(),
                endingDeployerBalance.add(gasCost).toString()
            )
            //Make sure the funders are reset properly
            await expect(fundMe.funders(0)).to.be.reverted

            for (i = 1; i < 6; i++) {
                assert.equal(
                    await fundMe.addressToAmountFunded(accounts[i].address),
                    0
                )
            }
        })

        it("Only allows the owner to withdraw", async function () {
            const accounts = await ethers.getSigners()
            const attacker = accounts[1]
            const attackerConnectedContract = await fundMe.connect(attacker)
            await expect(attackerConnectedContract.withdraw()).to.be.reverted
        })
    })
})

I hope this helps

[maheepatel]

hey smarth, i also ran into same problem.

1. If you are using ethers latest version v6 then first do the changes according to what @alfaqi mentioned earlier (like change this const gasCost = gasUsed.mul(effectiveGasPrice)
   to this const gasCost = gasUsed * effectiveGasPrice

after making those changes. If you get an error like this

 5 passing (4s)
  2 failing

  1) FundMe
       withdraw
         withdraw ETH from a single founder:
     TypeError: Cannot mix BigInt and other types, use explicit conversions
      at Context.<anonymous> (test/unit/FundMe.test.js:61:37)
      at processTicksAndRejections (internal/process/task_queues.js:95:5)

  2) FundMe
       withdraw
         allows us to withdraw with multiple funders:
     TypeError: Cannot mix BigInt and other types, use explicit conversions
      at Context.<anonymous> (test/unit/FundMe.test.js:97:37)
      at processTicksAndRejections (internal/process/task_queues.js:95:5)



error Command failed with exit code 2.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

The issue is with effectiveGasPrice.
There is no variable called effectiveGasPrice in transactionReceipt may because they changed in ethers v6
Just refer this code
change
const { gasUsed, effectiveGasPrice } = transactionReceipt
const gasCost = gasUsed.mul(effectiveGasPrice)
to
const { gasUsed, gasPrice } = transactionReceipt
const gasCost = gasUsed * gasPrice

` describe("withdraw", async function () {
beforeEach(async function () {
await fundMe.fund({ value: sendValue })
})

    it("withdraw ETH from a single founder", async function () {
        //Arrange
        const startingFundMeBalance = await ethers.provider.getBalance(
            await fundMe.getAddress()
        )
        const startingDeployerBalance = await ethers.provider.getBalance(
            deployer
        )
        //Act
        const transactionResponse = await fundMe.withdraw()
        const transactionReceipt = await transactionResponse.wait(1)

        const { gasUsed, gasPrice } = transactionReceipt
        console.log(gasUsed)
        console.log(gasPrice)
        const gasCost = gasUsed * gasPrice

        const endingFundMeBalance = await ethers.provider.getBalance(
            await fundMe.getAddress()
        )
        const endingDeployerBalance = await ethers.provider.getBalance(
            deployer
        )
        //gasCost
        //Assert
        assert.equal(endingFundMeBalance, 0)
        assert.equal(
            startingFundMeBalance + startingDeployerBalance,
            endingDeployerBalance + gasCost
        )
    })
})`

this code worked for me.

[Okpainmo]

Thanks @maheepatel this works in 2024.

[wwwbaraccuda]

in my case, I change effectiveGasPrice into gasPrice
It seems in ether version 6.7.1, BigNumber math operation like add, mul, etc can't be used anymore.
Instead, I used basic math operator like +, -, /, *.

Here's my code :

it("withdraw ETH from a single founder", async function () {
            // Arrange
            const startingFundMeBalance = await ethers.provider.getBalance(
                fundMe.getAddress()
            )
            const startingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            // Act
            const transactionResponse = await fundMe.withdraw()
            const transactionReceipt = await transactionResponse.wait(1)
            const { gasUsed, gasPrice } = transactionReceipt
            const gasCost = gasUsed * gasPrice

            const endingFundMeBalance = await ethers.provider.getBalance(
                fundMe.getAddress()
            )
            const endingDeployerBalance = await ethers.provider.getBalance(
                deployer
            )
            // Assert
            assert.equal(endingFundMeBalance, 0)
            assert.equal(
                startingFundMeBalance + startingDeployerBalance,
                endingDeployerBalance + gasCost
            )

Hope it helps!