Lesson 7: Why is converting BigNumber values to strings needed when comparing them?

[terrytjw]

The following code is provided for context:

import { assert, expect } from "chai";
import { deployments, ethers, getNamedAccounts } from "hardhat";
import { FundMe, MockV3Aggregator } from "../typechain-types";

// you wanna test the FundMe contract here
describe("FundMe", () => {
  let fundMeContract: FundMe,
    mockv3aggregator: MockV3Aggregator,
    deployer: string;
  let sendValue = ethers.utils.parseEther("1"); // same as 1000000000000000000gwei aka 1ETH

  beforeEach(async () => {
    deployer = (await getNamedAccounts()).deployer;

    // deploy fundme contract using hardhat-deploy
    // what fixture does is basically allowing us to run our entire deploy folder
    await deployments.fixture(["all"]);

    // gets the latest deployed instance of the FundMe contract and tells ether which account to connect to this FundMe contract instance
    fundMeContract = await ethers.getContract("FundMe", deployer);

    // deploy mockv3aggregator coz we're testing locally, no chainlink price feed
    mockv3aggregator = await ethers.getContract("MockV3Aggregator", deployer);
  });

  describe("constructor", () => {
    it("sets the correct aggregator address", async () => {
      const response = await fundMeContract.pricefeed();

      assert.equal(response, mockv3aggregator.address);
    });
  });

  describe("fund", () => {
    it("fails when not enough ETH is sent", async () => {
      await expect(fundMeContract.fund()).to.be.revertedWith(
        "You need to send more ETH!"
      );
    });

    it("list of funders is properly updated", async () => {
      await fundMeContract.fund({ value: sendValue });
      const response = await fundMeContract.addressToAmountFunded(deployer);
      assert.equal(response.toString(), sendValue.toString());
    });
  });
});

When comparing BigNumber values, why do we need to use the toString() before the comparison (see code fragment below)?

assert.equal(response.toString(), sendValue.toString());

The test fails when I do:

assert.equal(response, sendValue);

[krakxn]

From docs:

utils . parseEther ( etherString ) => BigNumber
Parse the etherString representation of ether into a BigNumber instance of the amount of wei

Keyword here, representation of ether into a BigNumber instance -- BigNumbers are stored in a String form, and that is why we have to use type conversion to String for comparison.

Hope this answers your queries!

[terrytjw]

If BigNumbers are already in String form, why the need to convert?

[krakxn]

Try doing this:

assert.equal(response.toString(), sendValue);

I will correct myself: (quoting from Docs)

A BigNumber is an object which safely allows mathematical operations on numbers of any magnitude. Most operations which need to return a value will return a BigNumber and parameters which accept values will generally accept them.

[terrytjw]

BigNumber !== string. But I'm just wondering why we can't do BigNumber === BigNumber?

[krakxn]

You definitely can do BigNumber (object) === BigNumber (object).

(Context: JavaScript primitive data types -- Do a quick Google search if not accustomed)
But we cannot: BigInt (JS long) or Number (JS int) === BigNumber (object)

Also, if the above did not work -- the const response = await fundMeContract.addressToAmountFunded(deployer); is most likely stored in a BigInt (JS long) or Number (JS int) data type, and that is why we have to convert it to string (JS String) along with the BigNumber (object).

Hence, we ultimately convert both of them.

Note though, if the BigNumber was not stored as an object but instead like a string, converting response would have been enough.

[alymurtazamemon]

@t3reetan BigNumbers are larger in bits size than the numbers that JavaScript can handle. Due to that we can either convert it to string form and get the value or we can use BigNumber wrappers or there are npm packages that handle that.

Hope it clears your query.

[alymurtazamemon]

@t3reetan You can also search for BigInt Wrapper on MDN docs.