web3 7.0.0b1__tar.gz → 7.0.0b2__tar.gz

{web3-7.0.0b1 → web3-7.0.0b2}/MANIFEST.in

@@ -5,7 +5,3 @@ recursive-exclude * __pycache__
 recursive-exclude * *.py[co]
 
 recursive-include ens/specs *
-
-recursive-include ethpm/assets *
-recursive-include ethpm/ethpm-spec/examples *
-recursive-include ethpm/ethpm-spec/spec *

{web3-7.0.0b1 → web3-7.0.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: web3
-Version: 7.0.0b1
+Version: 7.0.0b2
 Summary: web3.py
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation
@@ -26,8 +26,6 @@ Requires-Dist: eth-hash[pycryptodome]>=0.5.1
 Requires-Dist: eth-typing>=3.0.0
 Requires-Dist: eth-utils>=4.0.0
 Requires-Dist: hexbytes<0.4.0,>=0.1.0
-Requires-Dist: jsonschema>=4.0.0
-Requires-Dist: protobuf>=4.21.6
 Requires-Dist: pydantic>=2.4.0
 Requires-Dist: pywin32>=223; platform_system == "Windows"
 Requires-Dist: requests>=2.16.0
@@ -44,7 +42,6 @@ Requires-Dist: isort>=5.11.0; extra == "linter"
 Requires-Dist: mypy==1.4.1; extra == "linter"
 Requires-Dist: types-setuptools>=57.4.4; extra == "linter"
 Requires-Dist: types-requests>=2.26.1; extra == "linter"
-Requires-Dist: types-protobuf==3.19.13; extra == "linter"
 Provides-Extra: docs
 Requires-Dist: sphinx>=5.3.0; extra == "docs"
 Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "docs"
@@ -58,11 +55,9 @@ Requires-Dist: isort>=5.11.0; extra == "dev"
 Requires-Dist: mypy==1.4.1; extra == "dev"
 Requires-Dist: types-setuptools>=57.4.4; extra == "dev"
 Requires-Dist: types-requests>=2.26.1; extra == "dev"
-Requires-Dist: types-protobuf==3.19.13; extra == "dev"
 Requires-Dist: sphinx>=5.3.0; extra == "dev"
 Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "dev"
 Requires-Dist: towncrier<22,>=21; extra == "dev"
-Requires-Dist: ipfshttpclient==0.8.0a2; extra == "dev"
 Requires-Dist: bumpversion; extra == "dev"
 Requires-Dist: flaky>=3.7.0; extra == "dev"
 Requires-Dist: hypothesis>=3.31.2; extra == "dev"
@@ -76,10 +71,7 @@ Requires-Dist: setuptools>=38.6.0; extra == "dev"
 Requires-Dist: tox>=3.18.0; extra == "dev"
 Requires-Dist: tqdm>4.32; extra == "dev"
 Requires-Dist: twine>=1.13; extra == "dev"
-Requires-Dist: when-changed>=0.3.0; extra == "dev"
 Requires-Dist: build>=0.9.0; extra == "dev"
-Provides-Extra: ipfs
-Requires-Dist: ipfshttpclient==0.8.0a2; extra == "ipfs"
 
 # web3.py
 

{web3-7.0.0b1 → web3-7.0.0b2}/ens/async_ens.py

@@ -100,7 +100,7 @@ class AsyncENS(BaseENS):
         self,
         provider: "AsyncBaseProvider" = cast("AsyncBaseProvider", default),
         addr: ChecksumAddress = None,
-        middlewares: Optional[Sequence[Tuple["Middleware", str]]] = None,
+        middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
     ) -> None:
         """
         :param provider: a single provider used to connect to Ethereum
@@ -108,7 +108,7 @@ class AsyncENS(BaseENS):
         :param hex-string addr: the address of the ENS registry on-chain.
             If not provided, ENS.py will default to the mainnet ENS registry address.
         """
-        self.w3 = init_async_web3(provider, middlewares)
+        self.w3 = init_async_web3(provider, middleware)
 
         ens_addr = addr if addr else ENS_MAINNET_ADDR
         self.ens = self.w3.eth.contract(abi=abis.ENS, address=ens_addr)
@@ -129,10 +129,8 @@ class AsyncENS(BaseENS):
             provided, defaults to the mainnet ENS registry address.
         """
         provider = w3.manager.provider
-        middlewares = w3.middleware_onion.middlewares
-        ns = cls(
-            cast("AsyncBaseProvider", provider), addr=addr, middlewares=middlewares
-        )
+        middleware = w3.middleware_onion.middleware
+        ns = cls(cast("AsyncBaseProvider", provider), addr=addr, middleware=middleware)
 
         # inherit strict bytes checking from w3 instance
         ns.strict_bytes_type_checking = w3.strict_bytes_type_checking

{web3-7.0.0b1 → web3-7.0.0b2}/ens/ens.py

@@ -99,7 +99,7 @@ class ENS(BaseENS):
         self,
         provider: "BaseProvider" = cast("BaseProvider", default),
         addr: ChecksumAddress = None,
-        middlewares: Optional[Sequence[Tuple["Middleware", str]]] = None,
+        middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
     ) -> None:
         """
         :param provider: a single provider used to connect to Ethereum
@@ -108,7 +108,7 @@ class ENS(BaseENS):
             If not provided, ENS.py will default to the mainnet ENS
             registry address.
         """
-        self.w3 = init_web3(provider, middlewares)
+        self.w3 = init_web3(provider, middleware)
 
         ens_addr = addr if addr else ENS_MAINNET_ADDR
         self.ens = self.w3.eth.contract(abi=abis.ENS, address=ens_addr)
@@ -129,8 +129,8 @@ class ENS(BaseENS):
             provided, defaults to the mainnet ENS registry address.
         """
         provider = w3.manager.provider
-        middlewares = w3.middleware_onion.middlewares
-        ns = cls(cast("BaseProvider", provider), addr=addr, middlewares=middlewares)
+        middleware = w3.middleware_onion.middleware
+        ns = cls(cast("BaseProvider", provider), addr=addr, middleware=middleware)
 
         # inherit strict bytes checking from w3 instance
         ns.strict_bytes_type_checking = w3.strict_bytes_type_checking

{web3-7.0.0b1 → web3-7.0.0b2}/ens/utils.py

@@ -81,7 +81,7 @@ def Web3() -> Type["_Web3"]:
 
 def init_web3(
     provider: "BaseProvider" = cast("BaseProvider", default),
-    middlewares: Optional[Sequence[Tuple["Middleware", str]]] = None,
+    middleware: Optional[Sequence[Tuple["Middleware", str]]] = None,
 ) -> "_Web3":
     from web3 import (
         Web3 as Web3Main,
@@ -93,7 +93,7 @@ def init_web3(
     if provider is default:
         w3 = Web3Main(ens=None, modules={"eth": (EthMain)})
     else:
-        w3 = Web3Main(provider, middlewares, ens=None, modules={"eth": (EthMain)})
+        w3 = Web3Main(provider, middleware, ens=None, modules={"eth": (EthMain)})
 
     return customize_web3(w3)
 
@@ -299,7 +299,7 @@ def get_abi_output_types(abi: "ABIFunction") -> List[str]:
 
 def init_async_web3(
     provider: "AsyncBaseProvider" = cast("AsyncBaseProvider", default),
-    middlewares: Optional[Sequence[Tuple["Middleware", str]]] = (),
+    middleware: Optional[Sequence[Tuple["Middleware", str]]] = (),
 ) -> "AsyncWeb3":
     from web3 import (
         AsyncWeb3 as AsyncWeb3Main,
@@ -311,13 +311,13 @@ def init_async_web3(
         StalecheckMiddlewareBuilder,
     )
 
-    middlewares = list(middlewares)
-    for i, (middleware, name) in enumerate(middlewares):
+    middleware = list(middleware)
+    for i, (mw, name) in enumerate(middleware):
         if name == "ens_name_to_address":
-            middlewares.pop(i)
+            middleware.pop(i)
 
-    if "stalecheck" not in (name for mw, name in middlewares):
-        middlewares.append(
+    if "stalecheck" not in (name for mw, name in middleware):
+        middleware.append(
             (
                 StalecheckMiddlewareBuilder.build(ACCEPTABLE_STALE_HOURS * 3600),
                 "stalecheck",
@@ -326,12 +326,12 @@ def init_async_web3(
 
     if provider is default:
         async_w3 = AsyncWeb3Main(
-            middlewares=middlewares, ens=None, modules={"eth": (AsyncEthMain)}
+            middleware=middleware, ens=None, modules={"eth": (AsyncEthMain)}
         )
     else:
         async_w3 = AsyncWeb3Main(
             provider,
-            middlewares=middlewares,
+            middleware=middleware,
             ens=None,
             modules={"eth": (AsyncEthMain)},
         )

{web3-7.0.0b1 → web3-7.0.0b2}/setup.py

@@ -16,7 +16,6 @@ extras_require = {
         "mypy==1.4.1",
         "types-setuptools>=57.4.4",
         "types-requests>=2.26.1",
-        "types-protobuf==3.19.13",
     ],
     "docs": [
         "sphinx>=5.3.0",
@@ -37,19 +36,14 @@ extras_require = {
         "tox>=3.18.0",
         "tqdm>4.32",
         "twine>=1.13",
-        "when-changed>=0.3.0",
         "build>=0.9.0",
     ],
-    "ipfs": [
-        "ipfshttpclient==0.8.0a2",
-    ],
 }
 
 extras_require["dev"] = (
     extras_require["tester"]
     + extras_require["linter"]
     + extras_require["docs"]
-    + extras_require["ipfs"]
     + extras_require["dev"]
 )
 
@@ -59,7 +53,7 @@ with open("./README.md") as readme:
 setup(
     name="web3",
     # *IMPORTANT*: Don't manually change the version here. Use the 'bumpversion' utility.
-    version="7.0.0-beta.1",
+    version="7.0.0-beta.2",
     description="""web3.py""",
     long_description_content_type="text/markdown",
     long_description=long_description,
@@ -75,8 +69,6 @@ setup(
         "eth-typing>=3.0.0",
         "eth-utils>=4.0.0",
         "hexbytes>=0.1.0,<0.4.0",
-        "jsonschema>=4.0.0",
-        "protobuf>=4.21.6",
         "pydantic>=2.4.0",
         "pywin32>=223;platform_system=='Windows'",
         "requests>=2.16.0",
@@ -86,8 +78,7 @@ setup(
     ],
     python_requires=">=3.8",
     extras_require=extras_require,
-    py_modules=["web3", "ens", "ethpm"],
-    entry_points={"pytest11": ["pytest_ethereum = web3.tools.pytest_ethereum.plugins"]},
+    py_modules=["web3", "ens"],
     license="MIT",
     zip_safe=False,
     keywords="ethereum",

{web3-7.0.0b1 → web3-7.0.0b2}/web3/_utils/abi.py

@@ -51,7 +51,6 @@ from eth_typing import (
     TypeStr,
 )
 from eth_utils import (
-    combomethod,
     decode_hex,
     is_bytes,
     is_list_like,
@@ -211,10 +210,7 @@ class AcceptsHexStrEncoder(encoding.BaseEncoder):
     ) -> None:
         super().__init__(**kwargs)
         self.subencoder = subencoder
-
-    @property
-    def is_dynamic(self) -> bool:
-        return self.subencoder.is_dynamic
+        self.is_dynamic = subencoder.is_dynamic
 
     @classmethod
     def from_type_str(
@@ -234,10 +230,9 @@ class AcceptsHexStrEncoder(encoding.BaseEncoder):
             raise AttributeError(f"No subencoder class is set. {cls.__name__}")
         return cls.subencoder_cls
 
-    @combomethod
     def validate_value(self, value: Any) -> None:
         normalized_value = self.validate_and_normalize(value)
-        return self.subencoder.validate_value(normalized_value)
+        self.subencoder.validate_value(normalized_value)
 
     def encode(self, value: Any) -> bytes:
         normalized_value = self.validate_and_normalize(value)
@@ -308,15 +303,14 @@ class ExactLengthBytesEncoder(BytesEncoder):
             raise ValueError("Value byte size exceeds data size")
 
     @parse_type_str("bytes")
-    def from_type_str(cls, abi_type: BasicType, registry: ABIRegistry) -> bytes:
+    def from_type_str(
+        cls, abi_type: BasicType, registry: ABIRegistry
+    ) -> "ExactLengthBytesEncoder":
         subencoder_cls = cls.get_subencoder_class()
-        # cast b/c expects BaseCoder but `from_type_string`
-        # restricted to BaseEncoder subclasses
-        subencoder = cast(
-            encoding.BaseEncoder,
-            subencoder_cls.from_type_str(abi_type.to_type_str(), registry),
-        )
-        return cls(
+        subencoder = subencoder_cls.from_type_str(abi_type.to_type_str(), registry)
+        # type ignored b/c @parse_type_str decorator turns it into a classmethod,
+        # so mypy thinks cls(...) is a call to __call__, but actually calls __init__
+        return cls(  # type: ignore
             subencoder,
             value_bit_size=abi_type.sub * 8,
             data_byte_size=abi_type.sub,

{web3-7.0.0b1 → web3-7.0.0b2}/web3/_utils/module_testing/module_testing_utils.py

@@ -104,7 +104,7 @@ def mock_offchain_lookup_request_response(
 
         # mock response only to specified url while validating appropriate fields
         if url_from_args == mocked_request_url:
-            assert kwargs["timeout"] == 10
+            assert kwargs["timeout"] == 30
             if http_method.upper() == "POST":
                 assert kwargs["data"] == {"data": calldata, "sender": sender}
             return MockedResponse()
@@ -154,7 +154,7 @@ def async_mock_offchain_lookup_request_response(
 
         # mock response only to specified url while validating appropriate fields
         if url_from_args == mocked_request_url:
-            assert kwargs["timeout"] == ClientTimeout(10)
+            assert kwargs["timeout"] == ClientTimeout(30)
             if http_method.upper() == "post":
                 assert kwargs["data"] == {"data": calldata, "sender": sender}
             return AsyncMockedResponse()

{web3-7.0.0b1 → web3-7.0.0b2}/web3/_utils/request.py

@@ -35,7 +35,7 @@ from web3.utils.caching import (
 
 logger = logging.getLogger(__name__)
 
-DEFAULT_TIMEOUT = 10
+DEFAULT_TIMEOUT = 30
 
 
 def get_default_http_endpoint() -> URI:

{web3-7.0.0b1 → web3-7.0.0b2}/web3/datastructures.py

@@ -252,9 +252,9 @@ class NamedElementOnion(Mapping[TKey, TValue]):
         del self._queue[old_name]
 
     @property
-    def middlewares(self) -> Sequence[Any]:
+    def middleware(self) -> Sequence[Any]:
         """
-        Returns middlewares in the appropriate order to be imported into a new Web3
+        Returns middleware in the appropriate order to be imported into a new Web3
         instance (reversed _queue order) as a list of (middleware, name) tuples.
         """
         return [(val, key) for key, val in reversed(self._queue.items())]
@@ -301,24 +301,24 @@ class NamedElementOnion(Mapping[TKey, TValue]):
 
     # --- iter and tupleize methods --- #
 
-    def _reversed_middlewares(self) -> Iterator[TValue]:
+    def _reversed_middleware(self) -> Iterator[TValue]:
         elements = self._queue.values()
         if not isinstance(elements, Sequence):
             # type ignored b/c elements is set as _OrderedDictValuesView[Any] on 210
             elements = list(elements)  # type: ignore
         return reversed(elements)
 
-    def as_tuple_of_middlewares(self) -> Tuple[TValue, ...]:
+    def as_tuple_of_middleware(self) -> Tuple[TValue, ...]:
         """
         This helps with type hinting since we return `Iterator[TKey]` type, though it's
         actually a `Iterator[TValue]` type, for the `__iter__()` method. This is in
         order to satisfy the `Mapping` interface.
         """
-        return tuple(self._reversed_middlewares())
+        return tuple(self._reversed_middleware())
 
     def __iter__(self) -> Iterator[TKey]:
         # ``__iter__()`` for a ``Mapping``  returns ``Iterator[TKey]`` but this
         # implementation returns ``Iterator[TValue]`` on reversed values (not keys).
         # This leads to typing issues, so it's better to use
-        # ``as_tuple_of_middlewares()`` to achieve the same result.
-        return iter(self._reversed_middlewares())  # type: ignore
+        # ``as_tuple_of_middleware()`` to achieve the same result.
+        return iter(self._reversed_middleware())  # type: ignore

{web3-7.0.0b1 → web3-7.0.0b2}/web3/main.py

@@ -1,5 +1,4 @@
 import decimal
-import warnings
 from types import (
     TracebackType,
 )
@@ -142,7 +141,6 @@ from web3.types import (
 )
 
 if TYPE_CHECKING:
-    from web3.pm import PM  # noqa: F401
     from web3._utils.empty import Empty  # noqa: F401
 
 
@@ -338,30 +336,6 @@ class BaseWeb3:
     def is_encodable(self, _type: TypeStr, value: Any) -> bool:
         return self.codec.is_encodable(_type, value)
 
-    @property
-    def pm(self) -> "PM":
-        if hasattr(self, "_pm"):
-            # ignored b/c property is dynamically set
-            # via enable_unstable_package_management_api
-            return self._pm
-        else:
-            raise AttributeError(
-                "The Package Management feature is disabled by default until "
-                "its API stabilizes. To use these features, please enable them by "
-                "running `w3.enable_unstable_package_management_api()` and try again."
-            )
-
-    def enable_unstable_package_management_api(self) -> None:
-        if not hasattr(self, "_pm"):
-            warnings.warn(
-                "The ``ethPM`` module is no longer being maintained and will be "
-                "deprecated with ``web3.py`` version 7",
-                UserWarning,
-            )
-            from web3.pm import PM  # noqa: F811
-
-            self.attach_modules({"_pm": PM})
-
 
 class Web3(BaseWeb3):
     # mypy types
@@ -378,14 +352,14 @@ class Web3(BaseWeb3):
     def __init__(
         self,
         provider: Optional[BaseProvider] = None,
-        middlewares: Optional[Sequence[Any]] = None,
+        middleware: Optional[Sequence[Any]] = None,
         modules: Optional[Dict[str, Union[Type[Module], Sequence[Any]]]] = None,
         external_modules: Optional[
             Dict[str, Union[Type[Module], Sequence[Any]]]
         ] = None,
         ens: Union[ENS, "Empty"] = empty,
     ) -> None:
-        self.manager = self.RequestManager(self, provider, middlewares)
+        self.manager = self.RequestManager(self, provider, middleware)
         self.codec = ABICodec(build_strict_registry())
 
         if modules is None:
@@ -446,14 +420,14 @@ class AsyncWeb3(BaseWeb3):
     def __init__(
         self,
         provider: Optional[AsyncBaseProvider] = None,
-        middlewares: Optional[Sequence[Any]] = None,
+        middleware: Optional[Sequence[Any]] = None,
         modules: Optional[Dict[str, Union[Type[Module], Sequence[Any]]]] = None,
         external_modules: Optional[
             Dict[str, Union[Type[Module], Sequence[Any]]]
         ] = None,
         ens: Union[AsyncENS, "Empty"] = empty,
     ) -> None:
-        self.manager = self.RequestManager(self, provider, middlewares)
+        self.manager = self.RequestManager(self, provider, middleware)
         self.codec = ABICodec(build_strict_registry())
 
         self._modules = get_async_default_modules() if modules is None else modules

{web3-7.0.0b1 → web3-7.0.0b2}/web3/manager.py

@@ -125,7 +125,7 @@ class RequestManager:
         self,
         w3: Union["AsyncWeb3", "Web3"],
         provider: Optional[Union["BaseProvider", "AsyncBaseProvider"]] = None,
-        middlewares: Optional[Sequence[Tuple[Middleware, str]]] = None,
+        middleware: Optional[Sequence[Tuple[Middleware, str]]] = None,
     ) -> None:
         self.w3 = w3
 
@@ -134,10 +134,10 @@ class RequestManager:
         else:
             self.provider = provider
 
-        if middlewares is None:
-            middlewares = self.get_default_middlewares()
+        if middleware is None:
+            middleware = self.get_default_middleware()
 
-        self.middleware_onion = NamedElementOnion(middlewares)
+        self.middleware_onion = NamedElementOnion(middleware)
 
         if isinstance(provider, PersistentConnectionProvider):
             # set up the request processor to be able to properly process ordered
@@ -157,9 +157,9 @@ class RequestManager:
         self._provider = provider
 
     @staticmethod
-    def get_default_middlewares() -> List[Tuple[Middleware, str]]:
+    def get_default_middleware() -> List[Tuple[Middleware, str]]:
         """
-        List the default middlewares for the request manager.
+        List the default middleware for the request manager.
         Documentation should remain in sync with these defaults.
         """
         return [

{web3-7.0.0b1 → web3-7.0.0b2}/web3/middleware/__init__.py

@@ -11,6 +11,7 @@ from .attrdict import (
 )
 from .base import (
     Middleware,
+    Web3Middleware,
 )
 from .buffered_gas_estimate import (
     BufferedGasEstimateMiddleware,
@@ -58,8 +59,8 @@ if TYPE_CHECKING:
     )
 
 
-def combine_middlewares(
-    middlewares: Sequence[Middleware],
+def combine_middleware(
+    middleware: Sequence[Middleware],
     w3: "Web3",
     provider_request_fn: MakeRequestFn,
 ) -> Callable[..., "RPCResponse"]:
@@ -69,14 +70,14 @@ def combine_middlewares(
     the response through the response processors.
     """
     accumulator_fn = provider_request_fn
-    for middleware in reversed(middlewares):
+    for mw in reversed(middleware):
         # initialize the middleware and wrap the accumulator function down the stack
-        accumulator_fn = middleware(w3).wrap_make_request(accumulator_fn)
+        accumulator_fn = mw(w3).wrap_make_request(accumulator_fn)
     return accumulator_fn
 
 
-async def async_combine_middlewares(
-    middlewares: Sequence[Middleware],
+async def async_combine_middleware(
+    middleware: Sequence[Middleware],
     async_w3: "AsyncWeb3",
     provider_request_fn: AsyncMakeRequestFn,
 ) -> Callable[..., Coroutine[Any, Any, "RPCResponse"]]:
@@ -86,8 +87,8 @@ async def async_combine_middlewares(
     the response through the response processors.
     """
     accumulator_fn = provider_request_fn
-    for middleware in reversed(middlewares):
+    for mw in reversed(middleware):
         # initialize the middleware and wrap the accumulator function down the stack
-        initialized = middleware(async_w3)
+        initialized = mw(async_w3)
         accumulator_fn = await initialized.async_wrap_make_request(accumulator_fn)
     return accumulator_fn

{web3-7.0.0b1 → web3-7.0.0b2}/web3/module.py

@@ -129,7 +129,7 @@ def retrieve_async_method_call_fn(
 
 #  Module should no longer have access to the full web3 api.
 #  Only the calling functions need access to the request methods.
-#  Any "re-entrant" shenanigans can go in the middlewares, which do
+#  Any "re-entrant" shenanigans can go in the middleware, which do
 #  have web3 access.
 class Module:
     is_async = False

{web3-7.0.0b1 → web3-7.0.0b2}/web3/providers/async_base.py

@@ -28,7 +28,7 @@ from web3.exceptions import (
     ProviderConnectionError,
 )
 from web3.middleware import (
-    async_combine_middlewares,
+    async_combine_middleware,
 )
 from web3.middleware.base import (
     Middleware,
@@ -95,14 +95,14 @@ class AsyncBaseProvider:
     async def request_func(
         self, async_w3: "AsyncWeb3", middleware_onion: MiddlewareOnion
     ) -> Callable[..., Coroutine[Any, Any, RPCResponse]]:
-        middlewares: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middlewares()
+        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._request_func_cache[0]
-        if cache_key != middlewares:
+        if cache_key != middleware:
             self._request_func_cache = (
-                middlewares,
-                await async_combine_middlewares(
-                    middlewares=middlewares,
+                middleware,
+                await async_combine_middleware(
+                    middleware=middleware,
                     async_w3=async_w3,
                     provider_request_fn=self.make_request,
                 ),

{web3-7.0.0b1 → web3-7.0.0b2}/web3/providers/base.py

@@ -25,7 +25,7 @@ from web3.exceptions import (
     ProviderConnectionError,
 )
 from web3.middleware import (
-    combine_middlewares,
+    combine_middleware,
 )
 from web3.middleware.base import (
     Middleware,
@@ -61,7 +61,7 @@ CACHEABLE_REQUESTS = cast(
 
 
 class BaseProvider:
-    # a tuple of (middlewares, request_func)
+    # a tuple of (middleware, request_func)
     _request_func_cache: Tuple[Tuple[Middleware, ...], Callable[..., RPCResponse]] = (
         None,
         None,
@@ -86,19 +86,19 @@ class BaseProvider:
     ) -> Callable[..., RPCResponse]:
         """
         @param w3 is the web3 instance
-        @param middleware_onion is an iterable of middlewares,
+        @param middleware_onion is an iterable of middleware,
             ordered by first to execute
         @returns a function that calls all the middleware and
             eventually self.make_request()
         """
-        middlewares: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middlewares()
+        middleware: Tuple[Middleware, ...] = middleware_onion.as_tuple_of_middleware()
 
         cache_key = self._request_func_cache[0]
-        if cache_key != middlewares:
+        if cache_key != middleware:
             self._request_func_cache = (
-                middlewares,
-                combine_middlewares(
-                    middlewares=middlewares,
+                middleware,
+                combine_middleware(
+                    middleware=middleware,
                     w3=w3,
                     provider_request_fn=self.make_request,
                 ),