Apply error formatters to response

tests/core/method-class/test_method.py

@@ -13,7 +13,7 @@
 )
 from web3.module import (
     ModuleV2,
-    apply_response_formatters,
+    apply_result_formatters,
 )
 
 
@@ -52,11 +52,10 @@ def test_get_formatters_default_formatter_for_falsy_config():
         formatter_lookup_fn=''
     )
 
-    default_request_formatters, default_response_formatters = method.get_formatters('')
-
+    default_request_formatters, (default_result_formatters, _) = method.get_formatters('')
     assert _apply_request_formatters(['a', 'b', 'c'], default_request_formatters) == ['a', 'b', 'c']
-    assert apply_response_formatters(
-        default_response_formatters, {'result': ['a', 'b', 'c']}) == {'result': ['a', 'b', 'c']}
+    assert apply_result_formatters(
+        default_result_formatters, ['a', 'b', 'c']) == ['a', 'b', 'c']
 
 
 def test_get_formatters_non_falsy_config_retrieval():

tests/core/method-class/test_result_formatters.py

@@ -26,7 +26,7 @@ def result_formatter(result):
 
 
 def formatters(method):
-    return ((identity,), (result_formatter,))
+    return ((identity,), ((result_formatter,), None))
 
 
 def test_method():
@@ -43,7 +43,7 @@ def make_request(method, params):
 
 result_middleware = construct_result_generator_middleware(
     {
-        'test_method': lambda m, p: {'result': 'ok'},
+        'test_method': lambda m, p: 'ok',
     })
 
 

web3/_utils/method_formatters.py

@@ -407,6 +407,7 @@ def method_filter(formatter_dict, method):
 )
 
 
+#  Note error formatters work on the full response dict
 ERROR_FORMATTER_MAPS = (
 
 )

web3/manager.py

@@ -1,6 +1,10 @@
 import logging
 import uuid
 
+from eth_utils.toolz import (
+    pipe,
+)
+
 from web3._utils.decorators import (
     deprecated_for,
 )
@@ -25,6 +29,17 @@
 )
 
 
+def apply_error_formatters(
+        error_formatters,
+        response):
+
+    if 'error' in response and error_formatters:
+        formatted_response = pipe(response, *error_formatters)
+        return formatted_response
+    else:
+        return response
+
+
 class RequestManager:
     logger = logging.getLogger("web3.RequestManager")
 
@@ -87,22 +102,24 @@ async def _coro_make_request(self, method, params):
         self.logger.debug("Making request. Method: %s", method)
         return await request_func(method, params)
 
-    def request_blocking(self, method, params):
+    def request_blocking(self, method, params, error_formatters=None):
         """
         Make a synchronous request using the provider
         """
         response = self._make_request(method, params)
+        apply_error_formatters(error_formatters, response)
 
         if "error" in response:
             raise ValueError(response["error"])
 
         return response['result']
 
-    async def coro_request(self, method, params):
+    async def coro_request(self, method, params, error_formatters=None):
         """
         Couroutine for making a request using the provider
         """
         response = await self._coro_make_request(method, params)
+        apply_error_formatters(error_formatters, response)
 
         if "error" in response:
             raise ValueError(response["error"])

web3/module.py

@@ -1,50 +1,38 @@
 from eth_utils.toolz import (
-    assoc,
     curry,
     pipe,
 )
 
 
 @curry
-def apply_response_formatters(
-        response_formatters,
-        response):
-
-    result_formatters, error_formatters = response_formatters
-
-    if 'result' in response and result_formatters:
-        formatted_response = assoc(
-            response,
-            'result',
-            pipe(response['result'], *result_formatters),
-        )
-        return formatted_response
-    elif 'error' in response and error_formatters:
-        formatted_response = assoc(
-            response,
-            'error',
-            pipe(response['error'], *error_formatters),
-        )
-        return formatted_response
+def apply_result_formatters(
+        result_formatters,
+        result):
+
+    if result_formatters:
+        formatted_result = pipe(result, *result_formatters)
+        return formatted_result
     else:
-        return response
+        return result
 
 
 @curry
 def retrieve_blocking_method_call_fn(w3, module, method):
     def caller(*args, **kwargs):
-        (method_str, params), output_formatters = method.process_params(module, *args, **kwargs)
-        response = w3.manager.request_blocking(method_str, params)
-        return apply_response_formatters(output_formatters, response)
+        (method_str, params), response_formatters = method.process_params(module, *args, **kwargs)
+        result_formatters, error_formatters = response_formatters
+        result = w3.manager.request_blocking(method_str, params, error_formatters)
+        return apply_result_formatters(result_formatters, result)
     return caller
 
 
 @curry
 def retrieve_async_method_call_fn(w3, module, method):
     async def caller(*args, **kwargs):
-        (method_str, params), output_formatters = method.process_params(module, *args, **kwargs)
-        raw_result = await w3.manager.coro_request(method_str, params)
-        return pipe(raw_result, *output_formatters)
+        (method_str, params), response_formatters = method.process_params(module, *args, **kwargs)
+        result_formatters, error_formatters = response_formatters
+        result = await w3.manager.coro_request(method_str, params, error_formatters)
+        return apply_result_formatters(result_formatters, result)
     return caller