Comparing ethers BigNumber does not work

bignumberchaiethers.jstesting

I'm testing the value of a BigNumber returned from a function call to a contract and its not working as expected.

I have this

const { BigNumber } = require('ethers');
...
const totalSupply = await token.totalSupply();
expect(totalSupply).to.equal(BigNumber.from("4"));

This test fails with this error:

AssertionError: expected BigNumber { value: "4" } to equal BigNumber { value: "4" }
      + expected - actual

But looking at the error message it appears the expected and actual are the same. Why does this test fail?

Best Answer

Try like this :

expect(totalSupply.eq(BigNumber.from("4")).to.equal(true);

This is because to.equal internally uses the strict equality check === which on Objects only returns true if the two references are pointing to the same object.

Alternatively, you could also use .deep.equal which checks for deep equality between Objects but not as strictly as ensuring that the references point to the same instance :

expect(totalSupply).to.deep.equal(ethers.BigNumber.from("4"))

I hope this answers your question.

Related Solutions

[Ethereum] How to use BigNumber values in Hardhat tests

The ethereum-waffle package does this very well.

To use it add this to your hardhat.config.ts:

import chai from "chai";
import { solidity } from "ethereum-waffle";

chai.use(solidity);

Then in your tests you can directly compare ethers.js BigNumber values:

expect(await token.balanceOf(wallet.address)).to.equal(993);

See ethereum-waffle docs for more details.

Properly use promises in loop contract calls when testing

I found an answer, I should've used Promise.all as the guy mention in the question here, i get the promise code snippet from here, thanks to @Mavcom.ETH for guiding me here

The difference between Promise.all and Await inside a for loop is that looping in execution time, it will stop and await until the call is done to continue the loop in contrast to the promise.all which does all the calls and wait for them asynchronously which can be faster if the order of the calls doesn't matter

        let signers: Wallet[] = [];
    
        //create 100 wallets
        for (let i = 0; i < 100; i++) {
          //create a new wallet
          let wallet = ethers.Wallet.createRandom().connect(ethers.provider);
          //can store as signer
          signers.push(wallet);
          //can store as address
          addressArray.push(wallet.address.toString());
        }
    
        const checkTheirNFT = () => {
          return Promise.all(
            signers.map(async fooSigner => {
              expect(await yourNFTContract.connect(fooSigner).balanceOf(fooSigner.address, 1)).to.be.equal(0);
              console.log(`fooWallet: ${fooSigner.address}`);
            })
          ).then(() => {
            console.log("done");
          });
        };
        await checkTheirNFT();

      });

Best Answer

Related Solutions

[Ethereum] How to use BigNumber values in Hardhat tests

Properly use promises in loop contract calls when testing

Related Topic