added a check for POA extraData

Author: voith

tests/core/eth-module/test_poa.py

@@ -1,5 +1,8 @@
 import pytest
 
+from web3.exceptions import (
+    ValidationError,
+)
 from web3.middleware import (
     construct_fixture_middleware,
     geth_poa_middleware,
@@ -12,7 +15,7 @@ def test_long_extra_data(web3):
         'eth_getBlockByNumber': {'extraData': '0x' + 'ff' * 33},
     })
     web3.middleware_stack.inject(return_block_with_long_extra_data, layer=0)
-    with pytest.raises(ValueError):
+    with pytest.raises(ValidationError):
         web3.eth.getBlock('latest')
 
 

web3/middleware/validation.py

@@ -1,19 +1,91 @@
 from cytoolz import (
+    assoc,
+    complement,
     compose,
     curry,
     dissoc,
 )
 from eth_utils.curried import (
-    apply_formatter_at_index,
+    apply_formatter_if,
     apply_formatters_to_dict,
+    is_null,
+)
+from eth_utils.decorators import (
+    return_arg_type,
+)
+from eth_utils.functional import (
+    to_dict,
+)
+from hexbytes import (
+    HexBytes,
 )
 
 from web3.exceptions import (
     ValidationError,
 )
 
+is_not_null = complement(is_null)
+
 
+# TODO: move to utils
+def construct_validation_middleware(request_validators=None, result_validators=None):
+    if request_validators is None:
+        request_validators = {}
+    if result_validators is None:
+        result_validators = {}
+
+    def formatter_middleware(make_request, web3):
+        def middleware(method, params):
+            if method in request_validators:
+                formatter = request_validators[method]
+                formatted_params = formatter(web3, params)
+                response = make_request(method, formatted_params)
+            else:
+                response = make_request(method, params)
+            if 'result' in response and method in result_validators:
+                formatter = result_validators[method]
+                formatted_response = assoc(
+                    response,
+                    'result',
+                    formatter(response['result']),
+                )
+                return formatted_response
+            else:
+                return response
+        return middleware
+    return formatter_middleware
+
+
+# TODO: move to utils
 @curry
+@return_arg_type(3)
+def apply_validator_at_index(validator, at_index, web3, value):
+    if at_index + 1 > len(value):
+        raise IndexError(
+            "Not enough values in iterable to apply formatter.  Got: {0}. "
+            "Need: {1}".format(len(value), at_index + 1)
+        )
+    for index, item in enumerate(value):
+        if index == at_index:
+            yield validator(web3, item)
+        else:
+            yield item
+
+
+# TODO: move to utils
+@curry
+@to_dict
+def apply_validator_to_dict(validators, web3, value):
+    for key, item in value.items():
+        if key in validators:
+            try:
+                yield key, validators[key](web3, item)
+            except (TypeError, ValueError) as exc:
+                raise type(exc)("Could not format value %r as field %r" % (item, key)) from exc
+        else:
+            yield key, item
+
+
 def validate_chain_id(web3, chain_id):
     if chain_id == web3.version.network:
         return None
@@ -27,21 +99,55 @@ def validate_chain_id(web3, chain_id):
         )
 
 
+@curry
+def check_extradata_length(val, length):
+    if not isinstance(val, (str, int, bytes)):
+        return val
+    result = HexBytes(val)
+    if len(result) > length:
+        raise ValidationError(
+            "The field extraData is %d bytes, but should be %d. "
+            "It is quite likely that you are connected to a POA chain. "
+            "Refer "
+            "http://web3py.readthedocs.io/en/latest/middleware.html#geth-style-proof-of-authority "
+            "for more details. The full extraData is: %r" % (
+                len(result), length, result
+            )
+        )
+    return val
+
+
 def transaction_normalizer(transaction):
     return dissoc(transaction, 'chainId')
 
 
-def validation_middleware(make_request, web3):
-    transaction_validator = apply_formatters_to_dict({
-        'chainId': validate_chain_id(web3),
-    })
+BLOCK_VALIDATORS = {
+    'extraData': check_extradata_length(length=32),
+}
 
-    transaction_sanitizer = compose(transaction_normalizer, transaction_validator)
 
-    def middleware(method, params):
-        if method in {'eth_sendTransaction', 'eth_estimateGas', 'eth_call'}:
-            post_validated_params = apply_formatter_at_index(transaction_sanitizer, 0, params)
-            return make_request(method, post_validated_params)
-        else:
-            return make_request(method, params)
-    return middleware
+block_validator = apply_formatters_to_dict(BLOCK_VALIDATORS)
+
+
+TRANSACTION_PARAMS_VALIDATORS = apply_validator_to_dict({
+    'chainId': validate_chain_id,
+})
+
+
+transaction_params_validator = apply_validator_at_index(
+    compose(transaction_normalizer, TRANSACTION_PARAMS_VALIDATORS),
+    0,
+)
+
+
+validation_middleware = construct_validation_middleware(
+    request_validators={
+        'eth_sendTransaction': transaction_params_validator,
+        'eth_estimateGas': transaction_params_validator,
+        'eth_call': transaction_params_validator,
+    },
+    result_validators={
+        'eth_getBlockByHash': apply_formatter_if(is_not_null, block_validator),
+        'eth_getBlockByNumber': apply_formatter_if(is_not_null, block_validator),
+    },
+)