feat!: support decoding multiple ABIs at the same time, including ds-note library logs

src/ape/api/networks.py

@@ -305,13 +305,13 @@ def encode_transaction(
         """
 
     @abstractmethod
-    def decode_logs(self, abi: EventABI, raw_logs: List[Dict]) -> Iterator[ContractLog]:
+    def decode_logs(self, logs: List[Dict], *events: EventABI) -> Iterator["ContractLog"]:
         """
         Decode any contract logs that match the given event ABI from the raw log data.
 
         Args:
-            abi (EventABI): The event producing the logs.
-            raw_logs (List[Dict]): A list of raw log data from the chain.
+            logs (List[Dict]): A list of raw log data from the chain.
+            *events (EventABI): Event definitions to decode.
 
         Returns:
             Iterator[:class:`~ape.types.ContractLog`]

src/ape/api/providers.py

@@ -11,7 +11,7 @@
 from pathlib import Path
 from signal import SIGINT, SIGTERM, signal
 from subprocess import PIPE, Popen
-from typing import Any, Iterator, List, Optional
+from typing import Any, Dict, Iterator, List, Optional
 
 from eth_typing import HexStr
 from eth_utils import add_0x_prefix
@@ -21,6 +21,7 @@
 from web3 import Web3
 from web3.exceptions import ContractLogicError as Web3ContractLogicError
 from web3.exceptions import TimeExhausted
+from web3.types import RPCEndpoint
 
 from ape.api.config import PluginConfig
 from ape.api.networks import LOCAL_NETWORK_NAME, NetworkAPI
@@ -732,7 +733,7 @@ def block_ranges(self, start=0, stop=None, page=None):
         if stop is None:
             stop = self.chain_manager.blocks.height
         if page is None:
-            page = self.chain_manager.provider.block_page_size
+            page = self.block_page_size
 
         for start_block in range(start, stop + 1, page):
             stop_block = min(stop, start_block + page - 1)
@@ -750,20 +751,26 @@ def fetch_log_page(block_range):
             # eth-tester expects a different format, let web3 handle the conversions for it
             raw = "EthereumTester" not in self.client_version
             logs = self._get_logs(page_filter.dict(), raw)
-            return self.network.ecosystem.decode_logs(log_filter.events, logs)
+            return self.network.ecosystem.decode_logs(logs, *log_filter.events)
 
         with ThreadPoolExecutor(self.concurrency) as pool:
             for page in pool.map(fetch_log_page, block_ranges):
                 yield from page
 
-    def _get_logs(self, filter_params, raw=True):
+    def _get_logs(self, filter_params, raw=True) -> List[Dict]:
         if raw:
-            response = self.web3.provider.make_request("eth_getLogs", [filter_params])
+            response = self.web3.provider.make_request(RPCEndpoint("eth_getLogs"), [filter_params])
             if "error" in response:
-                raise ValueError(response["error"]["message"])
+                error = response["error"]
+                if isinstance(error, dict) and "message" in error:
+                    raise ValueError(error["message"])
+                else:
+                    # Should never get here, mostly for mypy
+                    raise ValueError(str(error))
+
             return response["result"]
         else:
-            return self.web3.eth.get_logs(filter_params)
+            return [vars(d) for d in self.web3.eth.get_logs(filter_params)]
 
     def send_transaction(self, txn: TransactionAPI) -> ReceiptAPI:
         try:

src/ape/api/transactions.py

@@ -215,14 +215,12 @@ def _confirmations_occurred(self) -> int:
 
         return latest_block.number - self.block_number
 
-    def raise_for_status(self):
-        """
-        Handle provider-specific errors regarding a non-successful
-        :class:`~api.providers.TransactionStatusEnum`.
-        """
-
+    @abstractmethod
     def decode_logs(
-        self, abi: Union[List[Union[EventABI, "ContractEvent"]], Union[EventABI, "ContractEvent"]]
+        self,
+        abi: Optional[
+            Union[List[Union[EventABI, "ContractEvent"]], Union[EventABI, "ContractEvent"]]
+        ] = None,
     ) -> Iterator[ContractLog]:
         """
         Decode the logs on the receipt.
@@ -233,14 +231,12 @@ def decode_logs(
         Returns:
             Iterator[:class:`~ape.types.ContractLog`]
         """
-        if not isinstance(abi, (list, tuple)):
-            abi = [abi]
 
-        for event_abi in abi:
-            if not isinstance(event_abi, EventABI):
-                event_abi = event_abi.abi
-
-            yield from self.provider.network.ecosystem.decode_logs(event_abi, self.logs)
+    def raise_for_status(self):
+        """
+        Handle provider-specific errors regarding a non-successful
+        :class:`~api.providers.TransactionStatusEnum`.
+        """
 
     def await_confirmations(self) -> "ReceiptAPI":
         """

src/ape/contracts/base.py

@@ -440,7 +440,7 @@ def from_receipt(self, receipt: ReceiptAPI) -> Iterator[ContractLog]:
             Iterator[:class:`~ape.contracts.base.ContractLog`]
         """
         ecosystem = self.provider.network.ecosystem
-        yield from ecosystem.decode_logs(self.abi, receipt.logs)
+        yield from ecosystem.decode_logs(receipt.logs, self.abi)
 
     def poll_logs(
         self,

src/ape/managers/chain.py

@@ -580,7 +580,6 @@ def get(
             return default
 
         contract_type = self._get_contract_type_from_disk(address_key)
-
         if not contract_type:
             # Contract could be a minimal proxy
             proxy_info = self._local_proxies.get(address_key) or self._get_proxy_info_from_disk(
@@ -596,6 +595,13 @@ def get(
                 self._local_proxies[address_key] = proxy_info
                 return self.get(proxy_info.target)
 
+            if not self.provider.get_code(address_key):
+                if default:
+                    self._local_contracts[address_key] = default
+                    self._cache_contract_to_disk(address_key, default)
+
+                return default
+
             # Also gets cached to disk for faster lookup next time.
             contract_type = self._get_contract_type_from_explorer(address_key)
 

src/ape/types/__init__.py

@@ -21,6 +21,7 @@
 from web3.types import FilterParams
 
 from ape._compat import Literal
+from ape.utils.misc import to_int, to_snake_case
 
 from .signatures import MessageSignature, SignableMessage, TransactionSignature
 
@@ -78,8 +79,8 @@ def validate_addresses(cls, value):
     def dict(self, client=None):
         return FilterParams(
             address=self.addresses,
-            fromBlock=hex(self.start_block),
-            toBlock=hex(self.stop_block),
+            fromBlock=hex(self.start_block),  # type: ignore
+            toBlock=hex(self.stop_block),  # type: ignore
             topics=self.topic_filter,  # type: ignore
         )
 
@@ -147,7 +148,7 @@ class ContractLog(BaseModel):
     An instance of a log from a contract.
     """
 
-    name: str
+    event_name: str
     """The name of the event."""
 
     contract_address: AddressType
@@ -168,6 +169,28 @@ class ContractLog(BaseModel):
     log_index: int
     """The index of the log on the transaction."""
 
+    transaction_index: Optional[int] = None
+    """
+    The index of the transaction's position when the log was created.
+    Is `None` when from the pending block.
+    """
+
+    class Config:
+        alias_generator = to_snake_case
+
+    @validator("block_number", "log_index", "transaction_index", pre=True)
+    def validate_hex_ints(cls, value):
+        if not isinstance(value, int):
+            return to_int(value)
+
+        return value
+
+    @validator("contract_address", pre=True)
+    def validate_address(cls, value):
+        from ape import convert
+
+        return convert(value, AddressType)
+
     def __str__(self) -> str:
         args = " ".join(f"{key}={val}" for key, val in self.event_arguments.items())
         return f"{self.name} {args}"

src/ape/utils/__init__.py

@@ -34,6 +34,8 @@
     raises_not_implemented,
     singledispatchmethod,
     stream_response,
+    to_int,
+    to_snake_case,
 )
 from ape.utils.os import get_all_files_in_directory, get_relative_path, use_temp_sys_path
 from ape.utils.process import JoinableQueue, spawn
@@ -85,6 +87,8 @@
     "Struct",
     "StructParser",
     "TraceStyles",
+    "to_int",
+    "to_snake_case",
     "use_temp_sys_path",
     "USER_AGENT",
     "ZERO_ADDRESS",

src/ape/utils/misc.py

@@ -251,6 +251,10 @@ def to_int(value) -> int:
     raise ValueError(f"cannot convert {repr(value)} to int")
 
 
+def to_snake_case(string: str) -> str:
+    return "".join(["_" + i.lower() if i.isupper() else i for i in string]).lstrip("_")
+
+
 __all__ = [
     "cached_property",
     "expand_environment_variables",
@@ -261,5 +265,6 @@ def to_int(value) -> int:
     "raises_not_implemented",
     "singledispatchmethod",
     "stream_response",
+    "to_snake_case",
     "USER_AGENT",
 ]

src/ape/utils/trace.py

@@ -12,12 +12,12 @@
 from hexbytes import HexBytes
 from rich.tree import Tree
 
-from ape.api.networks import EcosystemAPI
 from ape.exceptions import ContractError, DecodingError
 from ape.utils.abi import Struct, parse_type
 from ape.utils.misc import ZERO_ADDRESS
 
 if TYPE_CHECKING:
+    from ape.api.networks import EcosystemAPI
     from ape.api.transactions import ReceiptAPI
 
 
@@ -85,7 +85,7 @@ def __init__(
         self.colors = color_set
 
     @property
-    def _ecosystem(self) -> EcosystemAPI:
+    def _ecosystem(self) -> "EcosystemAPI":
         return self._receipt.provider.network.ecosystem
 
     def parse_as_tree(self, call: CallTreeNode) -> Tree:

src/ape_ethereum/ecosystem.py

@@ -25,8 +25,8 @@
     is_array,
     parse_type,
     returns_array,
+    to_snake_case,
 )
-from ape.utils.misc import to_int
 from ape_ethereum.transactions import (
     AccessListTransaction,
     BaseTransaction,
@@ -146,6 +146,8 @@ def encode_address(cls, address: AddressType) -> RawAddress:
 
     def get_proxy_info(self, address: AddressType) -> Optional[ProxyInfo]:
         code = self.provider.get_code(address).hex()[2:]
+        if not code:
+            return None
         patterns = {
             ProxyType.Minimal: r"363d3d373d3d3d363d73(.{40})5af43d82803e903d91602b57fd5bf3",
             ProxyType.Vyper: r"366000600037611000600036600073(.{40})5af4602c57600080fd5b6110006000f3",  # noqa: E501
@@ -442,13 +444,7 @@ def create_transaction(self, **kwargs) -> TransactionAPI:
 
         return txn_class(**kwargs)  # type: ignore
 
-    def decode_logs(
-        self, events: Union[EventABI, List[EventABI]], logs: List[Dict]
-    ) -> Iterator["ContractLog"]:
-
-        if not isinstance(events, list):
-            events = [events]
-
+    def decode_logs(self, logs: List[Dict], *events: EventABI) -> Iterator["ContractLog"]:
         abi_inputs = {
             encode_hex(keccak(text=abi.selector)): LogInputABICollection(abi) for abi in events
         }
@@ -468,13 +464,14 @@ def decode_logs(
                 continue
 
             event_arguments = abi.decode(topics, log["data"])
-
+            log = {to_snake_case(k): v for k, v in log.items()}
             yield ContractLog(
-                name=abi.event_name,
+                block_hash=log["block_hash"],
+                block_number=log["block_number"],
                 contract_address=self.decode_address(log["address"]),
                 event_arguments=event_arguments,
-                transaction_hash=log["transactionHash"],
-                block_number=to_int(log["blockNumber"]),
-                block_hash=log["blockHash"],
-                log_index=to_int(log["logIndex"]),
-            )
+                event_name=abi.event_name,
+                log_index=log["log_index"],
+                transaction_hash=log["transaction_hash"],
+                transaction_index=log["transaction_index"],
+            )  # type: ignore