web3 7.12.0__tar.gz → 7.13.0__tar.gz

{web3-7.12.0/web3.egg-info → web3-7.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: web3
-Version: 7.12.0
+Version: 7.13.0
 Summary: web3: A Python library for interacting with Ethereum
 Home-page: https://github.com/ethereum/web3.py
 Author: The Ethereum Foundation

{web3-7.12.0 → web3-7.13.0}/pyproject.toml

@@ -127,7 +127,7 @@ name = "Removals"
 showcontent = true
 
 [tool.bumpversion]
-current_version = "7.12.0"
+current_version = "7.13.0"
 parse = """
     (?P<major>\\d+)
     \\.(?P<minor>\\d+)

{web3-7.12.0 → web3-7.13.0}/setup.py

@@ -55,7 +55,7 @@ with open("./README.md") as readme:
 setup(
     name="web3",
     # *IMPORTANT*: Don't manually change the version here. See Contributing docs for the release process.
-    version="7.12.0",
+    version="7.13.0",
     description="""web3: A Python library for interacting with Ethereum""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{web3-7.12.0 → web3-7.13.0}/tests/core/eth-module/test_accounts.py

@@ -264,6 +264,7 @@ def test_eth_account_sign(
     acct, message_text, key, expected_bytes, expected_hash, v, r, s, signature
 ):
     message = encode_defunct(text=message_text)
+    assert message.body == expected_bytes
     signed_message = Web3.keccak(
         b"\x19Ethereum Signed Message:\n"
         + bytes(f"{len(message.body)}", encoding="utf-8")
@@ -357,9 +358,9 @@ def test_eth_account_sign(
         ),
         (
             {
-                "gas": 100000,
-                "maxFeePerGas": 2000000000,
-                "maxPriorityFeePerGas": 2000000000,
+                "gas": "0x186a0",
+                "maxFeePerGas": "0x77359400",
+                "maxPriorityFeePerGas": "0x77359400",
                 "data": "0x5544",
                 "nonce": "0x2",
                 "to": "0x96216849c49358B10257cb55b28eA603c874b05E",

web3-7.13.0/tests/core/middleware/test_formatting_middleware.py

@@ -0,0 +1,236 @@
+import pytest
+from unittest.mock import (
+    Mock,
+)
+
+import pytest_asyncio
+
+from web3 import (
+    AsyncBaseProvider,
+    AsyncWeb3,
+    Web3,
+)
+from web3.exceptions import (
+    BadResponseFormat,
+    Web3RPCError,
+)
+from web3.middleware import (
+    FormattingMiddlewareBuilder,
+)
+from web3.providers.base import (
+    BaseProvider,
+)
+from web3.types import (
+    RPCEndpoint,
+)
+
+
+class DummyProvider(BaseProvider):
+    def make_request(self, method, params):
+        raise NotImplementedError(f"Cannot make request for {method}:{params}")
+
+
+@pytest.fixture
+def w3():
+    return Web3(provider=DummyProvider(), middleware=[])
+
+
+def test_formatting_middleware(w3, request_mocker):
+    # No formatters by default
+    expected = "done"
+    with request_mocker(w3, mock_results={"test_endpoint": "done"}):
+        actual = w3.manager.request_blocking(RPCEndpoint("test_endpoint"), [])
+        assert actual == expected
+
+
+def test_formatting_middleware_no_method(w3):
+    w3.middleware_onion.add(FormattingMiddlewareBuilder.build())
+
+    # Formatting middleware requires an endpoint
+    with pytest.raises(NotImplementedError):
+        w3.manager.request_blocking("test_endpoint", [])
+
+
+def test_formatting_middleware_request_formatters(w3, request_mocker):
+    callable_mock = Mock()
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            request_formatters={"test_endpoint": callable_mock}
+        )
+    )
+
+    expected = "done"
+    with request_mocker(w3, mock_results={"test_endpoint": "done"}):
+        actual = w3.manager.request_blocking("test_endpoint", ["param1"])
+
+    callable_mock.assert_called_once_with(["param1"])
+    assert actual == expected
+
+
+def test_formatting_middleware_result_formatters(w3, request_mocker):
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: f"STATUS: {x}"}
+        )
+    )
+
+    expected = "STATUS: done"
+    with request_mocker(w3, mock_results={"test_endpoint": "done"}):
+        actual = w3.manager.request_blocking("test_endpoint", [])
+
+    assert actual == expected
+
+
+def test_formatting_middleware_result_formatters_for_none(w3, request_mocker):
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: hex(x)}
+        )
+    )
+
+    expected = None
+    with request_mocker(w3, mock_results={"test_endpoint": expected}):
+        actual = w3.manager.request_blocking("test_endpoint", [])
+    assert actual == expected
+
+
+def test_formatting_middleware_error_formatters(w3, request_mocker):
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: f"STATUS: {x}"}
+        )
+    )
+
+    expected = "error"
+    with request_mocker(w3, mock_errors={"test_endpoint": {"message": "error"}}):
+        with pytest.raises(Web3RPCError) as err:
+            w3.manager.request_blocking("test_endpoint", [])
+            assert str(err.value) == expected
+
+
+def test_formatting_middleware_raises_for_non_dict_responses(w3, request_mocker):
+    w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: x}
+        )
+    )
+    w3.provider.make_request = lambda *_: "a string"
+
+    with pytest.raises(
+        BadResponseFormat,
+        match=r"Malformed response: expected a valid JSON-RPC response object, "
+        r"got: `a string`",
+    ):
+        _ = w3.eth.chain_id
+
+
+# -- async -- #
+
+
+@pytest_asyncio.fixture
+async def async_w3():
+    return AsyncWeb3(provider=AsyncBaseProvider(), middleware=[])
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware(async_w3, request_mocker):
+    # No formatters by default
+    expected = "done"
+    async with request_mocker(async_w3, mock_results={"test_endpoint": "done"}):
+        actual = await async_w3.manager.coro_request(RPCEndpoint("test_endpoint"), [])
+        assert actual == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_no_method(async_w3):
+    async_w3.middleware_onion.add(FormattingMiddlewareBuilder.build())
+
+    # Formatting middleware requires an endpoint
+    with pytest.raises(NotImplementedError):
+        await async_w3.manager.coro_request("test_endpoint", [])
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_request_formatters(async_w3, request_mocker):
+    callable_mock = Mock()
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            request_formatters={"test_endpoint": callable_mock}
+        )
+    )
+
+    expected = "done"
+    async with request_mocker(async_w3, mock_results={"test_endpoint": "done"}):
+        actual = await async_w3.manager.coro_request("test_endpoint", ["param1"])
+
+    callable_mock.assert_called_once_with(["param1"])
+    assert actual == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_result_formatters(async_w3, request_mocker):
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: f"STATUS: {x}"}
+        )
+    )
+
+    expected = "STATUS: done"
+    async with request_mocker(async_w3, mock_results={"test_endpoint": "done"}):
+        actual = await async_w3.manager.coro_request("test_endpoint", [])
+
+    assert actual == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_result_formatters_for_none(
+    async_w3, request_mocker
+):
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: hex(x)}
+        )
+    )
+
+    expected = None
+    async with request_mocker(async_w3, mock_results={"test_endpoint": expected}):
+        actual = await async_w3.manager.coro_request("test_endpoint", [])
+    assert actual == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_error_formatters(async_w3, request_mocker):
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: f"STATUS: {x}"}
+        )
+    )
+
+    expected = "error"
+    async with request_mocker(
+        async_w3, mock_errors={"test_endpoint": {"message": "error"}}
+    ):
+        with pytest.raises(Web3RPCError) as err:
+            await async_w3.manager.coro_request("test_endpoint", [])
+            assert str(err.value) == expected
+
+
+@pytest.mark.asyncio
+async def test_async_formatting_middleware_raises_for_non_dict_responses(async_w3):
+    async_w3.middleware_onion.add(
+        FormattingMiddlewareBuilder.build(
+            result_formatters={"test_endpoint": lambda x: x}
+        )
+    )
+
+    async def _make_request(*_):
+        return "a string"
+
+    async_w3.provider.make_request = _make_request
+
+    with pytest.raises(
+        BadResponseFormat,
+        match=r"Malformed response: expected a valid JSON-RPC response object, "
+        r"got: `a string`",
+    ):
+        _ = await async_w3.eth.chain_id