Address PR feedback

Author: kclowes

docs/contracts.rst

@@ -523,10 +523,11 @@ The following values will raise an error by default:
 
 However, you may want to be stricter with acceptable values for bytes types.
 For this you can use the ``enable_strict_bytes_type_checking`` method,
-which is available on the w3 instance. When the method is called, a new codec is
-instatntiated and any string that is not prefixed with
-``0x`` will throw an error. Similarly, a bytestring that is less than the
-specified byte size will raise an error. Using the same ``bytes4`` example:
+which is available on the web3 instance. A web3 instance which has had this method
+invoked will enforce a stricter set of rules on which values are accepted.
+Any string that is not prefixed with ``0x`` will throw an error.
+Similarly, a bytestring that is less than the specified byte size
+will raise an error. Using the same ``bytes4`` example:
 
 .. code-block:: python
 

tests/core/contracts/test_contract_call_interface.py

@@ -9,6 +9,9 @@
 import pytest
 
 import eth_abi
+from eth_utils import (
+    is_text,
+)
 from eth_utils.toolz import (
     identity,
 )
@@ -99,7 +102,13 @@ def address_contract(web3, WithConstructorAddressArgumentsContract, address_conv
 
 @pytest.fixture(params=[b'\x04\x06', '0x0406', '0406'])
 def bytes_contract(web3, BytesContract, request, address_conversion_func):
-    return deploy(web3, BytesContract, address_conversion_func, args=[request.param])
+    if is_text(request.param) and request.param[:2] != '0x':
+        with pytest.warns(
+            DeprecationWarning,
+            match='in v6 it will be invalid to pass a hexstring without the "0x" prefix'):
+            return deploy(web3, BytesContract, address_conversion_func, args=[request.param])
+    else:
+        return deploy(web3, BytesContract, address_conversion_func, args=[request.param])
 
 
 @pytest.fixture()
@@ -126,8 +135,11 @@ def call_transaction():
     HexBytes('0406040604060406040604060406040604060406040604060406040604060406'),
 ])
 def bytes32_contract(web3, Bytes32Contract, request, address_conversion_func):
-    return deploy(web3, Bytes32Contract, address_conversion_func, args=[request.param])
-
+    if is_text(request.param) and request.param[:2] != '0x':
+        with pytest.warns(DeprecationWarning):
+            return deploy(web3, Bytes32Contract, address_conversion_func, args=[request.param])
+    else:
+        return deploy(web3, Bytes32Contract, address_conversion_func, args=[request.param])
 
 @pytest.fixture()
 def undeployed_math_contract(web3, MathContract, address_conversion_func):

tests/core/contracts/test_extracting_event_data.py

@@ -1,9 +1,6 @@
 import pytest
 import re
 
-from eth_abi.utils.padding import (
-    zpad_right,
-)
 from eth_utils import (
     is_same_address,
 )
@@ -407,7 +404,8 @@ def test_argument_extraction_strict_bytes_types(web3_strict_types,
     assert event_topic in log_entry['topics']
 
     encoded_arg_0 = web3_strict_types.codec.encode_abi(['bytes2'], arg_0)
-    arg_0_topic = web3_strict_types.keccak(zpad_right(encoded_arg_0, 32))
+    padded_arg_0 = encoded_arg_0.ljust(32, b'\x00')
+    arg_0_topic = web3_strict_types.keccak(padded_arg_0)
     assert arg_0_topic in log_entry['topics']
 
     event_data = get_event_data(web3_strict_types.codec, event_abi, log_entry)

tests/core/utilities/test_abi_is_encodable.py

@@ -40,16 +40,13 @@
         ('rejects_invalid_names.eth', 'address', False),  # no underscore in domain names
 
         # Special bytes<M> behavior
-        ('12', 'bytes2', True),  # undersize OK
         ('0x12', 'bytes2', True),  # with or without 0x OK
-        ('0123', 'bytes2', True),  # exact size OK
         (b'\x12', 'bytes2', True),  # as bytes value undersize OK
         ('0123', 'bytes1', False),  # no oversize hex strings
         ('1', 'bytes2', False),  # no odd length
         ('0x1', 'bytes2', False),  # no odd length
 
         # Special bytes behavior
-        ('12', 'bytes', True),
         ('0x12', 'bytes', True),
         ('1', 'bytes', False),
         ('0x1', 'bytes', False),
@@ -75,10 +72,29 @@
 )
 def test_is_encodable(value, _type, expected):
     w3 = Web3(EthereumTesterProvider())
-    actual = w3.codec.is_encodable(_type, value)
+    actual = w3.is_encodable(_type, value)
     assert actual is expected
 
 
+@pytest.mark.parametrize(
+    'value,_type,expected',
+    (
+        ('12', 'bytes2', True),
+        ('0123', 'bytes2', True),
+
+        ('12', 'bytes', True),
+    )
+)
+def test_is_encodable_warnings(value, _type, expected):
+    w3 = Web3(EthereumTesterProvider())
+    with pytest.warns(
+        DeprecationWarning,
+        match='in v6 it will be invalid to pass a hexstring without the "0x" prefix'
+    ):
+        actual = w3.is_encodable(_type, value)
+        assert actual is expected
+
+
 @pytest.mark.parametrize(
     'value,_type,expected',
     (
@@ -96,6 +112,7 @@ def test_is_encodable(value, _type, expected):
         ('0x12', 'bytes', True),
         ('1', 'bytes', False),
         ('0x1', 'bytes', False),
+        ('0x0x0x0x', 'bytes', False),
 
         # Special string behavior
         (b'', 'string', True),
@@ -107,5 +124,5 @@ def test_is_encodable_strict(value, _type, expected):
     w3 = Web3(EthereumTesterProvider())
     w3.enable_strict_bytes_type_checking()
 
-    actual = w3.codec.is_encodable(_type, value)
+    actual = w3.is_encodable(_type, value)
     assert actual is expected

web3/_utils/abi.py

@@ -151,11 +151,7 @@ def validate_value(cls, value):
 
 class AcceptsHexStrMixin:
     def validate_value(self, value):
-        if is_text(value) and value[:2] != '0x':
-            warnings.warn(
-                'in v6 it will be invalid to pass a hexstring without the "0x" prefix',
-                category=DeprecationWarning
-            )
+        original_value = value
         if is_text(value):
             try:
                 value = decode_hex(value)
@@ -164,6 +160,12 @@ def validate_value(self, value):
                     value,
                     msg=f'{value} is an invalid hex string',
                 )
+            else:
+                if original_value[:2] != '0x':
+                    warnings.warn(
+                        'in v6 it will be invalid to pass a hexstring without the "0x" prefix',
+                        category=DeprecationWarning
+                    )
 
         super().validate_value(value)
 
@@ -184,8 +186,6 @@ def validate_value(self, value):
                     msg=f'{value} is an invalid hex string',
                 )
 
-        super().validate_value(value)
-
 
 class BytesEncoder(AcceptsHexStrMixin, encoding.BytesEncoder):
     pass
@@ -250,14 +250,10 @@ def encode(self, value):
         return self.encode_fn(value)
 
     def validate_value(self, value):
+        original_value = value
         if not is_bytes(value) and not is_text(value):
             self.invalidate_value(value)
 
-        if is_text(value) and value[:2] != '0x':
-            self.invalidate_value(
-                value,
-                msg='hex string must be prefixed with 0x'
-            )
         elif is_text(value):
             try:
                 value = decode_hex(value)
@@ -266,6 +262,12 @@ def validate_value(self, value):
                     value,
                     msg='invalid hex string',
                 )
+            else:
+                if original_value[:2] != '0x':
+                    self.invalidate_value(
+                        original_value,
+                        msg='hex string must be prefixed with 0x'
+                    )
 
         byte_size = self.value_bit_size // 8
         if len(value) > byte_size:

web3/_utils/filters.py

@@ -215,7 +215,7 @@ def match_fn(w3, match_values_and_abi, data):
             continue
         normalized_data = normalize_data_values(abi_type, data_value)
         for value in match_values:
-            if not w3.codec.is_encodable(abi_type, value):
+            if not w3.is_encodable(abi_type, value):
                 raise ValueError(
                     f"Value {value} is of the wrong abi type. "
                     f"Expected {abi_type} typed value."

web3/main.py

@@ -226,6 +226,9 @@ def solidityKeccak(cls, abi_types, values):
     def isConnected(self):
         return self.provider.isConnected()
 
+    def is_encodable(self, _type, value):
+        return self.codec.is_encodable(_type, value)
+
     @property
     def ens(self):
         if self._ens is empty: