Address comments on PR #2786

Author: fselmo

docs/abi_types.rst

@@ -28,14 +28,17 @@ All addresses must be supplied in one of three ways:
 Disabling Strict Bytes Type Checking
 ------------------------------------
 
-There is a method on web3 that will disable strict bytes type checking.
-This allows bytes values of Python strings and allows bytestrings less
-than the specified byte size. To disable stricter checks, set the
-``w3.strict_bytes_type_checking`` flag to ``False``. This will no longer cause the web3
-instance to raise an error if a Python string is passed in without a "0x"
-prefix. It will also render valid byte strings or hex strings that are below
-the exact number of bytes specified by the ABI type. See the
-:ref:`disable-strict-byte-check` section for an example and more details.
+There is a boolean flag on the web3 instance that will disable strict bytes type checking.
+This allows bytes values of Python strings and allows byte strings less
+than the specified byte size, appropriately padding values that need padding. To
+disable stricter checks, set the ``w3.strict_bytes_type_checking`` flag to ``False``.
+This will no longer cause the web3 instance to raise an error if a Python string is
+passed in without a "0x" prefix. It will also render valid byte strings or hex strings
+that are below the exact number of bytes specified by the ABI type by padding the value
+appropriately, according to the ABI type. See the :ref:`disable-strict-byte-check`
+section for an example on using the flag and more details. For more details on the ABI
+specification, refer to the
+`Solidity ABI Spec <https://docs.soliditylang.org/en/latest/abi-spec.html>`_.
 
 Types by Example
 ----------------

docs/web3.contract.rst

@@ -490,8 +490,8 @@ size, web3 will invalidate the value. For example, if an abi specifies a type of
 
 However, you may want to be less strict with acceptable values for bytes types.
 This may prove useful if you trust that values coming through are what they are
-meant to be with respects to the respective ABI. In this case, the automatic padding
-might be convenient for inferred types. For this, you can set the
+meant to be with respect to the ABI. In this case, the automatic padding might be
+convenient for inferred types. For this, you can set the
 :meth:`w3.strict_bytes_type_checking` flag to ``False``, which is available on the
 web3 instance. A web3 instance which has this flag set to ``False`` will have a less
 strict set of rules on which values are accepted. A ``bytes`` type will allow values as

docs/web3.main.rst

@@ -356,7 +356,7 @@ Check Encodability
 RPC API Modules
 ~~~~~~~~~~~~~~~
 
-Each ``Web3`` instance also exposes these name-spaced API modules.
+Each ``Web3`` instance also exposes these namespaced API modules.
 
 
 .. py:attribute:: Web3.eth

ens/base_ens.py

@@ -38,6 +38,14 @@ class BaseENS:
     _resolver_contract: Union[Type["Contract"], Type["AsyncContract"]] = None
     _reverse_resolver_contract: Union[Type["Contract"], Type["AsyncContract"]] = None
 
+    @property
+    def strict_bytes_type_checking(self) -> bool:
+        return self.w3.strict_bytes_type_checking
+
+    @strict_bytes_type_checking.setter
+    def strict_bytes_type_checking(self, strict_bytes_type_check: bool) -> None:
+        self.w3.strict_bytes_type_checking = strict_bytes_type_check
+
     @staticmethod
     @wraps(label_to_hash)
     def labelhash(label: str) -> HexBytes:

ens/ens.py

@@ -110,7 +110,7 @@ def __init__(
     @classmethod
     def from_web3(cls, w3: "Web3", addr: ChecksumAddress = None) -> "ENS":
         """
-        Generate an ENS instance with web3
+        Generate an ENS instance from a Web3 instance
 
         :param `web3.Web3` w3: to infer connection, middleware, and codec information
         :param hex-string addr: the address of the ENS registry on-chain. If not
@@ -120,9 +120,8 @@ def from_web3(cls, w3: "Web3", addr: ChecksumAddress = None) -> "ENS":
         middlewares = w3.middleware_onion.middlewares
         ns = cls(cast("BaseProvider", provider), addr=addr, middlewares=middlewares)
 
-        # set codec and strict bytes type check flag from w3
-        ns.w3.strict_bytes_type_checking = w3.strict_bytes_type_checking
-        ns.w3.codec = w3.codec
+        # inherit strict bytes checking from w3 instance
+        ns.strict_bytes_type_checking = w3.strict_bytes_type_checking
 
         return ns
 

tests/core/contracts/test_contract_call_interface.py

@@ -109,7 +109,7 @@ def nested_tuple_contract(w3, NestedTupleContract, address_conversion_func):
 def test_deploy_raises_due_to_strict_byte_checking_by_default(
     w3, Bytes32Contract, address_conversion_func
 ):
-    with pytest.raises(TypeError, match=""):
+    with pytest.raises(TypeError):
         deploy(
             w3,
             Bytes32Contract,

tests/core/contracts/test_contract_transact_interface.py

@@ -166,8 +166,7 @@ def test_transacting_with_contract_with_bytes32_array_argument(
     assert final_value == new_bytes32_array
 
 
-# TODO: strict by default
-def test_transacting_with_contract_with_byte_array_argument_strict(
+def test_transacting_with_contract_with_byte_array_argument(
     w3, arrays_contract, transact, call
 ):
     new_byte_array = [b"\x03", b"\x03", b"\x03", b"\x03", b"\x03", b"\x03"]
@@ -462,7 +461,6 @@ async def test_async_transacting_with_contract_with_bytes32_array_argument(
     assert final_value == new_bytes32_array
 
 
-# TODO: strict by default
 @pytest.mark.asyncio
 async def test_async_transacting_with_contract_with_byte_array_argument(
     async_w3,

tests/core/filtering/test_utils_functions.py

@@ -185,12 +185,14 @@ def test_match_fn_with_various_data_types(w3, data, expected, match_data_and_abi
         ),
     ),
 )
-def test_match_fn_with_various_data_types_strict(
-    w3, data, expected, match_data_and_abi
+def test_match_fn_with_various_data_types_non_strict(
+    w3_non_strict_abi, data, expected, match_data_and_abi
 ):
     abi_types, match_data = zip(*match_data_and_abi)
-    encoded_data = w3.codec.encode(abi_types, data)
-    assert match_fn(w3.codec, match_data_and_abi, encoded_data) == expected
+    encoded_data = w3_non_strict_abi.codec.encode(abi_types, data)
+    assert (
+        match_fn(w3_non_strict_abi.codec, match_data_and_abi, encoded_data) == expected
+    )
 
 
 @pytest.mark.parametrize(

tests/core/utilities/test_construct_event_topics.py

@@ -133,8 +133,8 @@ def test_construct_event_topics(w3, arguments, expected):
         ),
     ),
 )
-def test_construct_event_topics_strict(w3, arguments, expected):
-    actual = construct_event_topic_set(EVENT_1_ABI, w3.codec, arguments)
+def test_construct_event_topics_non_strict(w3_non_strict_abi, arguments, expected):
+    actual = construct_event_topic_set(EVENT_1_ABI, w3_non_strict_abi.codec, arguments)
     assert actual == expected
 
 

tests/ens/test_ens.py

@@ -54,13 +54,38 @@ def test_w3_ens_setter_sets_w3_object_reference_on_ens(w3):
     assert w3 == w3.ens.w3
 
     assert w3.strict_bytes_type_checking
+    assert w3.ens.strict_bytes_type_checking
     assert w3.ens.w3.strict_bytes_type_checking
 
     w3.strict_bytes_type_checking = False
     assert not w3.strict_bytes_type_checking
+    assert not w3.ens.strict_bytes_type_checking
     assert not w3.ens.w3.strict_bytes_type_checking
 
 
+def test_ens_strict_bytes_type_checking_is_distinct_from_w3_instance(w3):
+    ns = ENS.from_web3(w3)
+    assert ns.w3 != w3  # assert unique instance for ns
+    assert ns.w3 == ns._resolver_contract.w3  # assert same instance used under the hood
+
+    assert w3.strict_bytes_type_checking
+    assert ns.strict_bytes_type_checking
+
+    w3.strict_bytes_type_checking = False
+    assert not w3.strict_bytes_type_checking
+    assert ns.strict_bytes_type_checking
+    assert ns.w3.strict_bytes_type_checking
+    assert ns._resolver_contract.w3.strict_bytes_type_checking
+
+    w3.strict_bytes_type_checking = True
+    assert w3.strict_bytes_type_checking
+
+    ns.strict_bytes_type_checking = False
+    assert not ns.strict_bytes_type_checking
+    assert not ns.w3.strict_bytes_type_checking
+    assert not ns._resolver_contract.w3.strict_bytes_type_checking
+
+
 # -- async -- #
 
 
@@ -69,17 +94,15 @@ def async_w3():
     return Web3(AsyncEthereumTesterProvider())
 
 
-@pytest.mark.asyncio
-async def test_async_from_web3_inherits_web3_middlewares(async_w3):
+def test_async_from_web3_inherits_web3_middlewares(async_w3):
     test_middleware = async_validation_middleware
     async_w3.middleware_onion.add(test_middleware, "test_middleware")
 
     ns = AsyncENS.from_web3(async_w3)
     assert ns.w3.middleware_onion.get("test_middleware") == test_middleware
 
 
-@pytest.mark.asyncio
-async def test_async_from_web3_does_not_set_w3_object_reference(async_w3):
+def test_async_from_web3_does_not_set_w3_object_reference(async_w3):
     assert async_w3.strict_bytes_type_checking
 
     ns = AsyncENS.from_web3(async_w3)
@@ -93,8 +116,7 @@ async def test_async_from_web3_does_not_set_w3_object_reference(async_w3):
     assert ns.w3.strict_bytes_type_checking  # assert unchanged instance property
 
 
-@pytest.mark.asyncio
-async def test_async_w3_ens_for_empty_ens_sets_w3_object_reference(async_w3):
+def test_async_w3_ens_for_empty_ens_sets_w3_object_reference(async_w3):
     assert async_w3.strict_bytes_type_checking
     assert async_w3.ens.w3.strict_bytes_type_checking
 
@@ -105,8 +127,7 @@ async def test_async_w3_ens_for_empty_ens_sets_w3_object_reference(async_w3):
     assert not async_w3.ens.w3.strict_bytes_type_checking
 
 
-@pytest.mark.asyncio
-async def test_async_w3_ens_setter_sets_w3_object_reference_on_ens(async_w3):
+def test_async_w3_ens_setter_sets_w3_object_reference_on_ens(async_w3):
     ns = AsyncENS.from_web3(async_w3)
     async_w3.ens = ns
     assert ns == async_w3.ens
@@ -118,3 +139,26 @@ async def test_async_w3_ens_setter_sets_w3_object_reference_on_ens(async_w3):
     async_w3.strict_bytes_type_checking = False
     assert not async_w3.strict_bytes_type_checking
     assert not async_w3.ens.w3.strict_bytes_type_checking
+
+
+def test_async_ens_strict_bytes_type_checking_is_distinct_from_w3_instance(async_w3):
+    ns = AsyncENS.from_web3(async_w3)
+    assert ns.w3 != async_w3  # assert unique instance for ns
+    assert ns.w3 == ns._resolver_contract.w3  # assert same instance used under the hood
+
+    assert async_w3.strict_bytes_type_checking
+    assert ns.strict_bytes_type_checking
+
+    async_w3.strict_bytes_type_checking = False
+    assert not async_w3.strict_bytes_type_checking
+    assert ns.strict_bytes_type_checking
+    assert ns.w3.strict_bytes_type_checking
+    assert ns._resolver_contract.w3.strict_bytes_type_checking
+
+    async_w3.strict_bytes_type_checking = True
+    assert async_w3.strict_bytes_type_checking
+
+    ns.strict_bytes_type_checking = False
+    assert not ns.strict_bytes_type_checking
+    assert not ns.w3.strict_bytes_type_checking
+    assert not ns._resolver_contract.w3.strict_bytes_type_checking