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

web3/_utils/module_testing/eth_module.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 import math
 import pytest
@@ -5,7 +6,6 @@ from random import (
     randint,
 )
 import re
-import time
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -42,9 +42,6 @@ from hexbytes import (
     HexBytes,
 )
 
-from web3._utils.empty import (
-    empty,
-)
 from web3._utils.ens import (
     ens_addresses,
 )
@@ -882,7 +879,8 @@ class AsyncEthModuleTest:
         async_math_contract: "AsyncContract",
         params: StateOverrideParams,
     ) -> None:
-        txn_params: TxParams = {"from": await async_w3.eth.coinbase}
+        accounts = await async_w3.eth.accounts
+        txn_params: TxParams = {"from": accounts[0]}
 
         # assert does not raise
         await async_w3.eth.estimate_gas(
@@ -978,9 +976,8 @@ class AsyncEthModuleTest:
     async def test_eth_getBlockByNumber_latest(
         self, async_w3: "AsyncWeb3", async_empty_block: BlockData
     ) -> None:
-        current_block_number = await async_w3.eth.block_number
         block = await async_w3.eth.get_block("latest")
-        assert block["number"] == current_block_number
+        assert block["hash"] is not None
 
     @pytest.mark.asyncio
     async def test_eth_getBlockByNumber_not_found(
@@ -993,9 +990,8 @@ class AsyncEthModuleTest:
     async def test_eth_getBlockByNumber_pending(
         self, async_w3: "AsyncWeb3", async_empty_block: BlockData
     ) -> None:
-        current_block_number = await async_w3.eth.block_number
         block = await async_w3.eth.get_block("pending")
-        assert block["number"] == current_block_number + 1
+        assert block["hash"] is None
 
     @pytest.mark.asyncio
     async def test_eth_getBlockByNumber_earliest(
@@ -1087,7 +1083,6 @@ class AsyncEthModuleTest:
         async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
         # eth_getRawTransactionByBlockNumberAndIndex: block identifier
-        # send a txn to make sure pending block has at least one txn
         await async_w3.eth.send_transaction(
             {
                 "from": async_keyfile_account_address_dual_type,
@@ -1095,11 +1090,16 @@ class AsyncEthModuleTest:
                 "value": Wei(1),
             }
         )
-        pending_block = await async_w3.eth.get_block("pending")
-        last_pending_txn_index = len(pending_block["transactions"]) - 1
-        raw_txn = await async_w3.eth.get_raw_transaction_by_block(
-            "pending", last_pending_txn_index
-        )
+
+        async def wait_for_block_with_txn() -> HexBytes:
+            while True:
+                try:
+                    return await async_w3.eth.get_raw_transaction_by_block("latest", 0)
+                except TransactionNotFound:
+                    await asyncio.sleep(0.1)
+                    continue
+
+        raw_txn = await asyncio.wait_for(wait_for_block_with_txn(), timeout=5)
         assert is_bytes(raw_txn)
 
         # eth_getRawTransactionByBlockNumberAndIndex: block number
@@ -1149,14 +1149,15 @@ class AsyncEthModuleTest:
 
     @pytest.mark.asyncio
     async def test_eth_get_balance(self, async_w3: "AsyncWeb3") -> None:
-        coinbase = await async_w3.eth.coinbase
+        accounts = await async_w3.eth.accounts
+        account = accounts[0]
 
         with pytest.raises(InvalidAddress):
             await async_w3.eth.get_balance(
-                ChecksumAddress(HexAddress(HexStr(coinbase.lower())))
+                ChecksumAddress(HexAddress(HexStr(account.lower())))
             )
 
-        balance = await async_w3.eth.get_balance(coinbase)
+        balance = await async_w3.eth.get_balance(account)
 
         assert is_integer(balance)
         assert balance >= 0
@@ -1209,7 +1210,7 @@ class AsyncEthModuleTest:
         assert len(access_list) > 0
         assert access_list[0]["address"] is not None
         assert is_checksum_address(access_list[0]["address"])
-        assert len(access_list[0]["storageKeys"][0]) == 32
+        assert len(access_list[0]["storageKeys"][0]) == 66
         assert int(response["gasUsed"]) >= 0
 
         # assert the result can be used directly in a transaction dict
@@ -1235,11 +1236,13 @@ class AsyncEthModuleTest:
     async def test_eth_call(
         self, async_w3: "AsyncWeb3", async_math_contract: "AsyncContract"
     ) -> None:
-        coinbase = await async_w3.eth.coinbase
+        accounts = await async_w3.eth.accounts
+        account = accounts[0]
+
         txn_params = async_math_contract._prepare_transaction(
             fn_name="add",
             fn_args=(7, 11),
-            transaction={"from": coinbase, "to": async_math_contract.address},
+            transaction={"from": account, "to": async_math_contract.address},
         )
         call_result = await async_w3.eth.call(txn_params)
         assert is_string(call_result)
@@ -1252,10 +1255,11 @@ class AsyncEthModuleTest:
         async_w3: "AsyncWeb3",
         async_revert_contract: "AsyncContract",
     ) -> None:
-        coinbase = await async_w3.eth.coinbase
+        accounts = await async_w3.eth.accounts
+        account = accounts[0]
         txn_params = async_revert_contract._prepare_transaction(
             fn_name="normalFunction",
-            transaction={"from": coinbase, "to": async_revert_contract.address},
+            transaction={"from": account, "to": async_revert_contract.address},
         )
         call_result = await async_w3.eth.call(txn_params)
         (result,) = async_w3.codec.decode(["bool"], call_result)
@@ -1309,8 +1313,8 @@ class AsyncEthModuleTest:
         async_math_contract: "AsyncContract",
         params: StateOverrideParams,
     ) -> None:
-        coinbase = await async_w3.eth.coinbase
-        txn_params: TxParams = {"from": coinbase}
+        accounts = await async_w3.eth.accounts
+        txn_params: TxParams = {"from": accounts[0]}
 
         # assert does not raise
         await async_w3.eth.call(
@@ -1321,11 +1325,11 @@ class AsyncEthModuleTest:
     async def test_eth_call_with_0_result(
         self, async_w3: "AsyncWeb3", async_math_contract: "AsyncContract"
     ) -> None:
-        coinbase = await async_w3.eth.coinbase
+        accounts = await async_w3.eth.accounts
         txn_params = async_math_contract._prepare_transaction(
             fn_name="add",
             fn_args=(0, 0),
-            transaction={"from": coinbase, "to": async_math_contract.address},
+            transaction={"from": accounts[0], "to": async_math_contract.address},
         )
         call_result = await async_w3.eth.call(txn_params)
         assert is_string(call_result)
@@ -1661,23 +1665,12 @@ class AsyncEthModuleTest:
         with pytest.raises(TooManyRequests, match="Too many CCIP read redirects"):
             await async_offchain_lookup_contract.caller().continuousOffchainLookup()  # noqa: E501 type: ignore
 
-    @pytest.mark.asyncio
-    async def test_async_eth_hashrate(self, async_w3: "AsyncWeb3") -> None:
-        hashrate = await async_w3.eth.hashrate
-        assert is_integer(hashrate)
-        assert hashrate >= 0
-
     @pytest.mark.asyncio
     async def test_async_eth_chain_id(self, async_w3: "AsyncWeb3") -> None:
         chain_id = await async_w3.eth.chain_id
         # chain id value from geth fixture genesis file
         assert chain_id == 131277322940537
 
-    @pytest.mark.asyncio
-    async def test_async_eth_mining(self, async_w3: "AsyncWeb3") -> None:
-        mining = await async_w3.eth.mining
-        assert is_boolean(mining)
-
     @pytest.mark.asyncio
     async def test_async_eth_get_transaction_receipt_mined(
         self,
@@ -1818,7 +1811,6 @@ class AsyncEthModuleTest:
         assert is_list_like(accounts)
         assert len(accounts) != 0
         assert all(is_checksum_address(account) for account in accounts)
-        assert await async_w3.eth.coinbase in accounts
 
     @pytest.mark.asyncio
     async def test_async_eth_get_logs_without_logs(
@@ -2028,10 +2020,10 @@ class AsyncEthModuleTest:
     async def test_async_eth_get_storage_at_invalid_address(
         self, async_w3: "AsyncWeb3"
     ) -> None:
-        coinbase = await async_w3.eth.coinbase
+        accounts = await async_w3.eth.accounts
         with pytest.raises(InvalidAddress):
             await async_w3.eth.get_storage_at(
-                ChecksumAddress(HexAddress(HexStr(coinbase.lower()))), 0
+                ChecksumAddress(HexAddress(HexStr(accounts[0].lower()))), 0
             )
 
     def test_async_provider_default_account(
@@ -2039,9 +2031,7 @@ class AsyncEthModuleTest:
         async_w3: "AsyncWeb3",
         async_keyfile_account_address_dual_type: ChecksumAddress,
     ) -> None:
-        # check defaults to empty
-        default_account = async_w3.eth.default_account
-        assert default_account is empty
+        current_default_account = async_w3.eth.default_account
 
         # check setter
         async_w3.eth.default_account = async_keyfile_account_address_dual_type
@@ -2049,7 +2039,7 @@ class AsyncEthModuleTest:
         assert default_account == async_keyfile_account_address_dual_type
 
         # reset to default
-        async_w3.eth.default_account = empty
+        async_w3.eth.default_account = current_default_account
 
     def test_async_provider_default_block(
         self,
@@ -2517,19 +2507,6 @@ class EthModuleTest:
             assert is_integer(sync_dict["currentBlock"])
             assert is_integer(sync_dict["highestBlock"])
 
-    def test_eth_coinbase(self, w3: "Web3") -> None:
-        coinbase = w3.eth.coinbase
-        assert is_checksum_address(coinbase)
-
-    def test_eth_mining(self, w3: "Web3") -> None:
-        mining = w3.eth.mining
-        assert is_boolean(mining)
-
-    def test_eth_hashrate(self, w3: "Web3") -> None:
-        hashrate = w3.eth.hashrate
-        assert is_integer(hashrate)
-        assert hashrate >= 0
-
     def test_eth_chain_id(self, w3: "Web3") -> None:
         chain_id = w3.eth.chain_id
         # chain id value from geth fixture genesis file
@@ -2597,7 +2574,6 @@ class EthModuleTest:
         assert is_list_like(accounts)
         assert len(accounts) != 0
         assert all(is_checksum_address(account) for account in accounts)
-        assert w3.eth.coinbase in accounts
 
     def test_eth_block_number(self, w3: "Web3") -> None:
         block_number = w3.eth.block_number
@@ -2610,12 +2586,12 @@ class EthModuleTest:
         assert block_number >= 0
 
     def test_eth_get_balance(self, w3: "Web3") -> None:
-        coinbase = w3.eth.coinbase
+        account = w3.eth.accounts[0]
 
         with pytest.raises(InvalidAddress):
-            w3.eth.get_balance(ChecksumAddress(HexAddress(HexStr(coinbase.lower()))))
+            w3.eth.get_balance(ChecksumAddress(HexAddress(HexStr(account.lower()))))
 
-        balance = w3.eth.get_balance(coinbase)
+        balance = w3.eth.get_balance(account)
 
         assert is_integer(balance)
         assert balance >= 0
@@ -2677,10 +2653,10 @@ class EthModuleTest:
             assert storage == HexBytes(f"0x{'00' * 31}01")
 
     def test_eth_get_storage_at_invalid_address(self, w3: "Web3") -> None:
-        coinbase = w3.eth.coinbase
+        account = w3.eth.accounts[0]
         with pytest.raises(InvalidAddress):
             w3.eth.get_storage_at(
-                ChecksumAddress(HexAddress(HexStr(coinbase.lower()))), 0
+                ChecksumAddress(HexAddress(HexStr(account.lower()))), 0
             )
 
     def test_eth_get_transaction_count(
@@ -2705,10 +2681,10 @@ class EthModuleTest:
             assert transaction_count >= 0
 
     def test_eth_get_transaction_count_invalid_address(self, w3: "Web3") -> None:
-        coinbase = w3.eth.coinbase
+        account = w3.eth.accounts[0]
         with pytest.raises(InvalidAddress):
             w3.eth.get_transaction_count(
-                ChecksumAddress(HexAddress(HexStr(coinbase.lower())))
+                ChecksumAddress(HexAddress(HexStr(account.lower())))
             )
 
     def test_eth_getBlockTransactionCountByHash_empty_block(
@@ -2810,7 +2786,7 @@ class EthModuleTest:
         assert len(access_list) > 0
         assert access_list[0]["address"] is not None
         assert is_checksum_address(access_list[0]["address"])
-        assert len(access_list[0]["storageKeys"][0]) == 32
+        assert len(access_list[0]["storageKeys"][0]) == 66
         assert int(response["gasUsed"]) >= 0
 
         # assert the result can be used directly in a transaction dict
@@ -3724,11 +3700,10 @@ class EthModuleTest:
         assert txn_hash == HexBytes(signed.hash)
 
     def test_eth_call(self, w3: "Web3", math_contract: "Contract") -> None:
-        coinbase = w3.eth.coinbase
         txn_params = math_contract._prepare_transaction(
             fn_name="add",
             fn_args=(7, 11),
-            transaction={"from": coinbase, "to": math_contract.address},
+            transaction={"from": w3.eth.accounts[0], "to": math_contract.address},
         )
         call_result = w3.eth.call(txn_params)
         assert is_string(call_result)
@@ -3738,10 +3713,9 @@ class EthModuleTest:
     def test_eth_call_with_override_code(
         self, w3: "Web3", revert_contract: "Contract"
     ) -> None:
-        coinbase = w3.eth.coinbase
         txn_params = revert_contract._prepare_transaction(
             fn_name="normalFunction",
-            transaction={"from": coinbase, "to": revert_contract.address},
+            transaction={"from": w3.eth.accounts[0], "to": revert_contract.address},
         )
         call_result = w3.eth.call(txn_params)
         (result,) = w3.codec.decode(["bool"], call_result)
@@ -3792,7 +3766,7 @@ class EthModuleTest:
         math_contract: "Contract",
         params: StateOverrideParams,
     ) -> None:
-        txn_params: TxParams = {"from": w3.eth.coinbase}
+        txn_params: TxParams = {"from": w3.eth.accounts[0]}
 
         # assert does not raise
         w3.eth.call(txn_params, "latest", {math_contract.address: params})
@@ -3800,11 +3774,10 @@ class EthModuleTest:
     def test_eth_call_with_0_result(
         self, w3: "Web3", math_contract: "Contract"
     ) -> None:
-        coinbase = w3.eth.coinbase
         txn_params = math_contract._prepare_transaction(
             fn_name="add",
             fn_args=(0, 0),
-            transaction={"from": coinbase, "to": math_contract.address},
+            transaction={"from": w3.eth.accounts[0], "to": math_contract.address},
         )
         call_result = w3.eth.call(txn_params)
         assert is_string(call_result)
@@ -4243,7 +4216,7 @@ class EthModuleTest:
         math_contract: "Contract",
         params: StateOverrideParams,
     ) -> None:
-        txn_params: TxParams = {"from": w3.eth.coinbase}
+        txn_params: TxParams = {"from": w3.eth.accounts[0]}
 
         # assert does not raise
         w3.eth.estimate_gas(txn_params, None, {math_contract.address: params})
@@ -4270,12 +4243,9 @@ class EthModuleTest:
         block = w3.eth.get_block(empty_block["number"])
         assert block["number"] == empty_block["number"]
 
-    def test_eth_getBlockByNumber_latest(
-        self, w3: "Web3", empty_block: BlockData
-    ) -> None:
-        current_block_number = w3.eth.block_number
+    def test_eth_getBlockByNumber_latest(self, w3: "Web3") -> None:
         block = w3.eth.get_block("latest")
-        assert block["number"] == current_block_number
+        assert block["hash"] is not None
 
     def test_eth_getBlockByNumber_not_found(
         self, w3: "Web3", empty_block: BlockData
@@ -4665,39 +4635,42 @@ class EthModuleTest:
         math_contract: "Contract",
         keyfile_account_address: ChecksumAddress,
     ) -> None:
-        latest_block = w3.eth.get_block("latest")
-        block_num = latest_block["number"]
-        block_hash = latest_block["hash"]
+        current_block = w3.eth.get_block("latest")
+        block_num = current_block["number"]
+        block_hash = current_block["hash"]
 
+        default_call_result = math_contract.functions.counter().call()
         latest_call_result = math_contract.functions.counter().call(
             block_identifier="latest"
         )
+
+        # increment counter and get tx receipt
+        tx_hash = math_contract.functions.incrementCounter().transact(
+            {"from": keyfile_account_address}
+        )
+        tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
+
+        # get new state value
+        post_state_block_num_call_result = math_contract.functions.counter().call(
+            block_identifier=tx_receipt["blockNumber"]
+        )
+
+        # call old state values with different block identifiers
         block_hash_call_result = math_contract.functions.counter().call(
             block_identifier=block_hash
         )
-        block_num_call_result = math_contract.functions.counter().call(
+        pre_state_block_num_call_result = math_contract.functions.counter().call(
             block_identifier=block_num
         )
-        default_call_result = math_contract.functions.counter().call()
-
-        # send and wait 1 second to mine
-        math_contract.functions.incrementCounter().transact(
-            {"from": keyfile_account_address}
-        )
-        time.sleep(1)
 
-        pending_call_result = math_contract.functions.counter().call(
-            block_identifier="pending"
+        # assert old state values before incrementing counter
+        assert pre_state_block_num_call_result == post_state_block_num_call_result - 1
+        assert (
+            pre_state_block_num_call_result
+            == block_hash_call_result
+            == default_call_result
+            == latest_call_result
         )
-        assert block_hash_call_result == 0
-        assert block_num_call_result == 0
-        assert latest_call_result == 0
-        assert default_call_result == 0
-
-        if pending_call_result != 1:
-            raise AssertionError(
-                f"pending call result was {pending_call_result} instead of 1"
-            )
 
     def test_eth_uninstall_filter(self, w3: "Web3") -> None:
         filter = w3.eth.filter({})
@@ -4726,7 +4699,6 @@ class EthModuleTest:
         block_with_txn: BlockData,
     ) -> None:
         # eth_getRawTransactionByBlockNumberAndIndex: block identifier
-        # send a txn to make sure pending block has at least one txn
         w3.eth.send_transaction(
             {
                 "from": keyfile_account_address_dual_type,
@@ -4734,10 +4706,13 @@ class EthModuleTest:
                 "value": Wei(1),
             }
         )
-        last_pending_txn_index = len(w3.eth.get_block("pending")["transactions"]) - 1
-        raw_transaction = w3.eth.get_raw_transaction_by_block(
-            "pending", last_pending_txn_index
-        )
+        raw_transaction = None
+        while not raw_transaction:
+            try:
+                raw_transaction = w3.eth.get_raw_transaction_by_block("latest", 0)
+            except TransactionNotFound:
+                continue
+
         assert is_bytes(raw_transaction)
 
         # eth_getRawTransactionByBlockNumberAndIndex: block number
@@ -4781,9 +4756,7 @@ class EthModuleTest:
     def test_default_account(
         self, w3: "Web3", keyfile_account_address_dual_type: ChecksumAddress
     ) -> None:
-        # check defaults to empty
-        default_account = w3.eth.default_account
-        assert default_account is empty
+        current_default = w3.eth.default_account
 
         # check setter
         w3.eth.default_account = keyfile_account_address_dual_type
@@ -4791,7 +4764,7 @@ class EthModuleTest:
         assert default_account == keyfile_account_address_dual_type
 
         # reset to default
-        w3.eth.default_account = empty
+        w3.eth.default_account = current_default
 
     def test_default_block(
         self,

web3/_utils/module_testing/module_testing_utils.py

@@ -1,6 +1,4 @@
-from collections import (
-    deque,
-)
+import asyncio
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -13,6 +11,7 @@ from typing import (
 )
 
 from aiohttp import (
+    ClientSession,
     ClientTimeout,
 )
 from eth_typing import (
@@ -28,10 +27,10 @@ from flaky import (
 from hexbytes import (
     HexBytes,
 )
+import requests
 
-from web3._utils.request import (
-    async_cache_and_return_session,
-    cache_and_return_session,
+from web3._utils.http import (
+    DEFAULT_HTTP_TIMEOUT,
 )
 from web3.types import (
     BlockData,
@@ -40,7 +39,9 @@ from web3.types import (
 
 if TYPE_CHECKING:
     from _pytest.monkeypatch import MonkeyPatch  # noqa: F401
-    from aiohttp import ClientResponse  # noqa: F401
+    from aiohttp import (  # noqa: F401
+        ClientResponse,
+    )
     from requests import Response  # noqa: F401
 
     from web3 import Web3  # noqa: F401
@@ -102,13 +103,13 @@ 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"] == 30
+            assert kwargs["timeout"] == DEFAULT_HTTP_TIMEOUT
             if http_method.upper() == "POST":
                 assert kwargs["data"] == {"data": calldata, "sender": sender}
             return MockedResponse()
 
         # else, make a normal request (no mocking)
-        session = cache_and_return_session(url_from_args)
+        session = requests.Session()
         return session.request(method=http_method.upper(), url=url_from_args, **kwargs)
 
     monkeypatch.setattr(
@@ -152,16 +153,18 @@ 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(30)
+            assert kwargs["timeout"] == ClientTimeout(DEFAULT_HTTP_TIMEOUT)
             if http_method.upper() == "post":
                 assert kwargs["data"] == {"data": calldata, "sender": sender}
             return AsyncMockedResponse()
 
         # else, make a normal request (no mocking)
-        session = await async_cache_and_return_session(url_from_args)
-        return await session.request(
+        session = ClientSession()
+        response = await session.request(
             method=http_method.upper(), url=url_from_args, **kwargs
         )
+        await session.close()
+        return response
 
     monkeypatch.setattr(
         f"aiohttp.ClientSession.{http_method.lower()}", _mock_specific_request
@@ -174,7 +177,9 @@ class WebSocketMessageStreamMock:
     def __init__(
         self, messages: Collection[bytes] = None, raise_exception: Exception = None
     ) -> None:
-        self.messages = deque(messages) if messages else deque()
+        self.queue = asyncio.Queue()  # type: ignore  # py38 issue
+        for msg in messages or []:
+            self.queue.put_nowait(msg)
         self.raise_exception = raise_exception
 
     def __await__(self) -> Generator[Any, Any, "Self"]:
@@ -187,13 +192,12 @@ class WebSocketMessageStreamMock:
         return self
 
     async def __anext__(self) -> bytes:
+        return await self.queue.get()
+
+    async def recv(self) -> bytes:
         if self.raise_exception:
             raise self.raise_exception
-
-        elif len(self.messages) == 0:
-            raise StopAsyncIteration
-
-        return self.messages.popleft()
+        return await self.queue.get()
 
     @staticmethod
     async def pong() -> Literal[False]:

web3/_utils/module_testing/persistent_connection_provider.py

@@ -23,6 +23,7 @@ from web3.middleware import (
 )
 from web3.types import (
     FormattedEthSubscriptionResponse,
+    RPCEndpoint,
 )
 
 if TYPE_CHECKING:
@@ -31,6 +32,22 @@ if TYPE_CHECKING:
     )
 
 
+SOME_BLOCK_KEYS = [
+    "number",
+    "hash",
+    "parentHash",
+    "transactionsRoot",
+    "stateRoot",
+    "receiptsRoot",
+    "size",
+    "gasLimit",
+    "gasUsed",
+    "timestamp",
+    "transactions",
+    "baseFeePerGas",
+]
+
+
 class PersistentConnectionProviderTest:
     @pytest.mark.asyncio
     @pytest.mark.parametrize(
@@ -301,6 +318,7 @@ class PersistentConnectionProviderTest:
             assert response["result"] == expected_formatted_result
 
             # only testing one message, so break here
+            await async_w3.eth.unsubscribe(sub_id)
             break
 
     @pytest.mark.asyncio
@@ -371,22 +389,8 @@ class PersistentConnectionProviderTest:
         assert isinstance(pending, AttributeDict)
 
         # assert block values
-        some_block_keys = [
-            "number",
-            "hash",
-            "parentHash",
-            "transactionsRoot",
-            "stateRoot",
-            "receiptsRoot",
-            "size",
-            "gasLimit",
-            "gasUsed",
-            "timestamp",
-            "transactions",
-            "baseFeePerGas",
-        ]
-        assert all(k in latest.keys() for k in some_block_keys)
-        assert all(k in pending.keys() for k in some_block_keys)
+        assert all(k in latest.keys() for k in SOME_BLOCK_KEYS)
+        assert all(k in pending.keys() for k in SOME_BLOCK_KEYS)
 
         assert isinstance(block_num, int)
         assert latest["number"] == block_num
@@ -394,3 +398,28 @@ class PersistentConnectionProviderTest:
         assert isinstance(chain_id, int)
         assert isinstance(chain_id2, int)
         assert isinstance(chain_id3, int)
+
+    @pytest.mark.asyncio
+    async def test_public_socket_api(self, async_w3: "AsyncWeb3") -> None:
+        # send a request over the socket
+        await async_w3.socket.send(
+            RPCEndpoint("eth_getBlockByNumber"), ["latest", True]
+        )
+
+        # recv and validate the unprocessed response
+        response = await async_w3.socket.recv()
+        assert "id" in response, "Expected 'id' key in response."
+        assert "jsonrpc" in response, "Expected 'jsonrpc' key in response."
+        assert "result" in response, "Expected 'result' key in response."
+        assert all(k in response["result"].keys() for k in SOME_BLOCK_KEYS)
+        assert not isinstance(response["result"]["number"], int)  # assert not processed
+
+        # make a request over the socket
+        response = await async_w3.socket.make_request(
+            RPCEndpoint("eth_getBlockByNumber"), ["latest", True]
+        )
+        assert "id" in response, "Expected 'id' key in response."
+        assert "jsonrpc" in response, "Expected 'jsonrpc' key in response."
+        assert "result" in response, "Expected 'result' key in response."
+        assert all(k in response["result"].keys() for k in SOME_BLOCK_KEYS)
+        assert not isinstance(response["result"]["number"], int)  # assert not processed