web3 7.0.0b6__py3-none-any.whl → 7.0.0b7__py3-none-any.whl

web3/eth/__init__.py

@@ -8,3 +8,10 @@ from .eth import (
     Contract,
     Eth,
 )
+
+__all__ = [
+    "AsyncEth",
+    "BaseEth",
+    "Contract",
+    "Eth",
+]

web3/eth/async_eth.py

@@ -127,17 +127,6 @@ class AsyncEth(BaseEth):
     async def accounts(self) -> Tuple[ChecksumAddress]:
         return await self._accounts()
 
-    # eth_hashrate
-
-    _hashrate: Method[Callable[[], Awaitable[int]]] = Method(
-        RPC.eth_hashrate,
-        is_property=True,
-    )
-
-    @property
-    async def hashrate(self) -> int:
-        return await self._hashrate()
-
     # eth_blockNumber
 
     get_block_number: Method[Callable[[], Awaitable[BlockNumber]]] = Method(
@@ -160,17 +149,6 @@ class AsyncEth(BaseEth):
     async def chain_id(self) -> int:
         return await self._chain_id()
 
-    # eth_coinbase
-
-    _coinbase: Method[Callable[[], Awaitable[ChecksumAddress]]] = Method(
-        RPC.eth_coinbase,
-        is_property=True,
-    )
-
-    @property
-    async def coinbase(self) -> ChecksumAddress:
-        return await self._coinbase()
-
     # eth_gasPrice
 
     _gas_price: Method[Callable[[], Awaitable[Wei]]] = Method(
@@ -206,17 +184,6 @@ class AsyncEth(BaseEth):
             )
             return await async_fee_history_priority_fee(self)
 
-    # eth_mining
-
-    _mining: Method[Callable[[], Awaitable[bool]]] = Method(
-        RPC.eth_mining,
-        is_property=True,
-    )
-
-    @property
-    async def mining(self) -> bool:
-        return await self._mining()
-
     # eth_syncing
 
     _syncing: Method[Callable[[], Awaitable[Union[SyncStatus, bool]]]] = Method(

web3/eth/eth.py

@@ -119,17 +119,6 @@ class Eth(BaseEth):
     def accounts(self) -> Tuple[ChecksumAddress]:
         return self._accounts()
 
-    # eth_hashrate
-
-    _hashrate: Method[Callable[[], int]] = Method(
-        RPC.eth_hashrate,
-        is_property=True,
-    )
-
-    @property
-    def hashrate(self) -> int:
-        return self._hashrate()
-
     # eth_blockNumber
 
     get_block_number: Method[Callable[[], BlockNumber]] = Method(
@@ -152,17 +141,6 @@ class Eth(BaseEth):
     def chain_id(self) -> int:
         return self._chain_id()
 
-    # eth_coinbase
-
-    _coinbase: Method[Callable[[], ChecksumAddress]] = Method(
-        RPC.eth_coinbase,
-        is_property=True,
-    )
-
-    @property
-    def coinbase(self) -> ChecksumAddress:
-        return self._coinbase()
-
     # eth_gasPrice
 
     _gas_price: Method[Callable[[], Wei]] = Method(
@@ -198,17 +176,6 @@ class Eth(BaseEth):
             )
             return fee_history_priority_fee(self)
 
-    # eth_mining
-
-    _mining: Method[Callable[[], bool]] = Method(
-        RPC.eth_mining,
-        is_property=True,
-    )
-
-    @property
-    def mining(self) -> bool:
-        return self._mining()
-
     # eth_syncing
 
     _syncing: Method[Callable[[], Union[SyncStatus, bool]]] = Method(
@@ -285,7 +252,8 @@ class Eth(BaseEth):
                 return self._call(transaction, block_identifier, state_override)
             except OffchainLookup as offchain_lookup:
                 durin_calldata = handle_offchain_lookup(
-                    offchain_lookup.payload, transaction
+                    offchain_lookup.payload,
+                    transaction,
                 )
                 transaction["data"] = durin_calldata
 
@@ -660,25 +628,6 @@ class Eth(BaseEth):
         mungers=[default_root_munger],
     )
 
-    # eth_submitHashrate
-
-    submit_hashrate: Method[Callable[[int, _Hash32], bool]] = Method(
-        RPC.eth_submitHashrate,
-        mungers=[default_root_munger],
-    )
-
-    # eth_getWork, eth_submitWork
-
-    get_work: Method[Callable[[], List[HexBytes]]] = Method(
-        RPC.eth_getWork,
-        is_property=True,
-    )
-
-    submit_work: Method[Callable[[int, _Hash32, _Hash32], bool]] = Method(
-        RPC.eth_submitWork,
-        mungers=[default_root_munger],
-    )
-
     @overload
     # type error: Overloaded function signatures 1 and 2 overlap with incompatible return types  # noqa: E501
     def contract(self, address: None = None, **kwargs: Any) -> Type[Contract]:  # type: ignore[overload-overlap]  # noqa: E501

web3/middleware/__init__.py

@@ -92,3 +92,20 @@ async def async_combine_middleware(
         initialized = mw(async_w3)
         accumulator_fn = await initialized.async_wrap_make_request(accumulator_fn)
     return accumulator_fn
+
+
+__all__ = [
+    "AttributeDictMiddleware",
+    "Middleware",
+    "Web3Middleware",
+    "BufferedGasEstimateMiddleware",
+    "LocalFilterMiddleware",
+    "FormattingMiddlewareBuilder",
+    "GasPriceStrategyMiddleware",
+    "ENSNameToAddressMiddleware",
+    "ExtraDataToPOAMiddleware",
+    "PythonicMiddleware",
+    "SignAndSendRawMiddlewareBuilder",
+    "StalecheckMiddlewareBuilder",
+    "ValidationMiddleware",
+]

web3/providers/__init__.py

@@ -8,6 +8,10 @@ from .base import (
     BaseProvider,
     JSONBaseProvider,
 )
+from .eth_tester import (
+    AsyncEthereumTesterProvider,
+    EthereumTesterProvider,
+)
 from .ipc import (
     IPCProvider,
 )
@@ -26,3 +30,20 @@ from .persistent import (
 from .auto import (
     AutoProvider,
 )
+
+__all__ = [
+    "AsyncBaseProvider",
+    "AsyncEthereumTesterProvider",
+    "AsyncHTTPProvider",
+    "AsyncIPCProvider",
+    "AutoProvider",
+    "BaseProvider",
+    "EthereumTesterProvider",
+    "HTTPProvider",
+    "IPCProvider",
+    "JSONBaseProvider",
+    "LegacyWebSocketProvider",
+    "PersistentConnection",
+    "PersistentConnectionProvider",
+    "WebSocketProvider",
+]

web3/providers/eth_tester/__init__.py

@@ -2,3 +2,8 @@ from .main import (
     AsyncEthereumTesterProvider,
     EthereumTesterProvider,
 )
+
+__all__ = [
+    "AsyncEthereumTesterProvider",
+    "EthereumTesterProvider",
+]

web3/providers/eth_tester/defaults.py

@@ -243,12 +243,6 @@ API_ENDPOINTS = {
     "eth": {
         "protocolVersion": static_return(63),
         "syncing": static_return(False),
-        "coinbase": compose(
-            operator.itemgetter(0),
-            call_eth_tester("get_accounts"),
-        ),
-        "mining": static_return(False),
-        "hashrate": static_return(0),
         "chainId": static_return(131277322940537),  # from fixture generation file
         "feeHistory": call_eth_tester("get_fee_history"),
         "maxPriorityFeePerGas": static_return(10**9),

web3/providers/eth_tester/middleware.py

@@ -59,7 +59,7 @@ if TYPE_CHECKING:
 
 
 def is_named_block(value: Any) -> bool:
-    return value in {"latest", "earliest", "pending", "safe", "finalized"}
+    return value in {"latest", "earliest", "safe", "finalized"}
 
 
 def is_hexstr(value: Any) -> bool:
@@ -334,9 +334,7 @@ result_formatters: Optional[Dict[RPCEndpoint, Callable[..., Any]]] = {
 
 
 def guess_from(w3: "Web3", _: TxParams) -> ChecksumAddress:
-    if w3.eth.coinbase:
-        return w3.eth.coinbase
-    elif w3.eth.accounts and len(w3.eth.accounts) > 0:
+    if w3.eth.accounts and len(w3.eth.accounts) > 0:
         return w3.eth.accounts[0]
 
     return None
@@ -360,11 +358,8 @@ def fill_default(
 async def async_guess_from(
     async_w3: "AsyncWeb3", _: TxParams
 ) -> Optional[ChecksumAddress]:
-    coinbase = await async_w3.eth.coinbase
     accounts = await async_w3.eth.accounts
-    if coinbase is not None:
-        return coinbase
-    elif accounts is not None and len(accounts) > 0:
+    if accounts is not None and len(accounts) > 0:
         return accounts[0]
     return None
 

web3/providers/persistent/__init__.py

@@ -13,3 +13,10 @@ from .async_ipc import (
 from .websocket import (
     WebSocketProvider,
 )
+
+__all__ = [
+    "PersistentConnectionProvider",
+    "PersistentConnection",
+    "AsyncIPCProvider",
+    "WebSocketProvider",
+]

web3/providers/rpc/__init__.py

@@ -4,3 +4,8 @@ from .async_rpc import (
 from .rpc import (
     HTTPProvider,
 )
+
+__all__ = [
+    "AsyncHTTPProvider",
+    "HTTPProvider",
+]

web3/providers/rpc/async_rpc.py

@@ -29,11 +29,6 @@ from web3._utils.empty import (
 from web3._utils.http import (
     construct_user_agent,
 )
-from web3._utils.request import (
-    async_cache_and_return_session as _async_cache_and_return_session,
-    async_make_post_request,
-    get_default_http_endpoint,
-)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
@@ -45,6 +40,9 @@ from ..._utils.batching import (
 from ..._utils.caching import (
     async_handle_request_caching,
 )
+from ..._utils.http_session_manager import (
+    HTTPSessionManager,
+)
 from ..async_base import (
     AsyncJSONBaseProvider,
 )
@@ -63,13 +61,17 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         self,
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
-        exception_retry_configuration: Union[
-            ExceptionRetryConfiguration, Empty
+        exception_retry_configuration: Optional[
+            Union[ExceptionRetryConfiguration, Empty]
         ] = empty,
         **kwargs: Any,
     ) -> None:
+        self._request_session_manager = HTTPSessionManager()
+
         if endpoint_uri is None:
-            self.endpoint_uri = get_default_http_endpoint()
+            self.endpoint_uri = (
+                self._request_session_manager.get_default_http_endpoint()
+            )
         else:
             self.endpoint_uri = URI(endpoint_uri)
 
@@ -79,7 +81,9 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         super().__init__(**kwargs)
 
     async def cache_async_session(self, session: ClientSession) -> ClientSession:
-        return await _async_cache_and_return_session(self.endpoint_uri, session)
+        return await self._request_session_manager.async_cache_and_return_session(
+            self.endpoint_uri, session
+        )
 
     def __str__(self) -> str:
         return f"RPC connection {self.endpoint_uri}"
@@ -123,7 +127,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
         ):
             for i in range(self.exception_retry_configuration.retries):
                 try:
-                    return await async_make_post_request(
+                    return await self._request_session_manager.async_make_post_request(
                         self.endpoint_uri, request_data, **self.get_request_kwargs()
                     )
                 except tuple(self.exception_retry_configuration.errors):
@@ -136,7 +140,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
                         raise
             return None
         else:
-            return await async_make_post_request(
+            return await self._request_session_manager.async_make_post_request(
                 self.endpoint_uri, request_data, **self.get_request_kwargs()
             )
 
@@ -159,7 +163,7 @@ class AsyncHTTPProvider(AsyncJSONBaseProvider):
     ) -> List[RPCResponse]:
         self.logger.debug(f"Making batch request HTTP - uri: `{self.endpoint_uri}`")
         request_data = self.encode_batch_rpc_request(batch_requests)
-        raw_response = await async_make_post_request(
+        raw_response = await self._request_session_manager.async_make_post_request(
             self.endpoint_uri, request_data, **self.get_request_kwargs()
         )
         self.logger.debug("Received batch response HTTP.")

web3/providers/rpc/rpc.py

@@ -27,11 +27,6 @@ from web3._utils.empty import (
 from web3._utils.http import (
     construct_user_agent,
 )
-from web3._utils.request import (
-    cache_and_return_session,
-    get_default_http_endpoint,
-    make_post_request,
-)
 from web3.types import (
     RPCEndpoint,
     RPCResponse,
@@ -43,6 +38,9 @@ from ..._utils.batching import (
 from ..._utils.caching import (
     handle_request_caching,
 )
+from ..._utils.http_session_manager import (
+    HTTPSessionManager,
+)
 from ..base import (
     JSONBaseProvider,
 )
@@ -67,13 +65,17 @@ class HTTPProvider(JSONBaseProvider):
         endpoint_uri: Optional[Union[URI, str]] = None,
         request_kwargs: Optional[Any] = None,
         session: Optional[Any] = None,
-        exception_retry_configuration: Union[
-            ExceptionRetryConfiguration, Empty
+        exception_retry_configuration: Optional[
+            Union[ExceptionRetryConfiguration, Empty]
         ] = empty,
         **kwargs: Any,
     ) -> None:
+        self._request_session_manager = HTTPSessionManager()
+
         if endpoint_uri is None:
-            self.endpoint_uri = get_default_http_endpoint()
+            self.endpoint_uri = (
+                self._request_session_manager.get_default_http_endpoint()
+            )
         else:
             self.endpoint_uri = URI(endpoint_uri)
 
@@ -81,7 +83,9 @@ class HTTPProvider(JSONBaseProvider):
         self._exception_retry_configuration = exception_retry_configuration
 
         if session:
-            cache_and_return_session(self.endpoint_uri, session)
+            self._request_session_manager.cache_and_return_session(
+                self.endpoint_uri, session
+            )
 
         super().__init__(**kwargs)
 
@@ -131,7 +135,7 @@ class HTTPProvider(JSONBaseProvider):
         ):
             for i in range(self.exception_retry_configuration.retries):
                 try:
-                    return make_post_request(
+                    return self._request_session_manager.make_post_request(
                         self.endpoint_uri, request_data, **self.get_request_kwargs()
                     )
                 except tuple(self.exception_retry_configuration.errors) as e:
@@ -144,7 +148,7 @@ class HTTPProvider(JSONBaseProvider):
                         raise e
             return None
         else:
-            return make_post_request(
+            return self._request_session_manager.make_post_request(
                 self.endpoint_uri, request_data, **self.get_request_kwargs()
             )
 
@@ -167,7 +171,7 @@ class HTTPProvider(JSONBaseProvider):
     ) -> List[RPCResponse]:
         self.logger.debug(f"Making batch request HTTP, uri: `{self.endpoint_uri}`")
         request_data = self.encode_batch_rpc_request(batch_requests)
-        raw_response = make_post_request(
+        raw_response = self._request_session_manager.make_post_request(
             self.endpoint_uri, request_data, **self.get_request_kwargs()
         )
         self.logger.debug("Received batch response HTTP.")

web3/providers/rpc/utils.py

@@ -19,9 +19,6 @@ REQUEST_RETRY_ALLOWLIST = [
     "evm",
     "eth_protocolVersion",
     "eth_syncing",
-    "eth_coinbase",
-    "eth_mining",
-    "eth_hashrate",
     "eth_chainId",
     "eth_gasPrice",
     "eth_accounts",

web3/tools/benchmark/main.py

@@ -108,13 +108,14 @@ def main(logger: logging.Logger, num_calls: int) -> None:
                 asyncio.set_event_loop(loop)
 
             # -- sync -- #
-            coinbase = w3_http.eth.coinbase
+            account = w3_http.eth.accounts[0]
 
             # -- async -- #
             async_w3_http = loop.run_until_complete(
                 build_async_w3_http(fixture.endpoint_uri)
             )
-            async_coinbase = loop.run_until_complete(async_w3_http.eth.coinbase)
+            async_accounts = loop.run_until_complete(async_w3_http.eth.accounts)
+            async_account = async_accounts[0]
 
             methods = [
                 {
@@ -126,17 +127,17 @@ def main(logger: logging.Logger, num_calls: int) -> None:
                 {
                     "name": "eth_sendTransaction",
                     "params": {},
-                    "exec": lambda w3_http=w3_http, coinbase=coinbase: w3_http.eth.send_transaction(  # noqa: E501
+                    "exec": lambda w3_http=w3_http, account=account: w3_http.eth.send_transaction(  # noqa: E501
                         {
                             "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
-                            "from": coinbase,
+                            "from": account,
                             "value": Wei(1),
                         }
                     ),
-                    "async_exec": lambda async_w3_http=async_w3_http, async_coinbase=async_coinbase: async_w3_http.eth.send_transaction(  # noqa: E501
+                    "async_exec": lambda async_w3_http=async_w3_http, async_account=async_account: async_w3_http.eth.send_transaction(  # noqa: E501
                         {
                             "to": "0xd3CdA913deB6f67967B99D67aCDFa1712C293601",
-                            "from": async_coinbase,
+                            "from": async_account,
                             "value": Wei(1),
                         }
                     ),

web3/tools/benchmark/node.py

@@ -24,7 +24,7 @@ from web3.tools.benchmark.utils import (
     kill_proc_gracefully,
 )
 
-GETH_FIXTURE_ZIP = "geth-1.13.14-fixture.zip"
+GETH_FIXTURE_ZIP = "geth-1.14.5-fixture.zip"
 
 
 class GethBenchmarkFixture:

web3/utils/__init__.py

@@ -3,17 +3,26 @@ NOTE: This is a public utility module. Any changes to these utility methods woul
 classify as breaking changes.
 """
 
-from .abi import (  # NOQA
+from .abi import (
     get_abi_input_names,
     get_abi_output_names,
 )
-from .address import get_create_address  # NOQA
-from .async_exception_handling import (  # NOQA
+from .address import get_create_address
+from .async_exception_handling import (
     async_handle_offchain_lookup,
 )
-from .caching import (  # NOQA
+from .caching import (
     SimpleCache,
 )
-from .exception_handling import (  # NOQA
+from .exception_handling import (
     handle_offchain_lookup,
 )
+
+__all__ = [
+    "SimpleCache",
+    "async_handle_offchain_lookup",
+    "get_abi_input_names",
+    "get_abi_output_names",
+    "get_create_address",
+    "handle_offchain_lookup",
+]

web3/utils/async_exception_handling.py

@@ -3,6 +3,10 @@ from typing import (
     Dict,
 )
 
+from aiohttp import (
+    ClientSession,
+    ClientTimeout,
+)
 from eth_abi import (
     abi,
 )
@@ -10,10 +14,8 @@ from eth_typing import (
     URI,
 )
 
-from web3._utils.request import (
-    async_get_json_from_client_response,
-    async_get_response_from_get_request,
-    async_get_response_from_post_request,
+from web3._utils.http import (
+    DEFAULT_HTTP_TIMEOUT,
 )
 from web3._utils.type_conversion import (
     to_bytes_if_hex,
@@ -41,6 +43,7 @@ async def async_handle_offchain_lookup(
             "`sender` value does not equal `to` address in transaction."
         )
 
+    session = ClientSession()
     for url in offchain_lookup_payload["urls"]:
         formatted_url = URI(
             str(url)
@@ -50,13 +53,17 @@ async def async_handle_offchain_lookup(
 
         try:
             if "{data}" in url and "{sender}" in url:
-                response = await async_get_response_from_get_request(formatted_url)
+                response = await session.get(
+                    formatted_url, timeout=ClientTimeout(DEFAULT_HTTP_TIMEOUT)
+                )
             elif "{sender}" in url:
-                response = await async_get_response_from_post_request(
+                response = await session.post(
                     formatted_url,
                     data={"data": formatted_data, "sender": formatted_sender},
+                    timeout=ClientTimeout(DEFAULT_HTTP_TIMEOUT),
                 )
             else:
+                await session.close()
                 raise Web3ValidationError("url not formatted properly.")
         except Exception:
             continue  # try next url if timeout or issues making the request
@@ -64,13 +71,15 @@ async def async_handle_offchain_lookup(
         if (
             400 <= response.status <= 499
         ):  # if request returns 400 error, raise exception
+            await session.close()
             response.raise_for_status()
         if not 200 <= response.status <= 299:  # if not 400 error, try next url
             continue
 
-        result = await async_get_json_from_client_response(response)
+        result = await response.json()
 
         if "data" not in result.keys():
+            await session.close()
             raise Web3ValidationError(
                 "Improperly formatted response for offchain lookup HTTP request"
                 " - missing 'data' field."
@@ -91,5 +100,8 @@ async def async_handle_offchain_lookup(
             ]
         )
 
+        await session.close()
         return encoded_data_with_function_selector
+
+    await session.close()
     raise MultipleFailedRequests("Offchain lookup failed for supplied urls.")

web3/utils/exception_handling.py

@@ -9,10 +9,10 @@ from eth_abi import (
 from eth_typing import (
     URI,
 )
+import requests
 
-from web3._utils.request import (
-    get_response_from_get_request,
-    get_response_from_post_request,
+from web3._utils.http import (
+    DEFAULT_HTTP_TIMEOUT,
 )
 from web3._utils.type_conversion import (
     to_bytes_if_hex,
@@ -40,6 +40,7 @@ def handle_offchain_lookup(
             "Returned `sender` value does not equal `to` address in transaction."
         )
 
+    session = requests.Session()
     for url in offchain_lookup_payload["urls"]:
         formatted_url = URI(
             str(url)
@@ -49,14 +50,15 @@ def handle_offchain_lookup(
 
         try:
             if "{data}" in url and "{sender}" in url:
-                response = get_response_from_get_request(formatted_url)
+                response = session.get(formatted_url, timeout=DEFAULT_HTTP_TIMEOUT)
             elif "{sender}" in url:
-                response = get_response_from_post_request(
+                response = session.post(
                     formatted_url,
                     data={
                         "data": formatted_data,
                         "sender": formatted_sender,
                     },
+                    timeout=DEFAULT_HTTP_TIMEOUT,
                 )
             else:
                 raise Web3ValidationError("url not formatted properly.")