web3 6.20.3__py3-none-any.whl → 7.0.0__py3-none-any.whl

web3/middleware/buffered_gas_estimate.py

@@ -1,7 +1,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
+    cast,
 )
 
 from eth_utils.toolz import (
@@ -14,10 +14,11 @@ from web3._utils.async_transactions import (
 from web3._utils.transactions import (
     get_buffered_gas_estimate,
 )
+from web3.middleware.base import (
+    Web3Middleware,
+)
 from web3.types import (
-    AsyncMiddlewareCoroutine,
     RPCEndpoint,
-    RPCResponse,
 )
 
 if TYPE_CHECKING:
@@ -27,34 +28,32 @@ if TYPE_CHECKING:
     )
 
 
-def buffered_gas_estimate_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], w3: "Web3"
-) -> Callable[[RPCEndpoint, Any], RPCResponse]:
-    def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
+class BufferedGasEstimateMiddleware(Web3Middleware):
+    """
+    Includes a gas estimate for all transactions that do not already have a gas value.
+    """
+
+    def request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
         if method == "eth_sendTransaction":
             transaction = params[0]
             if "gas" not in transaction:
                 transaction = assoc(
                     transaction,
                     "gas",
-                    hex(get_buffered_gas_estimate(w3, transaction)),
+                    hex(get_buffered_gas_estimate(cast("Web3", self._w3), transaction)),
                 )
-                return make_request(method, [transaction])
-        return make_request(method, params)
-
-    return middleware
+                params = (transaction,)
+        return method, params
 
+    # -- async -- #
 
-async def async_buffered_gas_estimate_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], w3: "AsyncWeb3"
-) -> AsyncMiddlewareCoroutine:
-    async def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
+    async def async_request_processor(self, method: "RPCEndpoint", params: Any) -> Any:
         if method == "eth_sendTransaction":
             transaction = params[0]
             if "gas" not in transaction:
-                gas_estimate = await async_get_buffered_gas_estimate(w3, transaction)
+                gas_estimate = await async_get_buffered_gas_estimate(
+                    cast("AsyncWeb3", self._w3), transaction
+                )
                 transaction = assoc(transaction, "gas", hex(gas_estimate))
-                return await make_request(method, [transaction])
-        return await make_request(method, params)
-
-    return middleware
+                params = (transaction,)
+        return method, params

web3/middleware/filter.py

@@ -5,7 +5,6 @@ from typing import (
     Any,
     AsyncIterable,
     AsyncIterator,
-    Callable,
     Dict,
     Generator,
     Iterable,
@@ -43,18 +42,30 @@ from web3._utils.formatters import (
 from web3._utils.rpc_abi import (
     RPC,
 )
+from web3.exceptions import (
+    Web3TypeError,
+)
+from web3.middleware.base import (
+    Web3Middleware,
+)
 from web3.types import (
-    Coroutine,
+    AsyncMakeRequestFn,
     FilterParams,
     LatestBlockParam,
     LogReceipt,
-    RPCEndpoint,
-    RPCResponse,
+    MakeRequestFn,
     _Hash32,
 )
 
 if TYPE_CHECKING:
-    from web3 import Web3  # noqa: F401
+    from web3 import (  # noqa: F401
+        AsyncWeb3,
+        Web3,
+    )
+    from web3.types import (  # noqa: F401
+        RPCEndpoint,
+        RPCResponse,
+    )
 
 if "WEB3_MAX_BLOCK_REQUEST" in os.environ:
     MAX_BLOCK_REQUEST = to_int(text=os.environ["WEB3_MAX_BLOCK_REQUEST"])
@@ -63,7 +74,8 @@ else:
 
 
 def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, int]]:
-    """Creates a segment counting generator
+    """
+    Creates a segment counting generator
 
     The generator returns tuple pairs of integers
     that correspond to segments in the provided range.
@@ -76,6 +88,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
 
 
     Example:
+    -------
 
     >>> segment_counter = segment_count(start=0, stop=10, step=3)
     >>> next(segment_counter)
@@ -86,6 +99,7 @@ def segment_count(start: int, stop: int, step: int = 5) -> Iterable[Tuple[int, i
     (6, 9)
     >>> next(segment_counter) #  Remainder is also returned
     (9, 10)
+
     """
     return gen_bounded_segments(start, stop, step)
 
@@ -96,10 +110,9 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
     if start + step >= stop:
         yield (start, stop)
         return
-    for segment in zip(
+    yield from zip(
         range(start, stop - step + 1, step), range(start + step, stop + 1, step)
-    ):
-        yield segment
+    )
 
     remainder = (stop - start) % step
     #  Handle the remainder
@@ -110,13 +123,14 @@ def gen_bounded_segments(start: int, stop: int, step: int) -> Iterable[Tuple[int
 def block_ranges(
     start_block: BlockNumber, last_block: Optional[BlockNumber], step: int = 5
 ) -> Iterable[Tuple[BlockNumber, BlockNumber]]:
-    """Returns 2-tuple ranges describing ranges of block from start_block to last_block
+    """
+    Returns 2-tuple ranges describing ranges of block from start_block to last_block
 
     Ranges do not overlap to facilitate use as ``toBlock``, ``fromBlock``
     json-rpc arguments, which are both inclusive.
     """
     if last_block is not None and start_block > last_block:
-        raise TypeError(
+        raise Web3TypeError(
             "Incompatible start and stop arguments.",
             "Start must be less than or equal to stop.",
         )
@@ -130,7 +144,8 @@ def block_ranges(
 def iter_latest_block(
     w3: "Web3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> Iterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -152,8 +167,7 @@ def iter_latest_block(
 
     while True:
         latest_block = w3.eth.block_number
-        # type ignored b/c is_bounded_range prevents unsupported comparison
-        if is_bounded_range and latest_block > to_block:  # type: ignore
+        if is_bounded_range and latest_block > cast(BlockNumber, to_block):
             yield None
         #  No new blocks since last iteration.
         if _last is not None and _last == latest_block:
@@ -168,7 +182,8 @@ def iter_latest_block_ranges(
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> Iterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `fromBlock` to the latest mined block,
     until reaching toBlock. e.g.:
@@ -204,7 +219,8 @@ def get_logs_multipart(
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> Iterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.
@@ -239,9 +255,8 @@ class RequestLogs:
         if from_block is None or from_block == "latest":
             self._from_block = BlockNumber(w3.eth.block_number + 1)
         elif is_string(from_block) and is_hex(from_block):
-            self._from_block = BlockNumber(hex_to_integer(from_block))  # type: ignore
+            self._from_block = BlockNumber(hex_to_integer(cast(HexStr, from_block)))
         else:
-            # cast b/c LatestBlockParam is handled above
             self._from_block = from_block
         self._to_block = to_block
         self.filter_changes = self._get_filter_changes()
@@ -257,7 +272,7 @@ class RequestLogs:
         elif self._to_block == "latest":
             to_block = self.w3.eth.block_number
         elif is_string(self._to_block) and is_hex(self._to_block):
-            to_block = BlockNumber(hex_to_integer(self._to_block))  # type: ignore
+            to_block = BlockNumber(hex_to_integer(cast(HexStr, self._to_block)))
         else:
             to_block = self._to_block
 
@@ -338,59 +353,14 @@ def block_hashes_in_range(
         yield getattr(w3.eth.get_block(BlockNumber(block_number)), "hash", None)
 
 
-def local_filter_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], w3: "Web3"
-) -> Callable[[RPCEndpoint, Any], RPCResponse]:
-    filters = {}
-    filter_id_counter = map(to_hex, itertools.count())
-
-    def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-        if method in NEW_FILTER_METHODS:
-            filter_id = next(filter_id_counter)
-
-            _filter: Union[RequestLogs, RequestBlocks]
-            if method == RPC.eth_newFilter:
-                _filter = RequestLogs(
-                    w3, **apply_key_map(FILTER_PARAMS_KEY_MAP, params[0])
-                )
-
-            elif method == RPC.eth_newBlockFilter:
-                _filter = RequestBlocks(w3)
-
-            else:
-                raise NotImplementedError(method)
-
-            filters[filter_id] = _filter
-            return {"result": filter_id}
-
-        elif method in FILTER_CHANGES_METHODS:
-            filter_id = params[0]
-            #  Pass through to filters not created by middleware
-            if filter_id not in filters:
-                return make_request(method, params)
-            _filter = filters[filter_id]
-            if method == RPC.eth_getFilterChanges:
-                return {"result": next(_filter.filter_changes)}
-
-            elif method == RPC.eth_getFilterLogs:
-                # type ignored b/c logic prevents RequestBlocks which
-                # doesn't implement get_logs
-                return {"result": _filter.get_logs()}  # type: ignore
-            else:
-                raise NotImplementedError(method)
-        else:
-            return make_request(method, params)
-
-    return middleware
-
-
 # --- async --- #
 
 
 async def async_iter_latest_block(
-    w3: "Web3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
+    w3: "AsyncWeb3", to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None
 ) -> AsyncIterable[BlockNumber]:
-    """Returns a generator that dispenses the latest block, if
+    """
+    Returns a generator that dispenses the latest block, if
     any new blocks have been mined since last iteration.
 
     If there are no new blocks or the latest block is greater than
@@ -411,9 +381,9 @@ async def async_iter_latest_block(
     is_bounded_range = to_block is not None and to_block != "latest"
 
     while True:
-        latest_block = await w3.eth.block_number  # type: ignore
+        latest_block = await w3.eth.block_number
         # type ignored b/c is_bounded_range prevents unsupported comparison
-        if is_bounded_range and latest_block > to_block:
+        if is_bounded_range and latest_block > cast(int, to_block):
             yield None
         #  No new blocks since last iteration.
         if _last is not None and _last == latest_block:
@@ -424,11 +394,12 @@ async def async_iter_latest_block(
 
 
 async def async_iter_latest_block_ranges(
-    w3: "Web3",
+    w3: "AsyncWeb3",
     from_block: BlockNumber,
     to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
 ) -> AsyncIterable[Tuple[Optional[BlockNumber], Optional[BlockNumber]]]:
-    """Returns an iterator unloading ranges of available blocks
+    """
+    Returns an iterator unloading ranges of available blocks
 
     starting from `from_block` to the latest mined block,
     until reaching to_block. e.g.:
@@ -454,14 +425,15 @@ async def async_iter_latest_block_ranges(
 
 
 async def async_get_logs_multipart(
-    w3: "Web3",
+    w3: "AsyncWeb3",
     start_block: BlockNumber,
     stop_block: BlockNumber,
     address: Union[Address, ChecksumAddress, List[Union[Address, ChecksumAddress]]],
     topics: List[Optional[Union[_Hash32, List[_Hash32]]]],
     max_blocks: int,
 ) -> AsyncIterable[List[LogReceipt]]:
-    """Used to break up requests to ``eth_getLogs``
+    """
+    Used to break up requests to ``eth_getLogs``
 
     The getLog request is partitioned into multiple calls of the max number of blocks
     ``max_blocks``.
@@ -477,7 +449,7 @@ async def async_get_logs_multipart(
         params_with_none_dropped = cast(
             FilterParams, drop_items_with_none_value(params)
         )
-        next_logs = await w3.eth.get_logs(params_with_none_dropped)  # type: ignore
+        next_logs = await w3.eth.get_logs(params_with_none_dropped)
         yield next_logs
 
 
@@ -486,7 +458,7 @@ class AsyncRequestLogs:
 
     def __init__(
         self,
-        w3: "Web3",
+        w3: "AsyncWeb3",
         from_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
         to_block: Optional[Union[BlockNumber, LatestBlockParam]] = None,
         address: Optional[
@@ -504,7 +476,7 @@ class AsyncRequestLogs:
     def __await__(self) -> Generator[Any, None, "AsyncRequestLogs"]:
         async def closure() -> "AsyncRequestLogs":
             if self._from_block_arg is None or self._from_block_arg == "latest":
-                self.block_number = await self.w3.eth.block_number  # type: ignore
+                self.block_number = await self.w3.eth.block_number
                 self._from_block = BlockNumber(self.block_number + 1)
             elif is_string(self._from_block_arg) and is_hex(self._from_block_arg):
                 self._from_block = BlockNumber(
@@ -524,7 +496,7 @@ class AsyncRequestLogs:
     @property
     async def to_block(self) -> BlockNumber:
         if self._to_block is None or self._to_block == "latest":
-            to_block = await self.w3.eth.block_number  # type: ignore
+            to_block = await self.w3.eth.block_number
         elif is_string(self._to_block) and is_hex(self._to_block):
             to_block = BlockNumber(hex_to_integer(cast(HexStr, self._to_block)))
         else:
@@ -572,12 +544,12 @@ class AsyncRequestLogs:
 
 
 class AsyncRequestBlocks:
-    def __init__(self, w3: "Web3") -> None:
+    def __init__(self, w3: "AsyncWeb3") -> None:
         self.w3 = w3
 
     def __await__(self) -> Generator[Any, None, "AsyncRequestBlocks"]:
         async def closure() -> "AsyncRequestBlocks":
-            self.block_number = await self.w3.eth.block_number  # type: ignore
+            self.block_number = await self.w3.eth.block_number
             self.start_block = BlockNumber(self.block_number + 1)
             return self
 
@@ -597,7 +569,7 @@ class AsyncRequestBlocks:
 
 
 async def async_block_hashes_in_range(
-    w3: "Web3", block_range: Tuple[BlockNumber, BlockNumber]
+    w3: "AsyncWeb3", block_range: Tuple[BlockNumber, BlockNumber]
 ) -> List[Union[None, Hash32]]:
     from_block, to_block = block_range
     if from_block is None or to_block is None:
@@ -605,56 +577,124 @@ async def async_block_hashes_in_range(
 
     block_hashes = []
     for block_number in range(from_block, to_block + 1):
-        w3_get_block = await w3.eth.get_block(BlockNumber(block_number))  # type: ignore
+        w3_get_block = await w3.eth.get_block(BlockNumber(block_number))
         block_hashes.append(getattr(w3_get_block, "hash", None))
 
     return block_hashes
 
 
-async def async_local_filter_middleware(
-    make_request: Callable[[RPCEndpoint, Any], Any], w3: "Web3"
-) -> Callable[[RPCEndpoint, Any], Coroutine[Any, Any, RPCResponse]]:
-    filters = {}
-    filter_id_counter = map(to_hex, itertools.count())
+# -- middleware -- #
 
-    async def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
-        if method in NEW_FILTER_METHODS:
-            filter_id = next(filter_id_counter)
+SyncFilter = Union[RequestLogs, RequestBlocks]
+AsyncFilter = Union[AsyncRequestLogs, AsyncRequestBlocks]
 
-            _filter: Union[AsyncRequestLogs, AsyncRequestBlocks]
-            if method == RPC.eth_newFilter:
-                _filter = await AsyncRequestLogs(
-                    w3, **apply_key_map(FILTER_PARAMS_KEY_MAP, params[0])
-                )
 
-            elif method == RPC.eth_newBlockFilter:
-                _filter = await AsyncRequestBlocks(w3)
+def _simulate_rpc_response_with_result(filter_id: str) -> "RPCResponse":
+    return {"jsonrpc": "2.0", "id": -1, "result": filter_id}
+
+
+class LocalFilterMiddleware(Web3Middleware):
+    def __init__(self, w3: Union["Web3", "AsyncWeb3"]):
+        self.filters: Dict[str, SyncFilter] = {}
+        self.async_filters: Dict[str, AsyncFilter] = {}
+        self.filter_id_counter = itertools.count()
+        super().__init__(w3)
+
+    def wrap_make_request(self, make_request: MakeRequestFn) -> MakeRequestFn:
+        def middleware(method: "RPCEndpoint", params: Any) -> "RPCResponse":
+            if method in NEW_FILTER_METHODS:
+                _filter: SyncFilter
+                filter_id = to_hex(next(self.filter_id_counter))
+
+                if method == RPC.eth_newFilter:
+                    _filter = RequestLogs(
+                        cast("Web3", self._w3),
+                        **apply_key_map(FILTER_PARAMS_KEY_MAP, params[0])
+                    )
+
+                elif method == RPC.eth_newBlockFilter:
+                    _filter = RequestBlocks(cast("Web3", self._w3))
+
+                else:
+                    raise NotImplementedError(method)
+
+                self.filters[filter_id] = _filter
+                return _simulate_rpc_response_with_result(filter_id)
+
+            elif method in FILTER_CHANGES_METHODS:
+                _filter_id = params[0]
+
+                #  Pass through to filters not created by middleware
+                if _filter_id not in self.filters:
+                    return make_request(method, params)
+
+                _filter = self.filters[_filter_id]
+                if method == RPC.eth_getFilterChanges:
+                    return _simulate_rpc_response_with_result(
+                        next(_filter.filter_changes)  # type: ignore
+                    )
 
+                elif method == RPC.eth_getFilterLogs:
+                    # type ignored b/c logic prevents RequestBlocks which
+                    # doesn't implement get_logs
+                    return _simulate_rpc_response_with_result(
+                        _filter.get_logs()  # type: ignore
+                    )
+                else:
+                    raise NotImplementedError(method)
             else:
-                raise NotImplementedError(method)
+                return make_request(method, params)
 
-            filters[filter_id] = _filter
-            return {"result": filter_id}
+        return middleware
 
-        elif method in FILTER_CHANGES_METHODS:
-            filter_id = params[0]
-            #  Pass through to filters not created by middleware
-            if filter_id not in filters:
-                return await make_request(method, params)
-            _filter = filters[filter_id]
+    # -- async -- #
+
+    async def async_wrap_make_request(
+        self,
+        make_request: AsyncMakeRequestFn,
+    ) -> AsyncMakeRequestFn:
+        async def middleware(method: "RPCEndpoint", params: Any) -> "RPCResponse":
+            if method in NEW_FILTER_METHODS:
+                _filter: AsyncFilter
+                filter_id = to_hex(next(self.filter_id_counter))
+
+                if method == RPC.eth_newFilter:
+                    _filter = await AsyncRequestLogs(
+                        cast("AsyncWeb3", self._w3),
+                        **apply_key_map(FILTER_PARAMS_KEY_MAP, params[0])
+                    )
+
+                elif method == RPC.eth_newBlockFilter:
+                    _filter = await AsyncRequestBlocks(cast("AsyncWeb3", self._w3))
 
-            if method == RPC.eth_getFilterChanges:
-                changes = await _filter.filter_changes.__anext__()
-                return {"result": changes}
+                else:
+                    raise NotImplementedError(method)
 
-            elif method == RPC.eth_getFilterLogs:
-                # type ignored b/c logic prevents RequestBlocks which
-                # doesn't implement get_logs
-                logs = await _filter.get_logs()  # type: ignore
-                return {"result": logs}
+                self.async_filters[filter_id] = _filter
+                return _simulate_rpc_response_with_result(filter_id)
+
+            elif method in FILTER_CHANGES_METHODS:
+                _filter_id = params[0]
+
+                #  Pass through to filters not created by middleware
+                if _filter_id not in self.async_filters:
+                    return await make_request(method, params)
+
+                _filter = self.async_filters[_filter_id]
+                if method == RPC.eth_getFilterChanges:
+                    return _simulate_rpc_response_with_result(
+                        await _filter.filter_changes.__anext__()  # type: ignore
+                    )
+
+                elif method == RPC.eth_getFilterLogs:
+                    # type ignored b/c logic prevents RequestBlocks which
+                    # doesn't implement get_logs
+                    return _simulate_rpc_response_with_result(
+                        await _filter.get_logs()  # type: ignore
+                    )
+                else:
+                    raise NotImplementedError(method)
             else:
-                raise NotImplementedError(method)
-        else:
-            return await make_request(method, params)
+                return await make_request(method, params)
 
-    return middleware
+        return middleware