Parse revert reason (#1585)

* Parse revert reason when `call` fails

Solidity allows messages in `require` statements which can help a lot
when debugging. This commit parses the revert reasons from failing
`call`s and raises them as `SolidityError` exceptions.

Closes #941.

* Add test for revert interface

* Convert TransactionFailed into SolidityError

In an effort to be backend-agnostic eth-tester changes errors that are
specific to one EVM (like Revert) to a TransactionFailed error. This is
useful when using only eth-tester. But as web3.py also works directly
with other eth clients, we have to abstract over the different revert
behaviors ourselves.

* Check revert reason in test

* fixup! Add test for revert interface

Fix linting errors

* Revert contract working in geth fixture

* Beginnings of Geth integration test

* Minor refactoring, eth-tester tests passing

* Add parity fixture with revert contract

* address linting issues

* fix eth_module test and naming

* contain eth_tester exceptions

* fix lint

* check eth_estimateGas for revert exception

* wip: new fixture + latest geth revert messages

* update geth fixture

* handle eth-tester revert messages

* wip: standardize client errors

* lints

* upgrade parity fixture + handle parity revert

* dedupe constants, more cleanup

* pr review fixes

* more pr review

Co-authored-by: Keri <kclowes@users.noreply.github.com>
Co-authored-by: Marc Garreau <marcdgarreau@gmail.com>

Author: 3 people

newsfragments/941.feature.rst

@@ -0,0 +1 @@
+Raise `SolidityError` exceptions that contain the revert reason when a `call` fails.

tests/core/contracts/conftest.py

@@ -36,6 +36,11 @@
     CONTRACT_RECEIVE_FUNCTION_CODE,
     CONTRACT_RECEIVE_FUNCTION_RUNTIME,
 )
+from web3._utils.module_testing.revert_contract import (
+    _REVERT_CONTRACT_ABI,
+    REVERT_CONTRACT_BYTECODE,
+    REVERT_CONTRACT_RUNTIME_CODE,
+)
 
 CONTRACT_NESTED_TUPLE_SOURCE = """
 pragma solidity >=0.4.19 <0.6.0;
@@ -893,6 +898,37 @@ def CallerTesterContract(web3, CALLER_TESTER_CONTRACT):
     return web3.eth.contract(**CALLER_TESTER_CONTRACT)
 
 
+@pytest.fixture()
+def REVERT_CONTRACT_CODE():
+    return REVERT_CONTRACT_BYTECODE
+
+
+@pytest.fixture()
+def REVERT_CONTRACT_RUNTIME():
+    return REVERT_CONTRACT_RUNTIME_CODE
+
+
+@pytest.fixture()
+def REVERT_CONTRACT_ABI():
+    return _REVERT_CONTRACT_ABI
+
+
+@pytest.fixture()
+def REVERT_FUNCTION_CONTRACT(REVERT_CONTRACT_CODE,
+                             REVERT_CONTRACT_RUNTIME,
+                             REVERT_CONTRACT_ABI):
+    return {
+        'bytecode': REVERT_CONTRACT_CODE,
+        'bytecode_runtime': REVERT_CONTRACT_RUNTIME,
+        'abi': REVERT_CONTRACT_ABI,
+    }
+
+
+@pytest.fixture()
+def RevertContract(web3, REVERT_FUNCTION_CONTRACT):
+    return web3.eth.contract(**REVERT_FUNCTION_CONTRACT)
+
+
 class LogFunctions:
     LogAnonymous = 0
     LogNoArguments = 1

tests/core/contracts/test_contract_call_interface.py

@@ -30,6 +30,7 @@
     MismatchedABI,
     NoABIFound,
     NoABIFunctionsFound,
+    SolidityError,
     ValidationError,
 )
 
@@ -120,6 +121,19 @@ def payable_tester_contract(web3, PayableTesterContract, address_conversion_func
     return deploy(web3, PayableTesterContract, address_conversion_func)
 
 
+@pytest.fixture()
+def revert_contract(web3, RevertContract, address_conversion_func):
+    return deploy(web3, RevertContract, address_conversion_func)
+
+
+@pytest.fixture()
+def call_transaction():
+    return {
+        'data': '0x61bc221a',
+        'to': '0xc305c901078781C232A2a521C2aF7980f8385ee9'
+    }
+
+
 @pytest.fixture(params=[
     '0x0406040604060406040604060406040604060406040604060406040604060406',
     '0406040604060406040604060406040604060406040604060406040604060406',
@@ -855,3 +869,11 @@ def test_call_tuple_contract(tuple_contract, method_input, expected):
 def test_call_nested_tuple_contract(nested_tuple_contract, method_input, expected):
     result = nested_tuple_contract.functions.method(method_input).call()
     assert result == expected
+
+
+def test_call_revert_contract(revert_contract):
+    with pytest.raises(SolidityError, match="Function has been reverted."):
+        # eth-tester will do a gas estimation if we don't submit a gas value,
+        # which does not contain the revert reason. Avoid that by giving a gas
+        # value.
+        revert_contract.functions.revertWithMessage().call({'gas': 100000})

tests/core/utilities/test_method_formatters.py

@@ -0,0 +1,78 @@
+import pytest
+
+from web3._utils.method_formatters import (
+    get_error_formatters,
+    raise_solidity_error_on_revert,
+)
+from web3._utils.rpc_abi import (
+    RPC,
+)
+from web3.exceptions import (
+    SolidityError,
+)
+from web3.types import (
+    RPCResponse,
+)
+
+REVERT_WITH_MSG = RPCResponse({
+    'jsonrpc': '2.0',
+    'error': {
+        'code': -32015,
+        'message': 'VM execution error.',
+        'data': (
+            'Reverted '
+            '0x08c379a'
+            '00000000000000000000000000000000000000000000000000000000000000020'
+            '0000000000000000000000000000000000000000000000000000000000000016'
+            '6e6f7420616c6c6f77656420746f206d6f6e69746f7200000000000000000000'
+        ),
+    },
+    'id': 2987,
+})
+
+REVERT_WITHOUT_MSG = RPCResponse({
+    'jsonrpc': '2.0',
+    'error': {
+        'code': -32015,
+        'message': 'VM execution error.',
+        'data': 'Reverted 0x',
+    },
+    'id': 2987,
+})
+
+OTHER_ERROR = RPCResponse({
+    "jsonrpc": "2.0",
+    "error": {
+        "code": -32601,
+        "message": "Method not found",
+    },
+    "id": 1,
+})
+
+
+@pytest.mark.parametrize(
+    "response,expected",
+    (
+        (REVERT_WITH_MSG, 'execution reverted: not allowed to monitor'),
+        (REVERT_WITHOUT_MSG, 'execution reverted'),
+    ),
+    ids=[
+        'test-get-revert-reason-with-msg',
+        'test-get-revert-reason-without-msg',
+    ])
+def test_get_revert_reason(response, expected) -> None:
+    with pytest.raises(SolidityError, match=expected):
+        raise_solidity_error_on_revert(response)
+
+
+def test_get_revert_reason_other_error() -> None:
+    assert raise_solidity_error_on_revert(OTHER_ERROR) is OTHER_ERROR
+
+
+def test_get_error_formatters() -> None:
+    formatters = get_error_formatters(RPC.eth_call)
+    with pytest.raises(SolidityError, match='not allowed to monitor'):
+        formatters(REVERT_WITH_MSG)
+    with pytest.raises(SolidityError):
+        formatters(REVERT_WITHOUT_MSG)
+    assert formatters(OTHER_ERROR) == OTHER_ERROR

tests/integration/conftest.py

@@ -9,6 +9,10 @@
     MATH_ABI,
     MATH_BYTECODE,
 )
+from web3._utils.module_testing.revert_contract import (
+    _REVERT_CONTRACT_ABI,
+    REVERT_CONTRACT_BYTECODE,
+)
 
 
 @pytest.fixture(scope="module")
@@ -19,7 +23,17 @@ def math_contract_factory(web3):
 
 @pytest.fixture(scope="module")
 def emitter_contract_factory(web3):
-    contract_factory = web3.eth.contract(abi=CONTRACT_EMITTER_ABI, bytecode=CONTRACT_EMITTER_CODE)
+    contract_factory = web3.eth.contract(
+        abi=CONTRACT_EMITTER_ABI, bytecode=CONTRACT_EMITTER_CODE
+    )
+    return contract_factory
+
+
+@pytest.fixture(scope="module")
+def revert_contract_factory(web3):
+    contract_factory = web3.eth.contract(
+        abi=_REVERT_CONTRACT_ABI, bytecode=REVERT_CONTRACT_BYTECODE
+    )
     return contract_factory
 
 

tests/integration/generate_fixtures/common.py

@@ -34,22 +34,23 @@
     "config": {
         "chainId": 131277322940537,  # the string 'web3py' as an integer
         "homesteadBlock": 0,
+        "byzantiumBlock": 0,
+        "constantinopleBlock": 0,
         "eip150Block": 0,
         "eip155Block": 0,
         "eip158Block": 0,
-        "eip160Block": 0,
     },
     "nonce": "0x0000000000000042",
     "alloc": {
-        COINBASE: {
-            "balance": "1000000000000000000000000000"
-        },
-        UNLOCKABLE_ACCOUNT: {
-            "balance": "1000000000000000000000000000"
-        },
-        RAW_TXN_ACCOUNT: {
-            "balance": "1000000000000000000000000000"
-        }
+        COINBASE: {"balance": "1000000000000000000000000000"},
+        UNLOCKABLE_ACCOUNT: {"balance": "1000000000000000000000000000"},
+        RAW_TXN_ACCOUNT: {"balance": "1000000000000000000000000000"},
+        "0000000000000000000000000000000000000001": {"balance": "1"},
+        "0000000000000000000000000000000000000002": {"balance": "1"},
+        "0000000000000000000000000000000000000003": {"balance": "1"},
+        "0000000000000000000000000000000000000004": {"balance": "1"},
+        "0000000000000000000000000000000000000005": {"balance": "1"},
+        "0000000000000000000000000000000000000006": {"balance": "1"},
     },
     "timestamp": "0x00",
     "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",