"ambiguous function description" error when contract has functions with same names

[tab00]

Ethers Version

6.7.0

Search Terms

No response

Describe the Problem

I added function burn(address account, uint256 amount) public onlyRole(BURNER_ROLE) to an ERC20 contract. It compiles successfully.

But after deployment and calling the function like this:
await contract.burn(signer2.address, 1)
this error appears:

ambiguous function description (i.e. matches "burn(uint256)", "burn(address,uint256)")

I would have expected that it would determine which function should be executed by checking the argument list of the call. i.e. the function signatures are different enough that there should have been no ambiguity.

Code Snippet

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.21 <0.9.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

contract TOKEN3874 is ERC20, ERC20Burnable, AccessControl {
    bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");

    constructor(address[] memory supplyOwners) ERC20("TOKEN3874", "TOKEN3874") {
        _mint(supplyOwners[0], 10 * 10 ** decimals());
        _mint(supplyOwners[1], 90 * 10 ** decimals());

        _grantRole(DEFAULT_ADMIN_ROLE, supplyOwners[0]);
        _grantRole(BURNER_ROLE, supplyOwners[0]);
    }

    function burn(
        address account,
        uint256 amount
    ) public onlyRole(BURNER_ROLE) {
        _burn(account, amount);
    }
}

Contract ABI

{
      "inputs": [
        {
          "internalType": "uint256",
          "name": "amount",
          "type": "uint256"
        }
      ],
      "name": "burn",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },
    {
      "inputs": [
        {
          "internalType": "address",
          "name": "account",
          "type": "address"
        },
        {
          "internalType": "uint256",
          "name": "amount",
          "type": "uint256"
        }
      ],
      "name": "burn",
      "outputs": [],
      "stateMutability": "nonpayable",
      "type": "function"
    },

Errors

No response

Environment

Hardhat

Environment (Other)

No response

[ricmoo]

It can’t know which you mean though, because the string of an address, looks like a normal hexadecimal value for a uint256. Ethers will never guess if the situation is ambiguous by its value.

But this is why v6 introduced the Typed API, you can use contract.burn(Typed.address(addr)) to hint to the Contract what the value is, which will then select the correct entry in the ABI.

Does that make sense?

[tab00]

the string of an address, looks like a normal hexadecimal value for a uint256

OK but couldn't the number of arguments determine which function to execute?

[ricmoo]

Constraining by the number of arguments is possible, but since a Contract method allows an overrides, it cannot tell whether you were calling burn(addr, amount) or burn(uint256, overrides). If you wish, you can pass empty overrides in to force it to choose based on argument count using burn(addr, amount, { }) (now there are 3 arguments, the only possibility is that the 2-parameter option was called with an overrides parameter).

In general, I think the Typed option ensures the most explicit constraint. But it is a matter of taste. You can also for it by using the signature contract["burn(address, uint)"](addr, amount) or by removing the alternate fragment from the ABI.

Does that make sense?

(I'm moving this to discussion ;))