Getting lots of "missing revert data in call exception" errors on ethers@5.6.2 in several projects that use Hardhat and test revert strings

[cameel]

In Solidity we have an array of external projects that we build and test with latest compiler binary on every PR. Most of these projects use Hardhat and ethers.js. Today I have noticed failures in several of these tests. The errors are not identical but in 3 cases they look more or less like this:

Error: the string "expected error \"e/unknown-pricing-type\" but instead got \"missing revert data in call exception [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] (error={...}, data=\"0x\", code=CALL_EXCEPTION, version=providers/5.6.2)\"" was thrown, throw an Error :)

I managed to reproduce this outside of our CI and the problem disappears when I switch to ethers@5.6.1. I'm not sure if this is a bug in Ethers or incorrect usage on Hardhat's part. The bug reporting template suggests starting a discussion in that case so I'm posting here first.

Detailed info about failures

Here's the output from the 3 projects that fail this way:

• Gnosis Safe

  AssertionError: Expected transaction to be reverted with Transaction reverted without a reason, but other exception was thrown: Error: missing revert data in call exception [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] (error={"stackTrace":[{"type":0,"sourceReference":{"function":"<fallback>","contract":"GnosisSafeProxy","sourceName":"contracts/proxies/GnosisSafeProxy.sol","sourceContent":"// SPDX-License-Identifier: LGPL-3.0-only\npragma solidity >=0.0;\n\n/// @title IProxy - Helper interface to access masterCopy of the Proxy on-chain\n/// @author Richard Meissner - <richard@gnosis.io>\ninterface IProxy {\n    function masterCopy() external view returns (address);\n}\n\n/// @title GnosisSafeProxy - Generic proxy contract allows to execute all transactions applying the code of a master contract.\n/// @author Stefan George - <stefan@gnosis.io>\n/// @author Richard Meissner - <richard@gnosis.io>\ncontract GnosisSafeProxy {\n    // singleton always needs to be first declared variable, to ensure that it is at the same location in the contracts to which calls are delegated.\n    // To reduce deployment costs this variable is internal and needs to be retrieved via `getStorageAt`\n    address internal singleton;\n\n    /// @dev Constructor function sets address of singleton contract.\n    /// @param _singleton Singleton address.\n    constructor(address _singleton) {\n        require(_singleton != address(0), \"Invalid singleton address provided\");\n        singleton = _singleton;\n    }\n\n    /// @dev Fallback function forwards all transactions and returns all received return data.\n    fallback() external payable {\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            let _singleton := and(sload(0), 0xffffffffffffffffffffffffffffffffffffffff)\n            // 0xa619486e == keccak(\"masterCopy()\"). The value is right padded to 32-bytes with 0s\n            if eq(calldataload(0), 0xa619486e00000000000000000000000000000000000000000000000000000000) {\n                mstore(0, _singleton)\n                return(0, 0x20)\n            }\n            calldatacopy(0, 0, calldatasize())\n            let success := delegatecall(gas(), _singleton, 0, calldatasize(), 0, 0)\n            returndatacopy(0, 0, returndatasize())\n            if eq(success, 0) {\n                revert(0, returndatasize())\n            }\n            return(0, returndatasize())\n        }\n    }\n}\n","line":28,"range":[1284,1992]},"functionType":2},{"type":4,"sourceReference":{"sourceName":"contracts/GnosisSafe.sol","sourceContent":"// SPDX-License-Identifier: LGPL-3.0-only\npragma solidity >=0.0;\n\nimport \"./base/ModuleManager.sol\";\nimport \"./base/OwnerManager.sol\";\nimport \"./base/FallbackManager.sol\";\nimport \"./base/GuardManager.sol\";\nimport \"./common/EtherPaymentFallback.sol\";\nimport \"./common/Singleton.sol\";\nimport \"./common/SignatureDecoder.sol\";\nimport \"./common/SecuredTokenTransfer.sol\";\nimport \"./common/StorageAccessible.sol\";\nimport \"./interfaces/ISignatureValidator.sol\";\nimport \"./external/GnosisSafeMath.sol\";\n\n/// @title Gnosis Safe - A multisignature wallet with support for confirmations using signed messages based on ERC191.\n/// @author Stefan George - <stefan@gnosis.io>\n/// @author Richard Meissner - <richard@gnosis.io>\ncontract GnosisSafe is\n    EtherPaymentFallback,\n    Singleton,\n    ModuleManager,\n    OwnerManager,\n    SignatureDecoder,\n    SecuredTokenTransfer,\n    ISignatureValidatorConstants,\n    FallbackManager,\n    StorageAccessible,\n    GuardManager\n{\n    using GnosisSafeMath for uint256;\n\n    string public constant VERSION = \"1.3.0\";\n\n    // keccak256(\n    //     \"EIP712Domain(uint256 chainId,address verifyingContract)\"\n    // );\n    bytes32 private constant DOMAIN_SEPARATOR_TYPEHASH = 0x47e79534a245952e8b16893a336b85a3d9ea9fa8c573f3d803afb92a79469218;\n\n    // keccak256(\n    //     \"SafeTx(address to,uint256 value,bytes data,uint8 operation,uint256 safeTxGas,uint256 baseGas,uint256 gasPrice,address gasToken,address refundReceiver,uint256 nonce)\"\n    // );\n    bytes32 private constant SAFE_TX_TYPEHASH = 0xbb8310d486368db6bd6f849402fdd73ad53d316b5a4b2644ad6efe0f941286d8;\n\n    event SafeSetup(address indexed initiator, address[] owners, uint256 threshold, address initializer, address fallbackHandler);\n    event ApproveHash(bytes32 indexed approvedHash, address indexed owner);\n    event SignMsg(bytes32 indexed msgHash);\n    event ExecutionFailure(bytes32 txHash, uint256 payment);\n    event ExecutionSuccess(bytes32 txHash, uint256 payment);\n\n    uint256 public nonce;\n    bytes32 private _deprecatedDomainSeparator;\n    // Mapping to keep track of all message hashes that have been approved by ALL REQUIRED owners\n    mapping(bytes32 => uint256) public signedMessages;\n    // Mapping to keep track of all hashes (message or transaction) that have been approved by ANY owners\n    mapping(address => mapping(bytes32 => uint256)) public approvedHashes;\n\n    // This constructor ensures that this contract can only be used as a master copy for Proxy contracts\n    constructor() {\n        // By setting the threshold it is not possible to call setup anymore,\n        // so we create a Safe with 0 owners and threshold 1.\n        // This is an unusable Safe, perfect for the singleton\n        threshold = 1;\n    }\n\n    /// @dev Setup function sets initial storage of contract.\n    /// @param _owners List of Safe owners.\n    /// @param _threshold Number of required confirmations for a Safe transaction.\n    /// @param to Contract address for optional delegate call.\n    /// @param data Data payload for optional delegate call.\n    /// @param fallbackHandler Handler for fallback calls to this contract\n    /// @param paymentToken Token that should be used for the payment (0 is ETH)\n    /// @param payment Value that should be paid\n    /// @param paymentReceiver Address that should receive the payment (or 0 if tx.origin)\n    function setup(\n        address[] calldata _owners,\n        uint256 _threshold,\n        address to,\n        bytes calldata data,\n        address fallbackHandler,\n        address paymentToken,\n        uint256 payment,\n        address payable paymentReceiver\n    ) external {\n        // setupOwners checks if the Threshold is already set, therefore preventing that this method is called twice\n        setupOwners(_owners, _threshold);\n        if (fallbackHandler != address(0)) internalSetFallbackHandler(fallbackHandler);\n        // As setupOwners can only be called if the contract has not been initialized we don't need a check for setupModules\n        setupModules(to, data);\n\n        if (payment > 0) {\n            // To avoid running into issues with EIP-170 we reuse the handlePayment function (to avoid adjusting code of that has been verified we do not adjust the method itself)\n            // baseGas = 0, gasPrice = 1 and gas = payment => amount = (payment + 0) * 1 = payment\n            handlePayment(payment, 0, 1, paymentToken, paymentReceiver);\n        }\n        emit SafeSetup(msg.sender, _owners, _threshold, to, fallbackHandler);\n    }\n\n    /// @dev Allows to execute a Safe transaction confirmed by required number of owners and then pays the account that submitted the transaction.\n    ///      Note: The fees are always transferred, even if the user transaction fails.\n    /// @param to Destination address of Safe transaction.\n    /// @param value Ether value of Safe transaction.\n    /// @param data Data payload of Safe transaction.\n    /// @param operation Operation type of Safe transaction.\n    /// @param safeTxGas Gas that should be used for the Safe transaction.\n    /// @param baseGas Gas costs that are independent of the transaction execution(e.g. base transaction fee, signature check, payment of the refund)\n    /// @param gasPrice Gas price that should be used for the payment calculation.\n    /// @param gasToken Token address (or 0 if ETH) that is used for the payment.\n    /// @param refundReceiver Address of receiver of gas payment (or 0 if tx.origin).\n    /// @param signatures Packed signature data ({bytes32 r}{bytes32 s}{uint8 v})\n    function execTransaction(\n        address to,\n        uint256 value,\n        bytes calldata data,\n        Enum.Operation operation,\n        uint256 safeTxGas,\n        uint256 baseGas,\n        uint256 gasPrice,\n        address gasToken,\n        address payable refundReceiver,\n        bytes memory signatures\n    ) public payable virtual returns (bool success) {\n        bytes32 txHash;\n        // Use scope here to limit variable lifetime and prevent `stack too deep` errors\n        {\n            bytes memory txHashData =\n                encodeTransactionData(\n                    // Transaction info\n                    to,\n                    value,\n                    data,\n                    operation,\n                    safeTxGas,\n                    // Payment info\n                    baseGas,\n                    gasPrice,\n                    gasToken,\n                    refundReceiver,\n                    // Signature info\n                    nonce\n                );\n            // Increase nonce and execute transaction.\n            nonce++;\n            txHash = keccak256(txHashData);\n            checkSignatures(txHash, txHashData, signatures);\n        }\n        address guard = getGuard();\n        {\n            if (guard != address(0)) {\n                Guard(guard).checkTransaction(\n                    // Transaction info\n                    to,\n                    value,\n                    data,\n                    operation,\n                    safeTxGas,\n                    // Payment info\n                    baseGas,\n                    gasPrice,\n                    gasToken,\n                    refundReceiver,\n                    // Signature info\n                    signatures,\n                    msg.sender\n                );\n            }\n        }\n        // We require some gas to emit the events (at least 2500) after the execution and some to perform code until the execution (500)\n        // We also include the 1/64 in the check that is not send along with a call to counteract potential shortings because of EIP-150\n        require(gasleft() >= ((safeTxGas * 64) / 63).max(safeTxGas + 2500) + 500, \"GS010\");\n        // Use scope here to limit variable lifetime and prevent `stack too deep` errors\n        {\n            uint256 gasUsed = gasleft();\n            // If the gasPrice is 0 we assume that nearly all available gas can be used (it is always more than safeTxGas)\n            // We only substract 2500 (compared to the 3000 before) to ensure that the amount passed is still higher than safeTxGas\n            success = execute(to, value, data, operation, gasPrice == 0 ? (gasleft() - 2500) : safeTxGas);\n            gasUsed = gasUsed.sub(gasleft());\n            // If no safeTxGas and no gasPrice was set (e.g. both are 0), then the internal tx is required to be successful\n            // This makes it possible to use `estimateGas` without issues, as it searches for the minimum gas where the tx doesn't revert\n            require(success || safeTxGas != 0 || gasPrice != 0, \"GS013\");\n            // We transfer the calculated tx costs to the tx.origin to avoid sending it to intermediate contracts that have made calls\n            uint256 payment = 0;\n            if (gasPrice > 0) {\n                payment = handlePayment(gasUsed, baseGas, gasPrice, gasToken, refundReceiver);\n            }\n            if (success) emit ExecutionSuccess(txHash, payment);\n            else emit ExecutionFailure(txHash, payment);\n        }\n        {\n            if (guard != address(0)) {\n                Guard(guard).checkAfterExecution(txHash, success);\n            }\n        }\n    }\n\n    function handlePayment(\n        uint256 gasUsed,\n        uint256 baseGas,\n        uint256 gasPrice,\n        address gasToken,\n        address payable refundReceiver\n    ) private returns (uint256 payment) {\n        // solhint-disable-next-line avoid-tx-origin\n        address payable receiver = refundReceiver == address(0) ? payable(tx.origin) : refundReceiver;\n        if (gasToken == address(0)) {\n            // For ETH we will only adjust the gas price to not be higher than the actual used gas price\n            payment = gasUsed.add(baseGas).mul(gasPrice < tx.gasprice ? gasPrice : tx.gasprice);\n            require(receiver.send(payment), \"GS011\");\n        } else {\n            payment = gasUsed.add(baseGas).mul(gasPrice);\n            require(transferToken(gasToken, receiver, payment), \"GS012\");\n        }\n    }\n\n    /**\n     * @dev Checks whether the signature provided is valid for the provided data, hash. Will revert otherwise.\n     * @param dataHash Hash of the data (could be either a message hash or transaction hash)\n     * @param data That should be signed (this is passed to an external validator contract)\n     * @param signatures Signature data that should be verified. Can be ECDSA signature, contract signature (EIP-1271) or approved hash.\n     */\n    function checkSignatures(\n        bytes32 dataHash,\n        bytes memory data,\n        bytes memory signatures\n    ) public view {\n        // Load threshold to avoid multiple storage loads\n        uint256 _threshold = threshold;\n        // Check that a threshold is set\n        require(_threshold > 0, \"GS001\");\n        checkNSignatures(dataHash, data, signatures, _threshold);\n    }\n\n    /**\n     * @dev Checks whether the signature provided is valid for the provided data, hash. Will revert otherwise.\n     * @param dataHash Hash of the data (could be either a message hash or transaction hash)\n     * @param data That should be signed (this is passed to an external validator contract)\n     * @param signatures Signature data that should be verified. Can be ECDSA signature, contract signature (EIP-1271) or approved hash.\n     * @param requiredSignatures Amount of required valid signatures.\n     */\n    function checkNSignatures(\n        bytes32 dataHash,\n        bytes memory data,\n        bytes memory signatures,\n        uint256 requiredSignatures\n    ) public view {\n        // Check that the provided signature data is not too short\n        require(signatures.length >= requiredSignatures.mul(65), \"GS020\");\n        // There cannot be an owner with address 0.\n        address lastOwner = address(0);\n        address currentOwner;\n        uint8 v;\n        bytes32 r;\n        bytes32 s;\n        uint256 i;\n        for (i = 0; i < requiredSignatures; i++) {\n            (v, r, s) = signatureSplit(signatures, i);\n            if (v == 0) {\n                // If v is 0 then it is a contract signature\n                // When handling contract signatures the address of the contract is encoded into r\n                currentOwner = address(uint160(uint256(r)));\n\n                // Check that signature data pointer (s) is not pointing inside the static part of the signatures bytes\n                // This check is not completely accurate, since it is possible that more signatures than the threshold are send.\n                // Here we only check that the pointer is not pointing inside the part that is being processed\n                require(uint256(s) >= requiredSignatures.mul(65), \"GS021\");\n\n                // Check that signature data pointer (s) is in bounds (points to the length of data -> 32 bytes)\n                require(uint256(s).add(32) <= signatures.length, \"GS022\");\n\n                // Check if the contract signature is in bounds: start of data is s + 32 and end is start + signature length\n                uint256 contractSignatureLen;\n                // solhint-disable-next-line no-inline-assembly\n                assembly {\n                    contractSignatureLen := mload(add(add(signatures, s), 0x20))\n                }\n                require(uint256(s).add(32).add(contractSignatureLen) <= signatures.length, \"GS023\");\n\n                // Check signature\n                bytes memory contractSignature;\n                // solhint-disable-next-line no-inline-assembly\n                assembly {\n                    // The signature data for contract signatures is appended to the concatenated signatures and the offset is stored in s\n                    contractSignature := add(add(signatures, s), 0x20)\n                }\n                require(ISignatureValidator(currentOwner).isValidSignature(data, contractSignature) == EIP1271_MAGIC_VALUE, \"GS024\");\n            } else if (v == 1) {\n                // If v is 1 then it is an approved hash\n                // When handling approved hashes the address of the approver is encoded into r\n                currentOwner = address(uint160(uint256(r)));\n                // Hashes are automatically approved by the sender of the message or when they have been pre-approved via a separate transaction\n                require(msg.sender == currentOwner || approvedHashes[currentOwner][dataHash] != 0, \"GS025\");\n            } else if (v > 30) {\n                // If v > 30 then default va (27,28) has been adjusted for eth_sign flow\n                // To support eth_sign and similar we adjust v and hash the messageHash with the Ethereum message prefix before applying ecrecover\n                currentOwner = ecrecover(keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", dataHash)), v - 4, r, s);\n            } else {\n                // Default is the ecrecover flow with the provided data hash\n                // Use ecrecover with the messageHash for EOA signatures\n                currentOwner = ecrecover(dataHash, v, r, s);\n            }\n            require(currentOwner > lastOwner && owners[currentOwner] != address(0) && currentOwner != SENTINEL_OWNERS, \"GS026\");\n            lastOwner = currentOwner;\n        }\n    }\n\n    /// @dev Allows to estimate a Safe transaction.\n    ///      This method is only meant for estimation purpose, therefore the call will always revert and encode the result in the revert data.\n    ///      Since the `estimateGas` function includes refunds, call this method to get an estimated of the costs that are deducted from the safe with `execTransaction`\n    /// @param to Destination address of Safe transaction.\n    /// @param value Ether value of Safe transaction.\n    /// @param data Data payload of Safe transaction.\n    /// @param operation Operation type of Safe transaction.\n    /// @return Estimate without refunds and overhead fees (base transaction and payload data gas costs).\n    /// @notice Deprecated in favor of common/StorageAccessible.sol and will be removed in next version.\n    function requiredTxGas(\n        address to,\n        uint256 value,\n        bytes calldata data,\n        Enum.Operation operation\n    ) external returns (uint256) {\n        uint256 startGas = gasleft();\n        // We don't provide an error message here, as we use it to return the estimate\n        require(execute(to, value, data, operation, gasleft()));\n        uint256 requiredGas = startGas - gasleft();\n        // Convert response to string and return via error message\n        revert(string(abi.encodePacked(requiredGas)));\n    }\n\n    /**\n     * @dev Marks a hash as approved. This can be used to validate a hash that is used by a signature.\n     * @param hashToApprove The hash that should be marked as approved for signatures that are verified by this contract.\n     */\n    function approveHash(bytes32 hashToApprove) external {\n        require(owners[msg.sender] != address(0), \"GS030\");\n        approvedHashes[msg.sender][hashToApprove] = 1;\n        emit ApproveHash(hashToApprove, msg.sender);\n    }\n\n    /// @dev Returns the chain id used by this contract.\n    function getChainId() public view returns (uint256) {\n        uint256 id;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            id := chainid()\n        }\n        return id;\n    }\n\n    function domainSeparator() public view returns (bytes32) {\n        return keccak256(abi.encode(DOMAIN_SEPARATOR_TYPEHASH, getChainId(), this));\n    }\n\n    /// @dev Returns the bytes that are hashed to be signed by owners.\n    /// @param to Destination address.\n    /// @param value Ether value.\n    /// @param data Data payload.\n    /// @param operation Operation type.\n    /// @param safeTxGas Gas that should be used for the safe transaction.\n    /// @param baseGas Gas costs for that are independent of the transaction execution(e.g. base transaction fee, signature check, payment of the refund)\n    /// @param gasPrice Maximum gas price that should be used for this transaction.\n    /// @param gasToken Token address (or 0 if ETH) that is used for the payment.\n    /// @param refundReceiver Address of receiver of gas payment (or 0 if tx.origin).\n    /// @param _nonce Transaction nonce.\n    /// @return Transaction hash bytes.\n    function encodeTransactionData(\n        address to,\n        uint256 value,\n        bytes calldata data,\n        Enum.Operation operation,\n        uint256 safeTxGas,\n        uint256 baseGas,\n        uint256 gasPrice,\n        address gasToken,\n        address refundReceiver,\n        uint256 _nonce\n    ) public view returns (bytes memory) {\n        bytes32 safeTxHash =\n            keccak256(\n                abi.encode(\n                    SAFE_TX_TYPEHASH,\n                    to,\n                    value,\n                    keccak256(data),\n                    operation,\n                    safeTxGas,\n                    baseGas,\n                    gasPrice,\n                    gasToken,\n                    refundReceiver,\n                    _nonce\n                )\n            );\n        return abi.encodePacked(bytes1(0x19), bytes1(0x01), domainSeparator(), safeTxHash);\n    }\n\n    /// @dev Returns hash to be signed by owners.\n    /// @param to Destination address.\n    /// @param value Ether value.\n    /// @param data Data payload.\n    /// @param operation Operation type.\n    /// @param safeTxGas Fas that should be used for the safe transaction.\n    /// @param baseGas Gas costs for data used to trigger the safe transaction.\n    /// @param gasPrice Maximum gas price that should be used for this transaction.\n    /// @param gasToken Token address (or 0 if ETH) that is used for the payment.\n    /// @param refundReceiver Address of receiver of gas payment (or 0 if tx.origin).\n    /// @param _nonce Transaction nonce.\n    /// @return Transaction hash.\n    function getTransactionHash(\n        address to,\n        uint256 value,\n        bytes calldata data,\n        Enum.Operation operation,\n        uint256 safeTxGas,\n        uint256 baseGas,\n        uint256 gasPrice,\n        address gasToken,\n        address refundReceiver,\n        uint256 _nonce\n    ) public view returns (bytes32) {\n        return keccak256(encodeTransactionData(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, _nonce));\n    }\n}\n","contract":"GnosisSafe","function":"requiredTxGas","line":315,"range":[15962,16495]},"message":{"value":{"type":"Buffer","data":[]}},"isInvalidOpcodeError":false}]}, data="0x", code=CALL_EXCEPTION, version=providers/5.6.2)
  

• Euler

  Error: the string "expected error \"e/liq/violator-not-entered-collateral\" but instead got \"missing revert data in call exception [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] (error={\"stackTrace\":[{\"type\":4,\"sourceReference\":{\"function\":\"<fallback>\",\"contract\":\"Proxy\",\"sourceName\":\"contracts/Proxy.sol\",\"sourceContent\":\"// SPDX-License-Identifier: GPL-2.0-or-later\\n\\npragma solidity >=0.0;\\n\\ncontract Proxy {\\n    address immutable creator;\\n\\n    constructor() {\\n        creator = msg.sender;\\n    }\\n\\n    // External interface\\n\\n    fallback() external {\\n        address creator_ = creator;\\n\\n        if (msg.sender == creator_) {\\n            assembly {\\n                mstore(0, 0)\\n                calldatacopy(31, 0, calldatasize())\\n\\n                switch mload(0) // numTopics\\n                    case 0 { log0(32,  sub(calldatasize(), 1)) }\\n                    case 1 { log1(64,  sub(calldatasize(), 33),  mload(32)) }\\n                    case 2 { log2(96,  sub(calldatasize(), 65),  mload(32), mload(64)) }\\n                    case 3 { log3(128, sub(calldatasize(), 97),  mload(32), mload(64), mload(96)) }\\n                    case 4 { log4(160, sub(calldatasize(), 129), mload(32), mload(64), mload(96), mload(128)) }\\n                    default { revert(0, 0) }\\n\\n                return(0, 0)\\n            }\\n        } else {\\n            assembly {\\n                mstore(0, 0xe9c4a3ac00000000000000000000000000000000000000000000000000000000) // dispatch() selector\\n                calldatacopy(4, 0, calldatasize())\\n                mstore(add(4, calldatasize()), shl(96, caller()))\\n\\n                let result := call(gas(), creator_, 0, 0, add(24, calldatasize()), 0, 0)\\n                returndatacopy(0, 0, returndatasize())\\n\\n                switch result\\n                    case 0 { revert(0, returndatasize()) }\\n                    default { return(0, returndatasize()) }\\n            }\\n        }\\n    }\\n}\\n\",\"line\":42,\"range\":[1466,1493]},\"message\":{\"value\":{\"type\":\"Buffer\",\"data\":[8,195,121,160,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,37,101,47,108,105,113,47,118,105,111,108,97,116,111,114,45,110,111,116,45,101,110,116,101,114,101,100,45,99,111,108,108,97,116,101,114,97,108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]},\"_selector\":\"08c379a0\"},\"isInvalidOpcodeError\":false}]}, data=\"0x\", code=CALL_EXCEPTION, version=providers/5.6.2)\"" was thrown, throw an Error :) 
  

• ENS

  AssertionError: Expected transaction to be reverted with readLabel: Index out of bounds, but other exception was thrown: Error: missing revert data in call exception [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] (error={"stackTrace":[{"type":0,"sourceReference":{"function":"readLabel","contract":"TestBytesUtils","sourceName":"contracts/wrapper/test/TestBytesUtils.sol","sourceContent":"import \"../BytesUtil.sol\";\n\ncontract TestBytesUtils {\n    using BytesUtils for *;\n\n    function readLabel(bytes calldata name, uint offset) public pure returns(bytes32, uint) {\n        return name.readLabel(offset);\n    }\n\n    function namehash(bytes calldata name, uint offset) public pure returns(bytes32) {\n        return name.namehash(offset);\n    }\n}\n","line":7,"range":[192,214]},"functionType":1},{"type":4,"sourceReference":{"sourceName":"contracts/wrapper/test/TestBytesUtils.sol","sourceContent":"import \"../BytesUtil.sol\";\n\ncontract TestBytesUtils {\n    using BytesUtils for *;\n\n    function readLabel(bytes calldata name, uint offset) public pure returns(bytes32, uint) {\n        return name.readLabel(offset);\n    }\n\n    function namehash(bytes calldata name, uint offset) public pure returns(bytes32) {\n        return name.namehash(offset);\n    }\n}\n","contract":"TestBytesUtils","function":"readLabel","line":6,"range":[87,221]},"message":{"value":{"type":"Buffer","data":[8,195,121,160,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,114,101,97,100,76,97,98,101,108,58,32,73,110,100,101,120,32,111,117,116,32,111,102,32,98,111,117,110,100,115,0,0]},"_selector":"08c379a0"},"isInvalidOpcodeError":false}]}, data="0x", code=CALL_EXCEPTION, version=providers/5.6.2)
  

There are 2 more that have completely different messages but started failing at the same time so the underlying cause could be the same:

• Uniswap v3

  AssertionError: Expected transaction to be reverted, but other exception was thrown: RangeError: Maximum call stack size exceeded
  

• Perpetual Pools

  AssertionError: Expected transaction to be reverted with PO: Out of bounds, but other exception was thrown: RangeError: Maximum call stack size exceeded
  

EDIT: I verified that downgrading ethers.js fixes breakage in these two as well.

How to reproduce

The error is easy to reproduce using Euler:

git clone https://github.com/euler-xyz/euler-contracts
cd euler-contracts/
npm install
npx hardhat test test/liquidation.js

[cameel]

Pinging @alcuadrado and @fvictorio.

[fvictorio]

I guess it would be useful to know what "missing revert data in call exception" means. That is, what does ethers expect to find in the exception. But my first guess is taht the latest version of ethers is not compatible with Hardhat's JSON-RPC responses.

[cameel]

As an extra data point, I found this discussion about a recent error with a similar message: #2603 (comment)

Might be related, though as I understand it, the problem there seems different - the expectation was for EXCEPTION_MESSAGE, which should never have been passed through to the user by Ethers?

[rubo]

Same here. Upgrading from v5.6.1 to v5.6.2 leads to this problem when using revertedWith. It was fine until I added a new argument to one of the function overloads. When I change the function name so it's no longer an overload, it works. Weird.

[ricmoo]

There was a bug prior to ethers 5.6.2 which would send out the wrong error (it emitted "UNPREDICTABLE_GAS_LIMIT" when it was actually a CALL_EXCEPTION, and in ethers CALL_EXCEPTION only occurs during call when the error is missing the data) when ethers could not parse the error response from the server.

The response for Hardhat was different than Geth/Parity, so things that worked in Geth/Parity (i.e. return the call result bytes, which if decoded using the Error(string) selector) would throw in Hardhat.

My goal is to make sure Geth, Parity, Hardhat, MM, etc. all work the same, so that tests written against one are indicative of behaviour across the others and that if you run your app against one backend and switch to another there are no surprises. Suffice to say, it is not easy because the specification really doesn't specify what happens in the case of errors and every backend is different.

I'm working with Patricio at Hardhat to get their errors including all the necessary data; currently in the case of Error(string) errors, it adds the human-readable string, but discards the machine-readable part, so he is adding that back in so that ethers can respond the same way Geth/Parity do.

I have a feeling the revertedWith will need to be modified too, since it was "working" before because:

1. ethers couldn't understand Hardhat errors and threw "something"
2. that "something" happen to have a string embedded deep within a JSON-ed payload that hardhat was grabbing

Ideally, everything stays in the machine-readable realm, so we don't have weird string matching and regular expressions which breaks every time a backend gets creative with their grammar [for example]. :)

[ricmoo]

@fvictorio @alcuadrado (tagging Patricio too, since he's working on it)

I guess it would be useful to know what "missing revert data in call exception" means. That is, what does ethers expect to find in the exception. But my first guess is taht the latest version of ethers is not compatible with Hardhat's JSON-RPC responses.

That's correct. When Geth/Parity throws, the message looks something like:

"jsonrpc": "2.0",
"id": 42,
"result": {
  "message": "execution reverted; maybe some extra weird human-readable stuff here; possibly even the decoded error: 'Hello World'",
  "data": "0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000b48656c6c6f20576f726c64000000000000000000000000000000000000000000"
  }
}

While currently Hardhat errors seem to look like:

{
  "jsonrpc": "2.0",
  "id": 117,
  "error": {
    "code": -32603,
    "message": "Error: VM Exception while processing transaction: reverted with reason string 'Hello World'"
  }
}

The important thing is the data isn't present, so there is no machine-readable information for ethers to process; this is what it means that the missing revert data, literally the data field and it gets lost. It used to bubble into a different part of the code and embed the raw error including the internal error, so my guess is there was some regex matching going on in Hardhat (maybe?) that was re-finding it. It may still be there, but now that regex won't work. But we want to avoid a world of regex anyways. :)

In v5.6.2 I added a spelunk function to help find the error; it searches for any machine readable component (including embedded in JSON; not within strings though) that contains:

1. a message property, which is a string and contains the word "reverted"
2. a data property which is a valid hexstring

This also solved a problem with some versions of MetaMask (which also had their own format), so I'm hoping this is both generic enough to find errors across the diverse collection of backends and also narrow enough not to misinterpret a value as a call exception.

[LorranSutter]

I have the exactly same problem. I thought it could be a problem of the repo solidstate that I am using. But looks like it is beyond that.

[fvictorio]

That makes sense, thanks a lot for the response.

We are going to add the data field, and we are also working on better chai matchers that will use that field instead of string-matching the error message.

[ricmoo]

No worries, let me know if there is anything I can help with. :)

[zemse]

Is this included in the latest release 2.9.3? (from the info it doesn't seem so but just confirming)

[fvictorio]

No, we haven't released this yet, sorry.

[PaulRBerg]

Another data point: checking for custom errors with revertedWith still works with ethers v5.6.2 and hardhat v2.9.3. It's only the panic codes (0x11, 0x12, etc.) that started to break after I upgraded my dependencies.

[sbauch]

Hoping this can be helpful to both projects' efforts here - I've got an OSS reproduction where I've bisected ethers versions to understand where I start seeing similar errors.

We're using EIP-3668 OffchainLookup errors in a public view func. We've found that while we do receive the custom OffchainError in tests, we cannot easily pull the params out, and apply a regex to the string to get the error params.

Using latest hardhat and hardhat-ethers, this works well with ethers@5.6.1 as seen on our main branch - https://github.com/0xEssential/PlaySession

When I upgrade ethers to 5.6.2, the error we catch is the same "missing revert data in call exception" reported here

Error: missing revert data in call exception [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] (error={"stackTrace":[{"type":0,"sourceReference":{"function":"preflight","contract":"EssentialForwarder","sourceName":"@0xessential/contracts/fwd/EssentialForwarder.sol"

0xEssential/PlaySession#2

Since we're using a regex against the error name, we still catch that error, but are not now able to pull the args off, and our tests start failing.

I'm not able to see any changes between 5.6.1 and 5.6.2 that would cause this, am happy to stay on 5.6.1 until resolved, but hopefully this helps y'all sort these things out!

[startswithaj]

I have the same issue - let me know if I can do anything to help diagnose.

[aelmanaa]

same issue. forced the version to remain 5.6.1 as a workaround. In package.json: "ethers": "5.6.1"

[Alexangelj]

Same issue - going back to ethers@5.6.1 fixed it for me.

[swtrse]

Same issue. However I hat to change

"devDependencies": {
    ...
    "ethers": "^5.0.0",
    ...
  },
  "resolutions": {
    "**/ethers": "^5.0.0"
  }

to

"devDependencies": {
    ...
    "ethers": "5.6.1",
    ...
  },
  "resolutions": {
    "**/ethers": "5.6.1"
  }

to fix it. And also the call in the unit test from

it("Should raise error on non existing block number", async () =>
{
    await Token.mint(Alice.address, "100");
    const result = await Token.function2(Bob.address);
    const probeBlockNumber = result.blockNumber + 100000;
    expect(await Token.function(Bob.address, probeBlockNumber)).to.be.revertedWith("Error text");
});

to

it("Should raise error on non existing block number", async () =>
{
    await Token.mint(Alice.address, "100");
    const result = await Token.function2(Bob.address);
    const probeBlockNumber = result.blockNumber + 100000;
    await expect(Token.function(Bob.address, probeBlockNumber)).to.be.revertedWith("Error text");
});

Calls that does not raise an error work with the fist variant.

[swan-of-bodom]

I am getting this error for some revertedWith tests:

AssertionError: Expected transaction to be reverted with { reason }, but other exception was thrown: ProviderError: VM Exception while processing transaction: revert with unrecognized return data or custom error

The weird thing is some i can test correctly revertedWith(errors.custom_error) and some i keep getting the error above. Is there a way to see exactly what data is being passed to revert() ?

[ItsNickBarry]

Whether the revertedWith matcher works seems to depend on whether the revert is defined directly in the contract being used, or inherited from another contract.

[swan-of-bodom]

In my case the error is defined in the contract being used, however the way I am testing the contract is:

let Contract = await ethers.getContractFactory("ExampleContract");
let contract = await Contract.attach( /* address */ )

When I perform tests this way, i get the AssertionError described above, however if i perform tests with this way it works:

let Contract = await ethers.getContractFactory("ExampleContract");
let contract = await Contract.deploy();

I think it is due to the fact that when using .deploy() from ethers the contract has a signer AND a provider attached, whereas in the first method it only has a signer WITH a provider. Could this be the issue?

[swan-of-bodom]

Just posting in case someone gets the same issue, I ran the tests again just now and they return the correct revert data and revertedWith works as expected. I did not modify the file, but while doing other things i did delete node_modules and updated @nomiclabs/hardhat-ethers": "^2.0.6 from 2.0.5 and reinstalled packages. Not sure if related but i don't get the "revert with unrecognized return data or custom error"

[matheusaaguiar]

Still having errors in solidity external tests. It fails in our CI 1071808 and it is reproducible locally, as shown next.

Steps to reproduce:

git clone https://github.com/gnosis/safe-contracts.git
cd safe-contracts/
npm init
sed -i 's/hardhat\": \"\^2\.2\.1/hardhat\": \"2.9.6/g' package.json     # ensure newest version of hardhat
npm install
sed -i "s/chainId: 31337/chainId: 0/g" node_modules/hardhat/internal/core/config/default-config.js  # workaround due to issue in behavior of chainid in @ethereumjs/vm.
npx hardhat test test/core/GnosisSafe.Estimation.spec.ts test/core/GnosisSafe.StorageAccessible.spec.ts

Output of failing tests:

 3 failing

  1) GnosisSafe
       requiredTxGas
         should revert without reason if tx fails:
     AssertionError: Expected transaction to be reverted with Transaction reverted without a reason, but other exception was thrown: Error: call revert exception [ See: https://links.ethers.org/v5-errors-CALL_EXCEPTION ] (method="requiredTxGas(address,uint256,bytes,uint8)", errorArgs=null, errorName=null, errorSignature=null, reason=null, code=CALL_EXCEPTION, version=abi/5.6.0)
  

  2) StorageAccessible
       simulateAndRevert
         should revert changes:

      AssertionError: Expected transaction to be reverted
      + expected - actual

      -Transaction NOT reverted.
      +Transaction reverted.
      
  

  3) StorageAccessible
       simulateAndRevert
         should return estimate in revert:

      AssertionError: Expected transaction to be reverted
      + expected - actual

      -Transaction NOT reverted.
      +Transaction reverted.

[ilya-bobyr]

This PR partially fixes this issue: #3308

[iboxgithub]

hi, any news on this topic? I have the same problem when I try to get the real revert reason of a tx (as detailed here: https://gist.github.com/gluk64/fdea559472d957f1138ed93bcbc6f78a)

[stackaccount1]

I am also running into this issue, is there a fix for this problem?

[samuelmonday699]

Really

[AndonMitev]

Hitting same error @6.8.1

any solutions, downgrade to any previous version? ( was @6.6.0 but there is a issue with getting FeeData for polygon so i upgraded to latest)

[atodorov]

Hitting the same error with 6.13.0 too! (Using Polkadot's/Substrate EVM compatibility impleemntation called frontier)