LESSON 12: Unit Test Error - Constructor

[DorianDaSilva]

ERROR

  1) ManualToken Unit Test
       constructor
         Has correct initial supply of our token:

      AssertionError: expected '10000000000000000000000000' to equal '10000000'
      + expected - actual

      -10000000000000000000000000
      +10000000
      
      at Context.<anonymous> (test/ManualToken-unit.test.js:23:20)

So far 3 out of 4 pass - test breaks when checking for initialSupply

• Script seems correct, can't figure out what the issue is with it.

=================================================================================

Below are the scripts:

UNIT TEST

describe("ManualToken Unit Test", function () {
    const multiplier = 10 ** 18 //Set proper decimals (18)
    let token, deployer, user
    beforeEach(async function () {
        const accounts = await getNamedAccounts()
        deployer = accounts.deployer
        user = accounts.user
        await deployments.fixture("all")
        token = await ethers.getContract("ManualToken", deployer)
    })

    it("Token deployed!!!", async function () {
        assert(token.address)
    })

    describe("constructor", async function () {
        it("Has correct initial supply of our token", async function () {
            const totalSupply = await token.totalSupply()
            assert.equal(totalSupply.toString(), INITIAL_SUPPLY)
        })
}

MANUALTOKEN CONTRACT

    //public variables
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    uint256 public totalSupply;

    constructor(
    uint256 initialSupply,
    string memory tokenName,
    string memory tokenSymbol
    ) {
        totalSupply = initialSupply * 10**uint256(decimals); //total supply w/decimals
        balanceOf[msg.sender] = totalSupply; //all tokens to owner
        name = tokenName;
        symbol = tokenSymbol;
    }

HELPER

const INITIAL_SUPPLY = "10000000"

===================================================================================

Thank you!

[krakxn]

The complete code for ManualToken-unit.test.js please

[DorianDaSilva]

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

interface tokenRecipient {
    function receiveApproval(
        address _from,
        uint256 _amount,
        address _token,
        bytes calldata _extraData
      ) external;
}

contract ManualToken {
    //public variables
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    uint256 public totalSupply;


    //array of balances
    mapping(address => uint256) public balanceOf;
    //Address mapping A allows address mapping B to use X amount of tokens
    mapping(address => mapping(address => uint256)) public allowance;

    //Events:
    //Blockchain event notifying clients of transfer
    event Transfer(address indexed from, address indexed to, uint256 value);

    //Blockchain event notifying clients of approval
    event Approval(
        address indexed _owner,
        address indexed _spender,
        uint256 _amount
    );

    //Blockchain event notifying clients of amount burned
    event Burn(address indexed from, uint256 amount);

    //Initializes contract - initial supply token to the creator
    constructor(
    uint256 initialSupply,
    string memory tokenName,
    string memory tokenSymbol
    ) {
        totalSupply = initialSupply; //total supply w/decimals
        balanceOf[msg.sender] = totalSupply; //all tokens to owner
        name = tokenName;
        symbol = tokenSymbol;
    }

    //internal transfers can only be called by this contract
    function tokenTransfer(address _from, address _to, uint256 _amount) internal {
        require(_to != address(0x0), "Error: Transfer to genesis account"); //Genesis address - Use burn() instead
        require(balanceOf[_from] >= _amount); // Does sender have enough
        require(balanceOf[_to] + _amount >= balanceOf[_to]); // Check for overflow

        uint256 previousBalances = balanceOf[_from] + balanceOf[_to]; //use for assertion at the end of block

        balanceOf[_from] = balanceOf[_from] - _amount; //substract from sender
        balanceOf[_to] += _amount; //add to recipient

        emit Transfer(_from, _to, _amount); //emit transaction

        assert(balanceOf[_from] + balanceOf[_to] == previousBalances); //should never fail

    }

    //transfer tokens - send amount of tokens from owner account to recipient's account
    function transfer(address _to, uint256 _amount) public returns (bool success) {
        tokenTransfer(msg.sender, _to , _amount);
        return true;
    }

    //transfer from a different address than owner
    function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
        require(_amount <= allowance[_from][msg.sender]); // Check allowance
        allowance[_from][msg.sender] -= _amount; //subtract from sender balance
        tokenTransfer(_from, _to, _amount);
        return true;
    }

    //Set allowance for spender(authorized address) <= amount
    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowance[msg.sender][_spender] = _amount;
        emit Approval(msg.sender, _spender, _amount); //Emits approval event
        return true;
    }

    //Set allowance for spender(authorized address) <= amount + Notify
    function approveAndCall(
        address _spender,
        uint256 _amount,
        bytes memory _extraData
       ) public returns (bool success) {
        tokenRecipient spender= tokenRecipient(_spender);
        if (approve(_spender, _amount)) {
            spender.receiveApproval(msg.sender, _amount, address(this), _extraData);
            return true;
        }
    }

    //burn token
    function burn(uint256 _amount) public returns (bool success){
        require (balanceOf[msg.sender] >= _amount);
        balanceOf[msg.sender] -= _amount;
        totalSupply -= _amount;
        emit Burn(msg.sender, _amount);
        return true;
    }

    function burnFrom(address _from, uint256 _amount) public returns (bool success) {
        require(balanceOf[_from] >= _amount); // Does sender have enough
        require(_amount <= allowance[_from][msg.sender]); // Check allowance
        balanceOf[_from] = balanceOf[_from] - _amount; //substract from sender
        allowance[_from][msg.sender] -= _amount; //subtract from sender allowance
        totalSupply -= _amount; //Update totalSupply
        emit Burn(_from, _amount); //Emit burn event
        return true;
    }

}

Here is the script so far - "transfers" tests are failing as well, will post it in new discussion

[RoboCrypter]

@DorianDaSilva : your INITIAL_SUPPLY should be in WEI.

Convert your INITIAL_SUPPLY into WEI means : "10000000" Tokens = "10000000000000000000000000" WEI Tokens

Because you have a function decimals() with 18 decimal places,

So, it means your : INITIAL_SUPPLY + 18 - zero's = "10000000000000000000000000".

Just change your INITIAL_SUPPLY from "10000000" to "10000000000000000000000000" in your HELPER

Your Tokens supply will still be "10000000" when you deploy the contract.

Hopefully it will resolve the issue!

[DorianDaSilva]

@abossofmyself Thanks for the input. When i tried this yesterday it still returned the number in Helper file it still returned the same error as it still adds the decimals on top of it.

[RoboCrypter]

@DorianDaSilva : So it just keeps adding 18 - zero's on top of whatever INITIAL_SUPPLY you are putting... I have to check your token contract.

The problem probably lies there!

If you can send me your repo link, I can check it out!

[adityabhattad2021]

Try this

  describe("constructor", async function () {
        it("Has correct initial supply of our token", async function () {
            const totalSupply = await token.totalSupply()			
            assert.equal(totalSupply.toString(),parseInt(INITIAL_SUPPLY) *multiplier)
        })

As is constructor you did set the decimal places to 10**18 here:

totalSupply = initialSupply * 10**uint256(decimals); //total supply w/decimals

[DorianDaSilva]

@adityabhattad2021 Thank you for the input. I tried your method however I still get the error.

The way I got around it was to modify constructor as below:

    constructor(
    uint256 initialSupply,
    string memory tokenName,
    string memory tokenSymbol
    ) {
        totalSupply = initialSupply; //total supply w/decimals <==
        balanceOf[msg.sender] = totalSupply; //all tokens to owner
        name = tokenName;
        symbol = tokenSymbol;
    }

The logic behind it is that the token being minted are not ETH but rather a custom token that I set to 10 million max supply.
I know it still doesn't fix the issue of the decimals but test is passing.

[adityabhattad2021]

So is your problem solved?

[DorianDaSilva]

@adityabhattad2021 Not exactly...but for now it is not presenting an issue.

I am currently struggling with this #1997