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

@@ -750,7 +750,7 @@ 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):

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_ethereum/ecosystem.py

@@ -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,12 @@ def decode_logs(
                 continue
 
             event_arguments = abi.decode(topics, log["data"])
-
             yield ContractLog(
-                name=abi.event_name,
+                block_hash=log["blockHash"],
+                block_number=to_int(log["blockNumber"]),
                 contract_address=self.decode_address(log["address"]),
                 event_arguments=event_arguments,
+                log_index=log["logIndex"],
+                name=abi.event_name,
                 transaction_hash=log["transactionHash"],
-                block_number=to_int(log["blockNumber"]),
-                block_hash=log["blockHash"],
-                log_index=to_int(log["logIndex"]),
-            )
+            )  # type: ignore

src/ape_ethereum/transactions.py

@@ -1,20 +1,23 @@
 import sys
 from enum import Enum, IntEnum
-from typing import IO, Dict, List, Optional, Union
+from typing import IO, Dict, Iterator, List, Optional, Union
 
 from eth_abi import decode_abi
 from eth_account import Account as EthAccount  # type: ignore
 from eth_account._utils.legacy_transactions import (
     encode_transaction,
     serializable_unsigned_transaction_from_dict,
 )
-from eth_utils import keccak, to_int
+from eth_utils import decode_hex, encode_hex, keccak, to_int
 from ethpm_types import HexBytes
+from ethpm_types.abi import EventABI
 from pydantic import BaseModel, Field, root_validator, validator
 from rich.console import Console as RichConsole
 
 from ape.api import ReceiptAPI, TransactionAPI
+from ape.contracts import ContractEvent
 from ape.exceptions import OutOfGasError, SignatureError, TransactionError
+from ape.types import ContractLog
 from ape.utils import CallTraceParser, TraceStyles
 
 
@@ -79,7 +82,7 @@ class StaticFeeTransaction(BaseTransaction):
     type: Union[str, int, bytes] = Field(TransactionType.STATIC.value, exclude=True)
     max_fee: Optional[int] = Field(None, exclude=True)
 
-    @root_validator(pre=True)
+    @root_validator(pre=True, allow_reuse=True)
     def calculate_read_only_max_fee(cls, values) -> Dict:
         # NOTE: Work-around, Pydantic doesn't handle calculated fields well.
         values["max_fee"] = values.get("gas_limit", 0) * values.get("gas_price", 0)
@@ -97,7 +100,7 @@ class DynamicFeeTransaction(BaseTransaction):
     type: Union[int, str, bytes] = Field(TransactionType.DYNAMIC.value)
     access_list: List[AccessList] = Field(default_factory=list, alias="accessList")
 
-    @validator("type")
+    @validator("type", allow_reuse=True)
     def check_type(cls, value):
 
         if isinstance(value, TransactionType):
@@ -115,7 +118,7 @@ class AccessListTransaction(BaseTransaction):
     type: Union[int, str, bytes] = Field(TransactionType.ACCESS_LIST.value)
     access_list: List[AccessList] = Field(default_factory=list, alias="accessList")
 
-    @validator("type")
+    @validator("type", allow_reuse=True)
     def check_type(cls, value):
 
         if isinstance(value, TransactionType):
@@ -177,3 +180,76 @@ def show_trace(self, verbose: bool = False, file: IO[str] = sys.stdout):
 
         console.print(f"txn.origin=[{TraceStyles.CONTRACTS}]{self.sender}[/]")
         console.print(root)
+
+    def decode_logs(
+        self,
+        abi: Optional[
+            Union[List[Union[EventABI, "ContractEvent"]], Union[EventABI, "ContractEvent"]]
+        ] = None,
+    ) -> Iterator[ContractLog]:
+        if abi:
+            if not isinstance(abi, (list, tuple)):
+                abi = [abi]
+
+            event_abis: List[EventABI] = [a.abi if not isinstance(a, EventABI) else a for a in abi]
+            yield from self.provider.network.ecosystem.decode_logs(self.logs, *event_abis)
+
+        else:
+            # If ABI is not provided, decode all events
+            addresses = {x["address"] for x in self.logs}
+            contract_types = self.chain_manager.contracts.get_multiple(addresses)
+            # address → selector → abi
+            selectors = {
+                address: {encode_hex(keccak(text=abi.selector)): abi for abi in contract.events}
+                for address, contract in contract_types.items()
+            }
+            for log in self.logs:
+                contract_address = log["address"]
+                if contract_address not in selectors:
+                    continue
+                try:
+                    selector = encode_hex(log["topics"][0])
+                    event_abi = selectors[contract_address][selector]
+                except KeyError:
+                    # Likely a library log
+                    library_log = self._decode_ds_note(log)
+                    if library_log:
+                        yield library_log
+                else:
+                    yield from self.provider.network.ecosystem.decode_logs([log], event_abi)
+
+    def _decode_ds_note(self, log: Dict) -> Optional[ContractLog]:
+        # The first topic encodes the function selector
+        selector, tail = log["topics"][0][:4], log["topics"][0][4:]
+        if sum(tail):
+            # non-zero bytes found after selector
+            return None
+
+        contract_type = self.chain_manager.contracts.get(log["address"])
+        if contract_type is None:
+            # contract type for {log['address']} not found
+            return None
+
+        try:
+            method_abi = contract_type.mutable_methods[selector]
+        except KeyError:
+            #  selector {selector.hex()} not found in {log['address']}
+            return None
+
+        # ds-note data field uses either (uint256,bytes) or (bytes) encoding
+        # instead of guessing, assume the payload begins right after the selector
+        data = decode_hex(log["data"])
+        input_types = [i.canonical_type for i in method_abi.inputs]
+        start_index = data.index(selector) + 4
+        values = decode_abi(input_types, data[start_index:])
+        address = self.provider.network.ecosystem.decode_address(log["address"])
+
+        return ContractLog(
+            block_hash=log["blockHash"],
+            block_number=log["blockNumber"],
+            contract_address=address,
+            event_arguments={i.name: value for i, value in zip(method_abi.inputs, values)},
+            log_index=log["logIndex"],
+            name=method_abi.name,
+            transaction_hash=log["transactionHash"],
+        )  # type: ignore

tests/functional/conftest.py

@@ -21,19 +21,20 @@
 from ape.types import AddressType, ContractLog
 
 
-def _get_raw_contract(compiler: str) -> Dict:
+def _get_raw_contract(name: str) -> Dict:
     here = Path(__file__).parent
     contracts_dir = here / "data" / "contracts" / "ethereum" / "local"
-    return json.loads((contracts_dir / f"{compiler}_contract.json").read_text())
+    return json.loads((contracts_dir / f"{name}.json").read_text())
 
 
 ALIAS = "__FUNCTIONAL_TESTS_ALIAS__"
 ALIAS_2 = "__FUNCTIONAL_TESTS_ALIAS_2__"
-RAW_SOLIDITY_CONTRACT_TYPE = _get_raw_contract("solidity")
-RAW_VYPER_CONTRACT_TYPE = _get_raw_contract("vyper")
+RAW_SOLIDITY_CONTRACT_TYPE = _get_raw_contract("solidity_contract")
+RAW_VYPER_CONTRACT_TYPE = _get_raw_contract("vyper_contract")
 TEST_ADDRESS = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
 BASE_PROJECTS_DIRECTORY = (Path(__file__).parent / "data" / "projects").absolute()
 PROJECT_WITH_LONG_CONTRACTS_FOLDER = BASE_PROJECTS_DIRECTORY / "LongContractsFolder"
+DS_NOTE_TEST_CONTRACT_TYPE = _get_raw_contract("ds_note_test")
 APE_PROJECT_FOLDER = BASE_PROJECTS_DIRECTORY / "ApeProject"
 SOLIDITY_CONTRACT_ADDRESS = "0xBcF7FFFD8B256Ec51a36782a52D0c34f6474D951"
 VYPER_CONTRACT_ADDRESS = "0x274b028b03A250cA03644E6c578D81f019eE1323"
@@ -200,6 +201,13 @@ def contract_instance(request, solidity_contract_instance, vyper_contract_instan
     return solidity_contract_instance if request.param == "solidity" else vyper_contract_instance
 
 
+@pytest.fixture
+def ds_note_test_contract(vyper_contract_type, owner, eth_tester_provider):
+    contract_type = ContractType.parse_obj(DS_NOTE_TEST_CONTRACT_TYPE)
+    contract_container = ContractContainer(contract_type=contract_type)
+    return contract_container.deploy(sender=owner)
+
+
 @pytest.fixture(scope="session")
 def temp_config(config):
     @contextmanager
@@ -259,6 +267,46 @@ def base_projects_directory():
     return BASE_PROJECTS_DIRECTORY
 
 
+@pytest.fixture
+def mainnet_contract(chain):
+    def contract_getter(address):
+        path = (
+            Path(__file__).parent
+            / "data"
+            / "contracts"
+            / "ethereum"
+            / "mainnet"
+            / f"{address}.json"
+        )
+        contract = ContractType.parse_file(path)
+        chain.contracts._local_contracts[address] = contract
+        return contract
+
+    return contract_getter
+
+
+@pytest.fixture
+def ds_note():
+    return {
+        "address": "0x35D1b3F3D7966A1DFe207aa4514C12a259A0492B",
+        "topics": [
+            HexBytes("0x7608870300000000000000000000000000000000000000000000000000000000"),
+            HexBytes("0x5946492d41000000000000000000000000000000000000000000000000000000"),
+            HexBytes("0x0000000000000000000000000abb839063ef747c8432b2acc60bf8f70ec09a45"),
+            HexBytes("0x0000000000000000000000000abb839063ef747c8432b2acc60bf8f70ec09a45"),
+        ],
+        "data": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000e0760887035946492d410000000000000000000000000000000000000000000000000000000000000000000000000000000abb839063ef747c8432b2acc60bf8f70ec09a450000000000000000000000000abb839063ef747c8432b2acc60bf8f70ec09a450000000000000000000000000abb839063ef747c8432b2acc60bf8f70ec09a450000000000000000000000000000000000000000000000000000000000000000fffffffffffffffffffffffffffffffffffffffffffa050e82a57b7fc6b6020c00000000000000000000000000000000000000000000000000000000",  # noqa: E501
+        "blockNumber": 14623434,
+        "transactionHash": HexBytes(
+            "0xa322a9fd0e627e22bfe1b0877cca1d1f2e697d076007231d0b7a366d1a0fdd51"
+        ),
+        "transactionIndex": 333,
+        "blockHash": HexBytes("0x0fd77b0af3fa471aa040a02d4fcd1ec0a35122a4166d0bb7c31354e23823de49"),
+        "logIndex": 376,
+        "removed": False,
+    }
+
+
 @pytest.fixture
 def chain_at_block_5(chain):
     snapshot_id = chain.snapshot()