Make sure inheritance of the codec comes from the Web3 instance

- Use the web3 object instance reference for ``Module`` and ``web3.ens`` since the codec is set on the Web3 instance itself and for general consistency.
- Add tests to guarantee object reference consistency.
- ``ENS.from_web3()`` should be excluded from this because that creates a new instance of ENS that is entirely separate from the initial web3 instance.

Author: fselmo

ens/ens.py

@@ -112,13 +112,19 @@ def from_web3(cls, w3: "Web3", addr: ChecksumAddress = None) -> "ENS":
         """
         Generate an ENS instance with web3
 
-        :param `web3.Web3` w3: to infer connection information
+        :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
             provided, defaults to the mainnet ENS registry address.
         """
         provider = w3.manager.provider
         middlewares = w3.middleware_onion.middlewares
-        return cls(cast("BaseProvider", provider), addr=addr, middlewares=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
+
+        return ns
 
     def address(self, name: str) -> Optional[ChecksumAddress]:
         """

tests/core/web3-module/test_strict_bytes_type_checking.py

@@ -1,3 +1,104 @@
+from ens import ENS
+
+
 def test_strict_bytes_type_checking_turns_on_and_off(w3):
-    # TODO: write this test
-    pass
+    assert w3.strict_bytes_type_checking
+    assert not w3.is_encodable("bytes2", b"\x01")
+
+    w3.strict_bytes_type_checking = False
+    assert not w3.strict_bytes_type_checking
+    assert w3.is_encodable("bytes2", b"\x01")
+
+    w3.strict_bytes_type_checking = True
+    assert w3.strict_bytes_type_checking
+    assert not w3.is_encodable("bytes2", b"\x01")
+
+
+def test_ens_module_uses_strict_byte_type_check_from_web3_instance_reference(w3):
+    assert w3.strict_bytes_type_checking
+    assert not w3.is_encodable("bytes2", b"\x01")
+    assert w3.ens.w3.strict_bytes_type_checking
+    assert not w3.ens.w3.is_encodable("bytes2", b"\x01")
+
+    w3.strict_bytes_type_checking = False
+    assert not w3.strict_bytes_type_checking
+    assert not w3.ens.w3.strict_bytes_type_checking
+    assert w3.is_encodable("bytes2", b"\x01")
+    assert w3.ens.w3.is_encodable("bytes2", b"\x01")
+
+    w3.strict_bytes_type_checking = True
+    assert w3.strict_bytes_type_checking
+    assert w3.ens.w3.strict_bytes_type_checking
+    assert not w3.is_encodable("bytes2", b"\x01")
+    assert not w3.ens.w3.is_encodable("bytes2", b"\x01")
+
+
+def test_ens_from_web3_inherits_w3_codec_and_strict_byte_type_checking(w3):
+    ns = ENS.from_web3(w3)
+
+    assert w3.strict_bytes_type_checking
+    assert not w3.is_encodable("bytes2", b"\x01")
+
+    assert ns.w3.strict_bytes_type_checking
+    assert not ns.w3.is_encodable("bytes2", b"\x01")
+
+    w3.strict_bytes_type_checking = False
+    assert not w3.strict_bytes_type_checking
+    assert w3.is_encodable("bytes2", b"\x01")
+
+    another_ns = ENS.from_web3(w3)
+    assert not another_ns.w3.strict_bytes_type_checking
+    assert another_ns.w3.is_encodable("bytes2", b"\x01")
+
+
+def test_modules_use_codec_and_strict_byte_type_check_from_web3_instance_reference(
+    w3, module1, module2, module3
+):
+    assert w3.codec == w3.eth.codec
+    assert w3.codec == w3.net.codec
+    assert w3.codec == w3.geth.codec
+
+    assert w3.strict_bytes_type_checking
+    assert not w3.is_encodable("bytes2", b"\x01")
+    assert not w3.eth.codec.is_encodable("bytes2", b"\x01")
+    assert not w3.net.codec.is_encodable("bytes2", b"\x01")
+    assert not w3.geth.codec.is_encodable("bytes2", b"\x01")
+
+    w3.strict_bytes_type_checking = False
+    assert not w3.strict_bytes_type_checking
+    assert w3.is_encodable("bytes2", b"\x01")
+    assert w3.eth.codec.is_encodable("bytes2", b"\x01")
+    assert w3.net.codec.is_encodable("bytes2", b"\x01")
+    assert w3.geth.codec.is_encodable("bytes2", b"\x01")
+
+    # add modules after byte check swap
+
+    w3.attach_modules(
+        {
+            "module1": module1,
+            "module2": (
+                module2,
+                {
+                    "submodule1": (module3,),
+                },
+            ),
+        }
+    )
+
+    assert w3.codec == w3.module1.codec
+    assert w3.codec == w3.module2.codec
+    assert w3.codec == w3.module2.submodule1.codec
+
+    assert w3.module1.codec.is_encodable("bytes2", b"\x01")
+    assert w3.module2.codec.is_encodable("bytes2", b"\x01")
+    assert w3.module2.submodule1.codec.is_encodable("bytes2", b"\x01")
+
+    w3.strict_bytes_type_checking = True
+    assert w3.strict_bytes_type_checking
+    assert not w3.is_encodable("bytes2", b"\x01")
+    assert not w3.eth.codec.is_encodable("bytes2", b"\x01")
+    assert not w3.net.codec.is_encodable("bytes2", b"\x01")
+    assert not w3.geth.codec.is_encodable("bytes2", b"\x01")
+    assert not w3.module1.codec.is_encodable("bytes2", b"\x01")
+    assert not w3.module2.codec.is_encodable("bytes2", b"\x01")
+    assert not w3.module2.submodule1.codec.is_encodable("bytes2", b"\x01")

tests/ens/test_ens.py

@@ -4,10 +4,14 @@
     ENS,
     AsyncENS,
 )
+from web3 import Web3
 from web3.middleware import (
     async_validation_middleware,
     pythonic_middleware,
 )
+from web3.providers.eth_tester import (
+    AsyncEthereumTesterProvider,
+)
 
 
 def test_from_web3_inherits_web3_middlewares(w3):
@@ -18,13 +22,99 @@ def test_from_web3_inherits_web3_middlewares(w3):
     assert ns.w3.middleware_onion.get("test_middleware") == test_middleware
 
 
+def test_from_web3_does_not_set_w3_object_reference(w3):
+    assert w3.strict_bytes_type_checking
+
+    ns = ENS.from_web3(w3)
+    assert ns.w3.strict_bytes_type_checking
+
+    assert w3 != ns.w3  # assert not the same object
+
+    w3.strict_bytes_type_checking = False
+    assert not w3.strict_bytes_type_checking
+
+    assert ns.w3.strict_bytes_type_checking  # assert unchanged instance property
+
+
+def test_w3_ens_for_empty_ens_sets_w3_object_reference(w3):
+    assert w3.strict_bytes_type_checking
+    assert w3.ens.w3.strict_bytes_type_checking
+
+    assert w3 == w3.ens.w3  # assert same object
+
+    w3.strict_bytes_type_checking = False
+    assert not w3.strict_bytes_type_checking
+    assert not w3.ens.w3.strict_bytes_type_checking
+
+
+def test_w3_ens_setter_sets_w3_object_reference_on_ens(w3):
+    ns = ENS.from_web3(w3)
+    w3.ens = ns
+    assert ns == w3.ens
+    assert w3 == w3.ens.w3
+
+    assert w3.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.w3.strict_bytes_type_checking
+
+
 # -- async -- #
 
 
+@pytest.fixture
+def async_w3():
+    return Web3(AsyncEthereumTesterProvider())
+
+
 @pytest.mark.asyncio
 async 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):
+    assert async_w3.strict_bytes_type_checking
+
+    ns = AsyncENS.from_web3(async_w3)
+    assert ns.w3.strict_bytes_type_checking
+
+    assert async_w3 != ns.w3  # assert not the same object
+
+    async_w3.strict_bytes_type_checking = False
+    assert not async_w3.strict_bytes_type_checking
+
+    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):
+    assert async_w3.strict_bytes_type_checking
+    assert async_w3.ens.w3.strict_bytes_type_checking
+
+    assert async_w3 == async_w3.ens.w3  # assert same object
+
+    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
+
+
+@pytest.mark.asyncio
+async 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
+    assert async_w3 == async_w3.ens.w3
+
+    assert async_w3.strict_bytes_type_checking
+    assert async_w3.ens.w3.strict_bytes_type_checking
+
+    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

web3/main.py

@@ -252,8 +252,6 @@ def __init__(
         ens: Union[ENS, AsyncENS, "Empty"] = empty,
     ) -> None:
         self.manager = self.RequestManager(self, provider, middlewares)
-        # this codec gets used in the module initialization,
-        # so it needs to come before attach_modules
         self.codec = ABICodec(build_strict_registry())
 
         if modules is None:
@@ -369,14 +367,20 @@ def is_encodable(self, _type: TypeStr, value: Any) -> bool:
     @property
     def ens(self) -> Union[ENS, AsyncENS, "Empty"]:
         if self._ens is empty:
-            return (
-                AsyncENS.from_web3(self) if self.eth.is_async else ENS.from_web3(self)
+            ns = (
+                AsyncENS.from_web3(self)
+                if self.provider.is_async
+                else ENS.from_web3(self)
             )
+            ns.w3 = self  # set self object reference for ``ENS.w3``
+            return cast(AsyncENS, ns) if self.provider.is_async else cast(ENS, ns)
 
         return self._ens
 
     @ens.setter
     def ens(self, new_ens: Union[ENS, AsyncENS, "Empty"]) -> None:
+        if new_ens:
+            new_ens.w3 = self  # set self object reference for ``ENS.w3``
         self._ens = new_ens
 
     @property

web3/module.py

@@ -108,7 +108,11 @@ def __init__(self, w3: "Web3") -> None:
         else:
             self.retrieve_caller_fn = retrieve_blocking_method_call_fn(w3, self)
         self.w3 = w3
-        self.codec: ABICodec = w3.codec
+
+    @property
+    def codec(self) -> ABICodec:
+        # use codec set on the Web3 instance
+        return self.w3.codec
 
     def attach_methods(
         self,

web3/pm.py

@@ -575,11 +575,11 @@ def _validate_set_registry(self) -> None:
     def _validate_set_ens(self) -> None:
         if not self.w3:
             raise InvalidAddress(
-                "Could not look up ENS address because no web3 " "connection available"
+                "Could not look up ENS address because no web3 connection available"
             )
         elif not self.w3.ens:
             raise InvalidAddress(
-                "Could not look up ENS address because web3.ens is " "set to None"
+                "Could not look up ENS address because web3.ens is not set up"
             )