How to detect if an Ethereum address is an ERC20 token contract?

Question

If I only get an Ethereum address from the input, is there a way to find out whether it matches the ERC20 token standard?

Answer 1

There are many possible ways to achieve this. One possible quick and dirty solution is to check if a ERC20 function exists on the contract address by calling the following:

eth.call({to:contractAddress, data:web3.sha3("balanceOf(address)")})

A non-ERC20 will return a 'null' 0x hex response whereas an ERC20 will give you a 32byte uint , in this case 0 but if you provide an address in the data then it will give you the actual token balance for that address.

This is not a guaranteed way of determining a contract is ERC20 since other contracts may expose the same function, however it is a quick and easy check. You could add additional calls on totalSupply() etc. for more confirmation.

Answer 2

ERC165 tackles this problem, but, unfortunately, most ERC20 implementations don't support it (as of Nov 2018, at least OpenZeppelin doesn't ). This means that you could try calling the supportsInterface function, but it would revert anyway and you'd rather complicate things.

Nevertheless, here's how it's defined in ERC721 :

bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
/*
 * 0x80ac58cd ===
 *   bytes4(keccak256('balanceOf(address)')) ^
 *   bytes4(keccak256('ownerOf(uint256)')) ^
 *   bytes4(keccak256('approve(address,uint256)')) ^
 *   bytes4(keccak256('getApproved(uint256)')) ^
 *   bytes4(keccak256('setApprovalForAll(address,bool)')) ^
 *   bytes4(keccak256('isApprovedForAll(address,address)')) ^
 *   bytes4(keccak256('transferFrom(address,address,uint256)')) ^
 *   bytes4(keccak256('safeTransferFrom(address,address,uint256)')) ^
 *   bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
 */

Although it's not guaranteed for all implementations to define the interface id, there's a higher chance it will work in the case of ERC721, given the fact the community agreed on applying ERC165 right from the get-go. If the return value of the query below is true, then it means you have a compliant contract, otherwise just revert the transaction.

// you can call this in your contracts
IERC721(contractAddress).supportsInterface(0x80ac58cd)

Also, a useful resource for manually checking the bytes4 of a given method is 4byte.directory

Answer 3

If you are asking about off-chain, so use these functions:

getContract(url, smartContractAddress){
    const Web3Eth = require('web3-eth');

    const abi_ = this.getABI();
    const web3Eth = new Web3Eth(Web3Eth.givenProvider || url);
    return new web3Eth.Contract(abi_, smartContractAddress);
}

async getERCtype(contract){
    const is721 = await contract.methods.supportsInterface('0x80ac58cd').call();
    if(is721){
        return "ERC721";
    }
    const is1155 = await contract.methods.supportsInterface('0xd9b67a26').call();
    if(is1155){
        return "ERC1155";
    }
    return undefined;
}

getABI(){
    return [         
        {"constant":true,"inputs": [
                {"internalType":"bytes4","name": "","type": "bytes4"}],
            "name": "supportsInterface",
            "outputs": [{"internalType":"bool","name": "","type": "bool"}],
            "payable": false,"stateMutability":"view","type": "function"}         
    ];
}

like this:

const contract = getContract(url, smartContractAddress);
const type = await getERCtype(contract);
console.log(type);

Answer 4

I am amazed by the answers that are provided. (I either do not know anything about Ethereum or I do not understand English at all)

the question states that given an Ethereum address, is this an Ethereum contract address or not?

First thing, you have to decide if this address is a contract address or an externally owned account address. How to find out if an Ethereum address is a contract

If it is a contract address, then you can only get the bytecode that is stored in the blockchain. Now you have to reverse engineer the bytecode to get the contract functions but this is almost impossible. There are some decompilers but they are not perfectly creating the contract code from the bytecode.

ERC165 just checks if the current contract signature supports the given interfaceId or not. Since you have only ethereum address, this will not help in this question.