web3 7.0.0b2__py3-none-any.whl → 7.7.0__py3-none-any.whl

web3/utils/address.py

@@ -9,6 +9,9 @@ from eth_utils import (
 )
 import rlp
 
+from web3.exceptions import (
+    Web3ValidationError,
+)
 from web3.types import (
     HexStr,
     Nonce,
@@ -30,6 +33,11 @@ def get_create2_address(
     Determine the resulting `CREATE2` opcode contract address for a sender, salt and
     bytecode.
     """
+    if len(to_bytes(hexstr=salt)) != 32:
+        raise Web3ValidationError(
+            f"`salt` must be 32 bytes, {len(to_bytes(hexstr=salt))} != 32"
+        )
+
     contract_address = keccak(
         b"\xff"
         + to_bytes(hexstr=sender)

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,27 +53,30 @@ 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)
-            elif "{sender}" in url:
-                response = await async_get_response_from_post_request(
-                    formatted_url,
-                    data={"data": formatted_data, "sender": formatted_sender},
+                response = await session.get(
+                    formatted_url, timeout=ClientTimeout(DEFAULT_HTTP_TIMEOUT)
                 )
             else:
-                raise Web3ValidationError("url not formatted properly.")
+                response = await session.post(
+                    formatted_url,
+                    json={"data": formatted_data, "sender": formatted_sender},
+                    timeout=ClientTimeout(DEFAULT_HTTP_TIMEOUT),
+                )
         except Exception:
             continue  # try next url if timeout or issues making the request
 
         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 +97,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/caching.py

@@ -1,6 +1,11 @@
+import asyncio
 from collections import (
     OrderedDict,
 )
+from enum import (
+    Enum,
+)
+import time
 from typing import (
     Any,
     Dict,
@@ -10,28 +15,31 @@ from typing import (
 )
 
 
+class RequestCacheValidationThreshold(Enum):
+    FINALIZED = "finalized"
+    SAFE = "safe"
+
+
 class SimpleCache:
     def __init__(self, size: int = 100):
         self._size = size
         self._data: OrderedDict[str, Any] = OrderedDict()
 
     def cache(self, key: str, value: Any) -> Tuple[Any, Dict[str, Any]]:
-        evicted_items = None
+        evicted_items = {}
         # If the key is already in the OrderedDict just update it
         # and don't evict any values. Ideally, we could still check to see
         # if there are too many items in the OrderedDict but that may rearrange
         # the order it should be unlikely that the size could grow over the limit
         if key not in self._data:
             while len(self._data) >= self._size:
-                if evicted_items is None:
-                    evicted_items = {}
                 k, v = self._data.popitem(last=False)
                 evicted_items[k] = v
         self._data[key] = value
 
         # Return the cached value along with the evicted items at the same time. No
         # need to reach back into the cache to grab the value.
-        return value, evicted_items
+        return value, evicted_items or None
 
     def get_cache_entry(self, key: str) -> Optional[Any]:
         return self._data[key] if key in self._data else None
@@ -48,8 +56,30 @@ class SimpleCache:
 
         return self._data.pop(key)
 
+    def popitem(self, last: bool = True) -> Tuple[str, Any]:
+        return self._data.popitem(last=last)
+
     def __contains__(self, key: str) -> bool:
         return key in self._data
 
     def __len__(self) -> int:
         return len(self._data)
+
+    # -- async utility methods -- #
+
+    async def async_await_and_popitem(
+        self, last: bool = True, timeout: float = 10.0
+    ) -> Tuple[str, Any]:
+        start = time.time()
+        end_time = start + timeout
+        while True:
+            await asyncio.sleep(0)
+            try:
+                return self.popitem(last=last)
+            except KeyError:
+                now = time.time()
+                if now >= end_time:
+                    raise asyncio.TimeoutError(
+                        "Timeout waiting for item to be available"
+                    )
+                await asyncio.sleep(min(0.1, end_time - now))

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,17 +50,13 @@ def handle_offchain_lookup(
 
         try:
             if "{data}" in url and "{sender}" in url:
-                response = get_response_from_get_request(formatted_url)
-            elif "{sender}" in url:
-                response = get_response_from_post_request(
+                response = session.get(formatted_url, timeout=DEFAULT_HTTP_TIMEOUT)
+            else:
+                response = session.post(
                     formatted_url,
-                    data={
-                        "data": formatted_data,
-                        "sender": formatted_sender,
-                    },
+                    json={"data": formatted_data, "sender": formatted_sender},
+                    timeout=DEFAULT_HTTP_TIMEOUT,
                 )
-            else:
-                raise Web3ValidationError("url not formatted properly.")
         except Exception:
             continue  # try next url if timeout or issues making the request
 

web3/utils/subscriptions.py

@@ -0,0 +1,285 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Sequence,
+    TypeVar,
+    Union,
+)
+
+from eth_typing import (
+    Address,
+    ChecksumAddress,
+    HexStr,
+)
+from hexbytes import (
+    HexBytes,
+)
+
+from web3.exceptions import (
+    Web3AttributeError,
+    Web3ValueError,
+)
+from web3.types import (
+    BlockData,
+    FilterParams,
+    LogReceipt,
+    SyncProgress,
+    TxData,
+)
+
+if TYPE_CHECKING:
+    from web3 import (
+        AsyncWeb3,
+    )
+    from web3.providers.persistent.subscription_manager import (
+        SubscriptionManager,
+    )
+    from web3.types import EthSubscriptionResult  # noqa: F401
+
+
+TSubscriptionResult = TypeVar("TSubscriptionResult", bound="EthSubscriptionResult")
+TSubscription = TypeVar("TSubscription", bound="EthSubscription[Any]")
+
+
+class EthSubscriptionContext(Generic[TSubscription, TSubscriptionResult]):
+    def __init__(
+        self,
+        async_w3: "AsyncWeb3",
+        subscription: TSubscription,
+        result: TSubscriptionResult,
+        **kwargs: Any,
+    ) -> None:
+        self.async_w3 = async_w3
+        self.subscription = subscription
+        self.result = result
+        self.__dict__.update(kwargs)
+
+    def __getattr__(self, item: str) -> Any:
+        if item in self.__dict__:
+            return self.__dict__[item]
+        raise Web3AttributeError(
+            f"'{self.__class__.__name__}' object has no attribute '{item}'"
+        )
+
+
+EthSubscriptionHandler = Callable[
+    [EthSubscriptionContext[Any, Any]], Coroutine[Any, Any, None]
+]
+
+
+def handler_wrapper(
+    handler: Optional[EthSubscriptionHandler],
+) -> Optional[EthSubscriptionHandler]:
+    """Wrap the handler to add bookkeeping and context creation."""
+    if handler is None:
+        return None
+
+    async def wrapped_handler(
+        context: EthSubscriptionContext[TSubscription, TSubscriptionResult],
+    ) -> None:
+        sub = context.subscription
+        sub.handler_call_count += 1
+        sub.manager.total_handler_calls += 1
+        sub.manager.logger.debug(
+            f"Subscription handler called.\n"
+            f"    label: {sub.label}\n"
+            f"    call count: {sub.handler_call_count}\n"
+            f"    total handler calls: {sub.manager.total_handler_calls}"
+        )
+        await handler(context)
+
+    return wrapped_handler
+
+
+class EthSubscription(Generic[TSubscriptionResult]):
+    _id: HexStr = None
+    manager: "SubscriptionManager" = None
+
+    def __init__(
+        self: TSubscription,
+        subscription_params: Optional[Sequence[Any]] = None,
+        handler: Optional[EthSubscriptionHandler] = None,
+        handler_context: Optional[Dict[str, Any]] = None,
+        label: Optional[str] = None,
+    ) -> None:
+        self._subscription_params = subscription_params
+        self._handler = handler_wrapper(handler)
+        self._handler_context = handler_context or {}
+        self._label = label
+        self.handler_call_count = 0
+
+    @classmethod
+    def _create_type_aware_subscription(
+        cls,
+        subscription_params: Optional[Sequence[Any]],
+        handler: Optional[EthSubscriptionHandler] = None,
+        handler_context: Optional[Dict[str, Any]] = None,
+        label: Optional[str] = None,
+    ) -> "EthSubscription[Any]":
+        subscription_type = subscription_params[0]
+        subscription_arg = (
+            subscription_params[1] if len(subscription_params) > 1 else None
+        )
+        if subscription_type == "newHeads":
+            return NewHeadsSubscription(
+                handler=handler, handler_context=handler_context, label=label
+            )
+        elif subscription_type == "logs":
+            subscription_arg = subscription_arg or {}
+            return LogsSubscription(
+                **subscription_arg,
+                handler=handler,
+                handler_context=handler_context,
+                label=label,
+            )
+        elif subscription_type == "newPendingTransactions":
+            subscription_arg = subscription_arg or False
+            return PendingTxSubscription(
+                full_transactions=subscription_arg,
+                handler=handler,
+                handler_context=handler_context,
+                label=label,
+            )
+        elif subscription_type == "syncing":
+            return SyncingSubscription(
+                handler=handler, handler_context=handler_context, label=label
+            )
+        else:
+            params = (
+                (subscription_type, subscription_arg)
+                if subscription_arg
+                else (subscription_type,)
+            )
+            return cls(
+                params,
+                handler=handler,
+                handler_context=handler_context,
+                label=label,
+            )
+
+    @property
+    def subscription_params(self) -> Sequence[Any]:
+        return self._subscription_params
+
+    @property
+    def label(self) -> str:
+        if not self._label:
+            self._label = f"{self.__class__.__name__}{self.subscription_params}"
+        return self._label
+
+    @property
+    def id(self) -> HexStr:
+        if not self._id:
+            raise Web3ValueError("No `id` found for subscription.")
+        return self._id
+
+    async def unsubscribe(self) -> bool:
+        return await self.manager.unsubscribe(self)
+
+
+LogsSubscriptionContext = EthSubscriptionContext[
+    "LogsSubscription", "EthSubscriptionResult"
+]
+LogsSubscriptionHandler = Callable[[LogsSubscriptionContext], Coroutine[Any, Any, None]]
+
+
+class LogsSubscription(EthSubscription[LogReceipt]):
+    def __init__(
+        self,
+        address: Optional[
+            Union[Address, ChecksumAddress, List[Address], List[ChecksumAddress]]
+        ] = None,
+        topics: Optional[List[HexStr]] = None,
+        handler: LogsSubscriptionHandler = None,
+        handler_context: Optional[Dict[str, Any]] = None,
+        label: Optional[str] = None,
+    ) -> None:
+        self.address = address
+        self.topics = topics
+
+        logs_filter: FilterParams = {}
+        if address:
+            logs_filter["address"] = address
+        if topics:
+            logs_filter["topics"] = topics
+        self.logs_filter = logs_filter
+
+        super().__init__(
+            subscription_params=("logs", logs_filter),
+            handler=handler,
+            handler_context=handler_context,
+            label=label,
+        )
+
+
+NewHeadsSubscriptionContext = EthSubscriptionContext["NewHeadsSubscription", BlockData]
+NewHeadsSubscriptionHandler = Callable[
+    [NewHeadsSubscriptionContext], Coroutine[Any, Any, None]
+]
+
+
+class NewHeadsSubscription(EthSubscription[BlockData]):
+    def __init__(
+        self,
+        label: Optional[str] = None,
+        handler: Optional[NewHeadsSubscriptionHandler] = None,
+        handler_context: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(
+            subscription_params=("newHeads",),
+            handler=handler,
+            handler_context=handler_context,
+            label=label,
+        )
+
+
+PendingTxSubscriptionContext = EthSubscriptionContext[
+    "PendingTxSubscription", Union[HexBytes, TxData]
+]
+PendingTxSubscriptionHandler = Callable[
+    [PendingTxSubscriptionContext], Coroutine[Any, Any, None]
+]
+
+
+class PendingTxSubscription(EthSubscription[Union[HexBytes, TxData]]):
+    def __init__(
+        self,
+        full_transactions: bool = False,
+        label: Optional[str] = None,
+        handler: Optional[PendingTxSubscriptionHandler] = None,
+        handler_context: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.full_transactions = full_transactions
+        super().__init__(
+            subscription_params=("newPendingTransactions", full_transactions),
+            handler=handler,
+            handler_context=handler_context,
+            label=label,
+        )
+
+
+SyncingSubscriptionContext = EthSubscriptionContext["SyncingSubscription", SyncProgress]
+SyncingSubscriptionHandler = Callable[
+    [SyncingSubscriptionContext], Coroutine[Any, Any, None]
+]
+
+
+class SyncingSubscription(EthSubscription[SyncProgress]):
+    def __init__(
+        self,
+        label: Optional[str] = None,
+        handler: Optional[SyncingSubscriptionHandler] = None,
+        handler_context: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(
+            subscription_params=("syncing",),
+            handler=handler,
+            handler_context=handler_context,
+            label=label,
+        )

{web3-7.0.0b2.dist-info → web3-7.7.0.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 The Ethereum Foundation
+Copyright (c) 2016-2024 The Ethereum Foundation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

web3-7.7.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.2
+Name: web3
+Version: 7.7.0
+Summary: web3: A Python library for interacting with Ethereum
+Home-page: https://github.com/ethereum/web3.py
+Author: The Ethereum Foundation
+Author-email: snakecharmers@ethereum.org
+License: MIT
+Keywords: ethereum
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8, <4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: eth-abi>=5.0.1
+Requires-Dist: eth-account>=0.13.1
+Requires-Dist: eth-hash[pycryptodome]>=0.5.1
+Requires-Dist: eth-typing>=5.0.0
+Requires-Dist: eth-utils>=5.0.0
+Requires-Dist: hexbytes>=1.2.0
+Requires-Dist: aiohttp>=3.7.4.post0
+Requires-Dist: pydantic>=2.4.0
+Requires-Dist: pywin32>=223; platform_system == "Windows"
+Requires-Dist: requests>=2.23.0
+Requires-Dist: typing-extensions>=4.0.1
+Requires-Dist: types-requests>=2.0.0
+Requires-Dist: websockets<14.0.0,>=10.0.0
+Requires-Dist: pyunormalize>=15.0.0
+Provides-Extra: tester
+Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.12.0b1; extra == "tester"
+Requires-Dist: py-geth>=5.1.0; extra == "tester"
+Provides-Extra: dev
+Requires-Dist: build>=0.9.0; extra == "dev"
+Requires-Dist: bumpversion>=0.5.3; extra == "dev"
+Requires-Dist: ipython; extra == "dev"
+Requires-Dist: setuptools>=38.6.0; extra == "dev"
+Requires-Dist: tqdm>4.32; extra == "dev"
+Requires-Dist: twine>=1.13; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: sphinx>=6.0.0; extra == "dev"
+Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "dev"
+Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "dev"
+Requires-Dist: towncrier<22,>=21; extra == "dev"
+Requires-Dist: pytest-asyncio<0.23,>=0.18.1; extra == "dev"
+Requires-Dist: pytest-mock>=1.10; extra == "dev"
+Requires-Dist: pytest-xdist>=2.4.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: flaky>=3.7.0; extra == "dev"
+Requires-Dist: hypothesis>=3.31.2; extra == "dev"
+Requires-Dist: tox>=4.0.0; extra == "dev"
+Requires-Dist: mypy==1.10.0; extra == "dev"
+Requires-Dist: pre-commit>=3.4.0; extra == "dev"
+Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.12.0b1; extra == "dev"
+Requires-Dist: py-geth>=5.1.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=6.0.0; extra == "docs"
+Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "docs"
+Requires-Dist: sphinx_rtd_theme>=1.0.0; extra == "docs"
+Requires-Dist: towncrier<22,>=21; extra == "docs"
+Provides-Extra: test
+Requires-Dist: pytest-asyncio<0.23,>=0.18.1; extra == "test"
+Requires-Dist: pytest-mock>=1.10; extra == "test"
+Requires-Dist: pytest-xdist>=2.4.0; extra == "test"
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Requires-Dist: flaky>=3.7.0; extra == "test"
+Requires-Dist: hypothesis>=3.31.2; extra == "test"
+Requires-Dist: tox>=4.0.0; extra == "test"
+Requires-Dist: mypy==1.10.0; extra == "test"
+Requires-Dist: pre-commit>=3.4.0; extra == "test"
+Requires-Dist: eth-tester[py-evm]<0.13.0b1,>=0.12.0b1; extra == "test"
+Requires-Dist: py-geth>=5.1.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# web3.py
+
+[![Join the conversation on Discord](https://img.shields.io/discord/809793915578089484?color=blue&label=chat&logo=discord&logoColor=white)](https://discord.gg/GHryRvPB84)
+[![Build Status](https://circleci.com/gh/ethereum/web3.py.svg?style=shield)](https://circleci.com/gh/ethereum/web3.py)
+[![PyPI version](https://badge.fury.io/py/web3.svg)](https://badge.fury.io/py/web3)
+[![Python versions](https://img.shields.io/pypi/pyversions/web3.svg)](https://pypi.python.org/pypi/web3)
+[![Docs build](https://readthedocs.org/projects/web3py/badge/?version=latest)](https://web3py.readthedocs.io/en/latest/?badge=latest)
+
+## A Python Library for Interacting with Ethereum
+
+web3.py allows you to interact with the Ethereum blockchain using Python, enabling you to build decentralized applications, interact with smart contracts, and much more.
+
+- Python 3.8+ support
+
+______________________________________________________________________
+
+## Quickstart
+
+[Get started in 5 minutes](https://web3py.readthedocs.io/en/latest/quickstart.html) or
+[take a tour](https://web3py.readthedocs.io/en/latest/overview.html) of the library.
+
+## Documentation
+
+For additional guides, examples, and APIs, see the [documentation](https://web3py.readthedocs.io/en/latest/).
+
+## Want to Help?
+
+Want to file a bug, contribute some code, or improve documentation? Excellent! Read up on our
+guidelines for [contributing](https://web3py.readthedocs.io/en/latest/contributing.html),
+then check out issues that are labeled
+[Good First Issue](https://github.com/ethereum/web3.py/issues?q=is%3Aissue+is%3Aopen+label%3A%22Good+First+Issue%22).
+
+______________________________________________________________________
+
+## Questions on Implementation or Usage?
+
+Join the conversation in the Ethereum Python Community [Discord](https://discord.gg/GHryRvPB84).