Add non-indexed event arg filtering support for get_logs

- Contract event ``get_logs()`` has support for ``argument_filters`` but it only works on indexed event arguments. This feature works on unindexed args for ``create_filter()`` / ``build_filter()``. It is ideal to achieve some parity in the same argument for ``get_logs()`` by allowing it here as well.

Author: fselmo

docs/web3.contract.rst

@@ -261,7 +261,7 @@ Each Contract Factory exposes the following methods.
     - ``fromBlock`` is a mandatory field. Defines the starting block (exclusive) filter block range. It can be either the starting block number, or 'latest' for the last mined block, or 'pending' for unmined transactions. In the case of ``fromBlock``, 'latest' and 'pending' set the 'latest' or 'pending' block as a static value for the starting filter block.
     - ``toBlock`` optional. Defaults to 'latest'. Defines the ending block (inclusive) in the filter block range.  Special values 'latest' and 'pending' set a dynamic range that always includes the 'latest' or 'pending' blocks for the filter's upper block range.
     - ``address`` optional. Defaults to the contract address. The filter matches the event logs emanating from ``address``.
-    - ``argument_filters``, optional. Expects a dictionary of argument names and values. When provided event logs are filtered for the event argument values. Event arguments can be both indexed or unindexed. Indexed values with be translated to their corresponding topic arguments. Unindexed arguments will be filtered using a regular expression.
+    - ``argument_filters``, optional. Expects a dictionary of argument names and values. When provided event logs are filtered for the event argument values. Event arguments can be both indexed or unindexed. Indexed values will be translated to their corresponding topic arguments. Unindexed arguments will be filtered using a regular expression.
     - ``topics`` optional, accepts the standard JSON-RPC topics argument.  See the JSON-RPC documentation for `eth_newFilter <https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_newfilter>`_ more information on the ``topics`` parameters.
 
 .. py:classmethod:: Contract.events.your_event_name.build_filter()
@@ -933,12 +933,15 @@ For example:
    :noindex:
 
    Fetches all logs for a given event within the specified block range or block hash.
+
     ``argument_filters`` is an optional dictionary argument that can be used to filter
     for logs where the event's argument values match the values provided in the
     dictionary. The keys must match the event argument names as they exist in the ABI.
     The values can either be a single value or a list of values to match against. If a
     list is provided, the logs will be filtered for any logs that match any of the
-    values in the list.
+    values in the list. Indexed arguments are filtered pre-call by building specific
+    ``topics`` to filter for. Non-indexed arguments are filtered by the library after
+    the logs are fetched from the node.
 
     .. code-block:: python
 

web3/_utils/filters.py

@@ -98,7 +98,11 @@ def construct_event_filter_params(
         if is_list_like(address):
             filter_params["address"] = [address] + [contract_address]
         elif is_string(address):
-            filter_params["address"] = [address, contract_address]
+            filter_params["address"] = (
+                [address, contract_address]
+                if address != contract_address
+                else [address]
+            )
         else:
             raise ValueError(
                 f"Unsupported type for `address` parameter: {type(address)}"

web3/contract/async_contract.py

@@ -83,6 +83,7 @@
     ABIFunctionNotFound,
     NoABIFound,
     NoABIFunctionsFound,
+    Web3ValidationError,
 )
 from web3.types import (
     ABI,
@@ -91,6 +92,9 @@
     EventData,
     TxParams,
 )
+from web3.utils import (
+    get_abi_input_names,
+)
 
 if TYPE_CHECKING:
     from ens import AsyncENS  # noqa: F401
@@ -156,25 +160,41 @@ async def get_logs(
 
         See also: :func:`web3.middleware.filter.local_filter_middleware`.
 
-        :param argument_filters:
+        :param argument_filters: Filter by argument values. Indexed arguments are
+          filtered by the node while non-indexed arguments are filtered by the library.
         :param fromBlock: block number or "latest", defaults to "latest"
         :param toBlock: block number or "latest". Defaults to "latest"
-        :param blockHash: block hash. blockHash cannot be set at the
+        :param block_hash: block hash. blockHash cannot be set at the
           same time as fromBlock or toBlock
         :yield: Tuple of :class:`AttributeDict` instances
         """
-        abi = self._get_event_abi()
+        event_abi = self._get_event_abi()
+
+        # validate ``argument_filters`` if present
+        if argument_filters is not None:
+            event_arg_names = get_abi_input_names(event_abi)
+            if not all(arg in event_arg_names for arg in argument_filters.keys()):
+                raise Web3ValidationError(
+                    "When filtering by argument names, all argument names must be "
+                    "present in the contract's event ABI."
+                )
+
         # Call JSON-RPC API
-        logs = await self.w3.eth.get_logs(
-            self._get_event_filter_params(
-                abi, argument_filters, fromBlock, toBlock, block_hash
-            )
+        _filter_params = self._get_event_filter_params(
+            event_abi, argument_filters, fromBlock, toBlock, block_hash
         )
 
-        # Convert raw binary data to Python proxy objects as described by ABI
-        return tuple(  # type: ignore
-            get_event_data(self.w3.codec, abi, entry) for entry in logs
+        logs = await self.w3.eth.get_logs(_filter_params)
+        # convert raw binary data to Python proxy objects as described by ABI:
+        all_event_logs = tuple(
+            get_event_data(self.w3.codec, event_abi, entry) for entry in logs
+        )
+        filtered_logs = self._process_get_logs_argument_filters(
+            event_abi,
+            all_event_logs,
+            argument_filters,
         )
+        return cast(Awaitable[Iterable[EventData]], filtered_logs)
 
     @combomethod
     async def create_filter(

web3/contract/base_contract.py

@@ -224,7 +224,7 @@ def _get_event_filter_params(
 
         # Construct JSON-RPC raw filter presentation based on human readable
         # Python descriptions. Namely, convert event names to their keccak signatures
-        data_filter_set, event_filter_params = construct_event_filter_params(
+        _, event_filter_params = construct_event_filter_params(
             abi,
             self.w3.codec,
             contract_address=self.address,
@@ -263,6 +263,53 @@ def check_for_forbidden_api_filter_arguments(
                     "filters with the match_any method."
                 )
 
+    @staticmethod
+    def _process_get_logs_argument_filters(
+        event_abi: ABIEvent,
+        event_logs: Sequence[EventData],
+        argument_filters: Optional[Dict[str, Any]],
+    ) -> Iterable[EventData]:
+        if (
+            argument_filters is None
+            or len(event_logs) == 0
+            or
+            # If all args in ``argument_filters`` are indexed, then the logs are
+            # already filtered by the node in the ``eth_getLogs`` call.
+            all(
+                input_arg["indexed"]
+                for input_arg in event_abi["inputs"]
+                if input_arg["name"] in argument_filters.keys()
+            )
+        ):
+            return event_logs
+
+        filtered_logs_by_non_indexed_args = []
+
+        for log in event_logs:
+            match = False
+            for arg, match_values in argument_filters.items():
+                if not is_list_like(match_values):
+                    match_values = [match_values]
+
+                for abi_arg in event_abi["inputs"]:
+                    if abi_arg["name"] == arg:
+                        if (
+                            # isolate ``string`` values to support substrings
+                            abi_arg["type"] == "string"
+                            and any(val in log["args"][arg] for val in match_values)
+                            or (
+                                # otherwise, do direct value comparison
+                                abi_arg["type"] != "string"
+                                and log["args"][arg] in match_values
+                            )
+                        ):
+                            filtered_logs_by_non_indexed_args.append(log)
+                            match = True
+                            break
+                if match:
+                    break
+        return filtered_logs_by_non_indexed_args
+
     @combomethod
     def _set_up_filter_builder(
         self,

web3/contract/contract.py

@@ -81,6 +81,7 @@
     ABIFunctionNotFound,
     NoABIFound,
     NoABIFunctionsFound,
+    Web3ValidationError,
 )
 from web3.types import (
     ABI,
@@ -89,6 +90,9 @@
     EventData,
     TxParams,
 )
+from web3.utils import (
+    get_abi_input_names,
+)
 
 if TYPE_CHECKING:
     from ens import ENS  # noqa: F401
@@ -154,23 +158,41 @@ def get_logs(
 
         See also: :func:`web3.middleware.filter.local_filter_middleware`.
 
-        :param argument_filters:
+        :param argument_filters: Filter by argument values. Indexed arguments are
+          filtered by the node while non-indexed arguments are filtered by the library.
         :param fromBlock: block number or "latest", defaults to "latest"
         :param toBlock: block number or "latest". Defaults to "latest"
         :param block_hash: block hash. block_hash cannot be set at the
           same time as fromBlock or toBlock
         :yield: Tuple of :class:`AttributeDict` instances
         """
-        abi = self._get_event_abi()
+        event_abi = self._get_event_abi()
+
+        # validate ``argument_filters`` if present
+        if argument_filters is not None:
+            event_arg_names = get_abi_input_names(event_abi)
+            if not all(arg in event_arg_names for arg in argument_filters.keys()):
+                raise Web3ValidationError(
+                    "When filtering by argument names, all argument names must be "
+                    "present in the contract's event ABI."
+                )
+
         # Call JSON-RPC API
-        logs = self.w3.eth.get_logs(
-            self._get_event_filter_params(
-                abi, argument_filters, fromBlock, toBlock, block_hash
-            )
+        _filter_params = self._get_event_filter_params(
+            event_abi, argument_filters, fromBlock, toBlock, block_hash
         )
 
-        # Convert raw binary data to Python proxy objects as described by ABI
-        return tuple(get_event_data(self.w3.codec, abi, entry) for entry in logs)
+        logs = cast(Sequence[EventData], self.w3.eth.get_logs(_filter_params))
+        # convert raw binary data to Python proxy objects as described by ABI:
+        all_event_logs = tuple(
+            get_event_data(self.w3.codec, event_abi, entry) for entry in logs
+        )
+        filtered_logs = self._process_get_logs_argument_filters(
+            event_abi,
+            all_event_logs,
+            argument_filters,
+        )
+        return filtered_logs
 
     @combomethod
     def create_filter(