How do you check if a contract has a function using Ethers.js?

Question

I want to be able to check using JavaScript/TypeScript & Ethers.js if a contract has a certain function.

I want to do this so that if the contract's function doesn't exist, I want to call another.

I want to do something along the lines of this:

if (contract.functionA) {
  // Other code logic before call
  contract.functionA()
} else {
  // Other code logic before call
  contract.functionB();
}

Answer 1

While other answers are correct, I think they can be improved as they only check for inclusion of a specific function selector in the bytecode which is not the same as checking if the jump table allows execution given that specific function selector.

For example, the following contract would trigger a false positive if you were to check for the function selector of functionA() : 9febadf2 :

pragma solidity ^0.8.4;
contract FalsePositive {
function randomFunction() public view {
  bytes4 data = 0x9febadf2;
}

}

To check for execution, and therefore a relevant entry in the jump table, it might be better to rely on the free gas estimation functions which technically includes the check of other answers and more since it will trigger a (free) execution:

EDIT: Modified the code to account for the other answers (checking the inclusion of the function selector in the bytecode) and added "undecidability" check if a fallback function is defined.

const { ethers } = require("ethers");
const ADDRESS = "THE-CONTRACT-ADDRESS";
const ENDPOINT = "THE-ENDPOINT-ADDRESS";
const ABI = ["function functionA()"];
const provider = new ethers.providers.getDefaultProvider(ENDPOINT);
async function main() {
  const bytecode = await provider.getCode(ADDRESS);
// No code : "0x" then functionA is definitely not there
  if (bytecode.length <= 2) {
    console.log("No functionA() : no code");
    return;
  }
// If the bytecode doesn't include the function selector functionA()
  // is definitely not present
  if (!bytecode.includes(ethers.utils.id("functionA()").slice(2, 10))) {
    console.log("No functionA() : no function selector in bytecode");
    return;
  }
const contract = new ethers.Contract(ADDRESS, ABI, provider);
// Check if a fallback function is defined : if it is, we cannot answer
  try {
    await provider.estimateGas({ to: ADDRESS });
    console.log(
      "Fallback is present : unable to decide if functionA() is present or not"
    );
    return;
  } catch {}
// If gas estimation doesn't revert then an execution is possible
  // given the provided function selector
  try {
    await contract.estimateGas.functionA();
    console.log("functionA() potentially included");
  } catch {
    // Otherwise (revert) we assume that there is no entry in the jump table
    // meaning that the contract doesn't include functionA()
    console.log("No functionA() : reverted");
  }
}
main();

Which doesn't trigger a false positive on the previous example. All the previously presented version do have a flaw that cannot be avoided anyway. If you were unlucky, those approaches would be fooled by a function selector collision.

Take the following function : functionA12735121() which happen to also have a function selector of 0x9febadf2, all the approaches mentioned would be fooled and return a false positive. The one that I am presenting, however, would catch a revert in the event of a function selector collision with different parameters, since the mismatching call data length would trigger a revert inside the smart contract.

There is also a possibility of a false negative, in case functionA() does exist, but reverts for some reasons... It could be improved by verifying the revert reason though.

Answer 2

If you do not have an ABI you can do the following flaky check

• Get the contract bytecode using web3.eth.getCode()

• Check if the bytecode contains 32-bit Solidity function selector

Note that contracts can always fake their interfaces or methods they support, so this check is only guidelining.

Answer 3

First thing, you'd want to fetch the smart contract's deployed bytecode as follows:

const provider = new ethers.providers.InfuraProvider(NETWORK, INFURA_API_KEY);
const bytecode = await provider.getCode(CONTRACT_ADDRESS);

Next, you'll need to compute the method selector of the function signature you're looking for and check if it exists as follows:

// In the following line, you could either provide a complete smart contract
// ABI that is imported from a JSON file; or you could just define it for
// the single function signature that you're searching for.
const abi = ["function methodName(methodType1,methodType2,...)"];
const iface = new ethers.utils.Interface(abi);
const method_selector = iface.getSighash("methodName(methodType1,methodType2,...)").substring(2);
const signer = new ethers.Wallet(ETH_PRIVATE_KEY, provider);
const contract = new ethers.Contract(CONTRACT_ADDRESS, abi, signer);
if(bytecode.includes(method_selector)) {
   /// logic when contract contains the function:
   /// call the method with provided values
   await contract.methodName(value1, value2, ...);
} else {
   /// logic when contract doesn't contain the function
   ...
}

Answer 4

I have written some simple scripts that may be helpful for working with Ethereum-based smart contracts and have made them into an npm module.

npm i @sigridjin/contract-validator

It has the following features:

1. Check if the given contract address exists on the network
2. Check if the given method signature can be called on the contract
3. Verify that the given ABI belongs to the contract

None of these are supported by web3.js or ethers.js...

https://github.com/sigridjineth/contract-validation

Answer 5

If you have the abi you can create an interface which is a object that contains all the contract functions:

const iface = new ethers.utils.Interface(contract.abi)