yearn-treasury 0.0.32__cp310-cp310-macosx_11_0_arm64.whl → 0.0.48__cp310-cp310-macosx_11_0_arm64.whl

yearn_treasury/_db.py

@@ -20,6 +20,14 @@ from yearn_treasury import constants
 
 
 def prepare_db() -> None:
+    """
+    Set up address nicknames in the Yearn Treasury database.
+
+    Maps key Yearn Treasury addresses to human-readable labels for improved
+    clarity in analytics and reporting. This function is typically called
+    during database preparation to ensure wallet addresses are labeled
+    within the DAO Treasury database entity system.
+    """
     chad = {Network.Mainnet: "y", Network.Fantom: "f"}[CHAINID]  # type: ignore [index]
 
     labels = {

yearn_treasury/_logging.py

@@ -1,6 +1,13 @@
 # mypy: disable-error-code="list-item"
 """
-This file contains logic for suppressing eth-portfolio error logs where desired.
+Error log suppression utilities for the Yearn Treasury exporter.
+
+This module suppresses noisy or irrelevant eth-portfolio error logs for specific
+token addresses that are known to be deprecated or otherwise unpricable.
+
+To suppress logs for additional tokens, add their addresses to the
+`suppress_logs_for[Network.<chain>]` mapping. The rest will be done
+automatically on package import.
 """
 
 from typing import Dict, Final, List
@@ -18,10 +25,19 @@ suppress_logs_for: Final[Dict[Network, List[HexAddress]]] = {
         "0xBF7AA989192b020a8d3e1C65a558e123834325cA",  # unpriceable yvWBTC - This vault had a bug and does not have a pricePerShare
         "0x5aFE3855358E112B5647B952709E6165e1c1eEEe",  # SAFE - This was not tradeable at the time of the first airdrops
         "0x718AbE90777F5B778B52D553a5aBaa148DD0dc5D",  # yvCurve-alETH - The underlying curve pool had an issue and is unpriceable
+        "0x3819f64f282bf135d62168C1e513280dAF905e06",  # HDRN
+        "0x5fAa989Af96Af85384b8a938c2EdE4A7378D9875",  # GAL
     ],
 }
 
 
 def setup_eth_portfolio_logging() -> None:
+    """
+    Suppress eth-portfolio error logs for specific tokens on the current chain.
+
+    Appends token addresses from the suppress_logs_for mapping (for the current
+    CHAINID) to the SUPPRESS_ERROR_LOGS list, preventing error logs for these
+    tokens from being emitted during analytics and reporting.
+    """
     for token in suppress_logs_for.get(CHAINID, []):  # type: ignore [call-overload]
         SUPPRESS_ERROR_LOGS.append(to_checksum_address(token))

yearn_treasury/address_labels.yaml

@@ -28,6 +28,12 @@
     - "0xC564EE9f21Ed8A2d8E7e76c085740d5e4c5FaFbE"
   yLockers Multisig:
     - "0x4444AAAACDBa5580282365e25b16309Bd770ce4a"
+  yRoboTreasury Treasury Contract:
+    - "0xEf77cc176c748d291EfB6CdC982c5744fC7211c8"
+  yRoboTreasury Stables Reserve:
+    - "0x278374fFb10B7D16E7633444c13e6E565EA57c28"
+  yearn.fi Dutch Auctions:
+    - "0x861fE45742f70054917B65bE18904662bD0dBd30"
 250:
   Yearn Strategist Multisig:
     - "0x72a34AbafAB09b15E7191822A679f28E067C4a16"

yearn_treasury/constants.py

@@ -87,3 +87,6 @@ class Args:
 
     nicknames: Final[Path] = _YEARN_TREASURY_ROOT_DIR / "address_labels.yaml"
     """The path where yearn-treasury's address nicknames are defined."""
+
+    custom_bucket: Final[list[str]] = [f"{YFI}:Other long term assets"]
+    """Custom bucket mapping for token addresses, tells DAO Treasury to categorize YFI as 'Other long term assets'."""

yearn_treasury/main.py

@@ -2,9 +2,9 @@
 Command-line interface for the Yearn Treasury exporter.
 
 This module provides the `yearn-treasury` CLI, which connects to a Brownie network
-based on the `--network` option (or the `BROWNIE_NETWORK_ID` environment variable),
-periodically snapshots treasury balances via :func:`export_balances`, and
-pushes metrics to Victoria Metrics.
+(based on the `--network` option or the `BROWNIE_NETWORK_ID` environment variable),
+periodically snapshots treasury metrics, and pushes them to Victoria Metrics.
+It also launches Yearn Treasury's Grafana dashboard and an optional renderer for visual reports.
 
 Example:
     Run export every 12 hours on mainnet:
@@ -12,15 +12,24 @@ Example:
     .. code-block:: bash
 
         yearn-treasury run --network mainnet --interval 12h
+
+CLI Options:
+    --network         Brownie network identifier (default: mainnet)
+    --interval        Time interval between datapoints (default: 12h)
+    --concurrency     Max number of historical blocks to export concurrently (default: 30)
+    --daemon          Run as a background daemon (currently unsupported)
+    --grafana-port    Port for the Grafana dashboard (default: 3004)
+    --victoria-port   Port for the Victoria metrics endpoint (default: 8430)
+    --start-renderer  Start the Grafana renderer container for dashboard image export
+    --renderer-port   Port for the renderer service (default: 8080)
 """
 
 import asyncio
 import os
 from argparse import ArgumentParser
-from pathlib import Path
 from typing import Final, final
 
-from eth_portfolio_scripts.balances import export_balances
+from yearn_treasury import yteams
 
 
 parser = ArgumentParser(description="Treasury CLI")
@@ -42,8 +51,8 @@ run_parser.add_argument(
 run_parser.add_argument(
     "--concurrency",
     type=int,
-    help="The max number of historical blocks to export concurrently. default: 50",
-    default=50,
+    help="The max number of historical blocks to export concurrently. default: 30",
+    default=30,
 )
 run_parser.add_argument(
     "--daemon",
@@ -83,23 +92,19 @@ BROWNIE_NETWORK = os.environ["BROWNIE_NETWORK_ID"]
 # TODO: run forever arg
 def main() -> None:
     """
-    Connect to the configured Brownie network and start the export loop.
+    Connect to the configured Brownie network, clean up the database, and start the export loop.
 
     This function is registered as a console script entrypoint under
-    ``yearn-treasury`` and delegates execution to Brownie's script runner.
-
-    Steps:
+    ``yearn-treasury``. It performs the following steps:
         1. Reads the ``BROWNIE_NETWORK_ID`` environment variable (populated from
            the ``--network`` option or existing env var).
-        2. Connects to that Brownie network.
-        3. Patches the global SHITCOINS mapping with local tokens.
-        4. Constructs a frozen Args subclass to pass CLI parameters to
-           :func:`export_balances`.
-        5. Exports ports for external services into environment variables.
-        6. Runs :func:`eth_portfolio_scripts.balances.export_balances` under asyncio.
-
-    Raises:
-        RuntimeError: If the Brownie network cannot be determined.
+        2. Connects to the specified Brownie network.
+        3. Merges local SHITCOINS into eth_portfolio's config to skip tokens we don't care about.
+        4. Drops any shitcoin transactions that might be in the database.
+        5. Constructs an immutable Args subclass to pass CLI parameters to
+           :func:`dao_treasury.main.export`.
+        6. Exports ports for external services into environment variables.
+        7. Runs both the DAO Treasury export and Yearn team revenue/expenses calculation concurrently under asyncio.
     """
     import dao_treasury.db
     import eth_portfolio
@@ -115,7 +120,10 @@ def main() -> None:
     @final
     class Args(constants.Args):
         """
-        Immutable container of CLI arguments for :func:`~export_balances`.
+        Immutable container of CLI arguments for export and dashboard/renderer configuration.
+
+        Inherits from DAO Treasury's :class:`constants.Args` and is used to pass runtime
+        parameters to the DAO Treasury export and related services.
         """
 
         network: Final[str] = args.network
@@ -149,7 +157,20 @@ def main() -> None:
     os.environ["DAO_TREASURY_RENDERER_PORT"] = str(Args.renderer_port)
     os.environ["VICTORIA_PORT"] = str(Args.victoria_port)
 
+    async def yearn_wrapper():
+        """
+        Run the DAO Treasury export and Yearn team revenue/expenses calculation concurrently.
+
+        This coroutine gathers:
+            - The main DAO Treasury export process (dao_treasury.main.export)
+            - The Yearn teams' revenue and expenses calculation (yteams.calculate_teams_revenue_expenses)
+        """
+        return await asyncio.gather(
+            dao_treasury.main.export(Args),
+            yteams.calculate_teams_revenue_expenses(),
+        )
+
     # Start the balance export routine
-    asyncio.get_event_loop().run_until_complete(dao_treasury.main.export(Args))
+    asyncio.get_event_loop().run_until_complete(yearn_wrapper())
 
     rules  # I just put this here so the import isn't flagged as unused

yearn_treasury/rules/__init__.py

@@ -1,6 +1,20 @@
+import os
+
+__ALRU_ENV_NAME = "ASYNC_LRU_ALLOW_SYNC"
+__ALRU_ENV_VAL = os.environ.get(__ALRU_ENV_NAME)
+os.environ[__ALRU_ENV_NAME] = "1"
+
 from yearn_treasury.rules.cost_of_revenue import *
 from yearn_treasury.rules.expense import *
 from yearn_treasury.rules.ignore import *
 from yearn_treasury.rules.other_expense import *
 from yearn_treasury.rules.other_income import *
 from yearn_treasury.rules.revenue import *
+
+if __ALRU_ENV_VAL is None:
+    os.environ.pop(__ALRU_ENV_NAME)
+else:
+    os.environ[__ALRU_ENV_NAME] = __ALRU_ENV_VAL
+
+del __ALRU_ENV_NAME
+del __ALRU_ENV_VAL

yearn_treasury/rules/ignore/passthru.py

@@ -44,7 +44,7 @@ def is_ycrv(tx: TreasuryTx) -> bool:
                 if tx.from_address == owner and tx.token == sell_token and buy_token == ycrv:
                     scaled = Decimal(sell_amount) / 10**18
                     # TODO: remove this rounding when we implement postgres
-                    if scaled == tx.amount:
+                    if round(scaled, 11) == round(tx.amount, 11):
                         return True
                     print(f"bribes for ycrv amount no match: [{scaled}, {tx.amount}]")
 

yearn_treasury/rules/ignore/swaps/__init__.py

@@ -7,6 +7,7 @@ swaps: Final[SortRuleFactory[IgnoreSortRule]] = ignore("Swaps")
 
 
 from yearn_treasury.rules.ignore.swaps.aave import *
+from yearn_treasury.rules.ignore.swaps.auctions import *
 from yearn_treasury.rules.ignore.swaps.compound import *
 from yearn_treasury.rules.ignore.swaps.conversion_factory import *
 from yearn_treasury.rules.ignore.swaps.cowswap import *

yearn_treasury/rules/ignore/swaps/aave.py

@@ -43,20 +43,27 @@ async def is_aave_withdrawal(tx: TreasuryTx) -> bool:
                 if (
                     from_address == event["_user"]
                     and await token.contract.underlyingAssetAddress == event["_reserve"]
-                    and token.scale_value(event["_amount"]) == tx.amount
                 ):
-                    return True
+                    # TODO get rid of this rounding when we migrate the db to postgres
+                    event_amount = round(token.scale_value(event["_amount"]), 11)
+                    if event_amount == round(tx.amount, 11):
+                        return True
+                    print(
+                        f"Aave Withdrawal atoken side does not match: {round(tx.amount, 14)}  {event_amount}"
+                    )
 
     # Underlying side
     if TreasuryWallet.check_membership(tx.to_address.address, tx.block):  # type: ignore [union-attr, arg-type]
         token = tx.token
         for event in await tx.get_events("RedeemUnderlying", sync=False):
-            if (
-                token == event["_reserve"]
-                and to_address == event["_user"]
-                and token.scale_value(event["_amount"]) == tx.amount
-            ):
-                return True
+            if token == event["_reserve"] and to_address == event["_user"]:
+                # TODO get rid of this rounding when we migrate the db to postgres
+                event_amount = round(token.scale_value(event["_amount"]), 11)
+                if event_amount == round(tx.amount, 11):
+                    return True
+                print(
+                    f"Aave Withdrawal underlying side does not match: {round(tx.amount, 14)}  {event_amount}"
+                )
 
     # TODO: If these end up becoming more frequent, figure out sorting hueristics.
     return tx.hash == "0x36ee5631859a15f57b44e41b8590023cf6f0c7b12d28ea760e9d8f8003f4fc50"

yearn_treasury/rules/ignore/swaps/auctions.py

@@ -0,0 +1,31 @@
+from typing import Final
+
+from dao_treasury import TreasuryTx
+from y import Network
+
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+auctions: Final = swaps("Auctions")
+
+YEARNFI_DUTCH_AUCTIONS: Final = "0x861fE45742f70054917B65bE18904662bD0dBd30"
+
+
+@auctions("Auction Proceeds", Network.Mainnet)
+async def is_auction_proceeds(tx: TreasuryTx) -> bool:
+    # NOTE: the other side of these swaps is currently recorded under
+    # 'Ignore:Internal Transfer' when it goes to the Generic bucket contract
+    if tx.from_nickname != "Contract: GPv2Settlement":
+        return False
+
+    for trade in await tx.get_events("Trade", sync=False):
+        if trade["owner"] != YEARNFI_DUTCH_AUCTIONS or tx.token != trade["buyToken"]:
+            continue
+        buy_amount = tx.token.scale_value(trade["buyAmount"])
+        if round(buy_amount, 14) == round(tx.amount, 14):
+            return True
+        print(
+            f"auction proceeds amount does not match: {round(buy_amount, 14)}  {round(tx.amount, 14)}"
+        )
+
+    return False

yearn_treasury/rules/ignore/swaps/compound.py

@@ -15,17 +15,21 @@ async def is_compound_deposit(tx: TreasuryTx) -> bool:
             minter = event["minter"]
             minted = tx.token.scale_value(event["mintTokens"])
             # cToken side
-            if (
-                tx.token == tx.from_address == event.address
-                and tx.to_address == minter
-                and minted == tx.amount
-            ):
-                return True
+            if tx.token == tx.from_address == event.address and tx.to_address == minter:
+                # TODO: get rid of this rounding when we migrate to postgres
+                if round(minted, 14) == round(tx.amount, 14):
+                    return True
+                print(
+                    f"Compound deposit ctoken side does not match: {round(minted, 14)}  {round(tx.amount, 14)}"
+                )
             # underlying side
-            elif (
-                tx.to_address == event.address and tx.from_address == minter and minted == tx.amount
-            ):
-                return True
+            elif tx.to_address == event.address and tx.from_address == minter:
+                # TODO: get rid of this rounding when we migrate to postgres
+                if round(minted, 14) == round(tx.amount, 14):
+                    return True
+                print(
+                    f"Compound deposit underlying side does not match: {round(minted, 14)}  {round(tx.amount, 14)}"
+                )
     return False
 
 
@@ -36,13 +40,19 @@ async def is_compound_withdrawal(tx: TreasuryTx) -> bool:
             redeemer = event["redeemer"]
             redeemed = tx.token.scale_value(event["redeemTokens"])
             # cToken side
-            if tx.token == event.address and tx.from_address == redeemer and redeemed == tx.amount:
-                return True
+            if tx.token == event.address and tx.from_address == redeemer:
+                # TODO: get rid of this rounding when we migrate to postgres
+                if round(redeemed, 7) == round(tx.amount, 7):
+                    return True
+                print(
+                    f"Compound withdrawal ctoken side does not match: {round(redeemed, 7)}  {round(tx.amount, 7)}"
+                )
             # underlying side
-            elif (
-                tx.to_address == redeemer
-                and tx.from_address == event.address
-                and redeemed == tx.amount
-            ):
-                return True
+            elif tx.to_address == redeemer and tx.from_address == event.address:
+                # TODO: get rid of this rounding when we migrate to postgres
+                if round(redeemed, 14) == round(tx.amount, 14):
+                    return True
+                print(
+                    f"Compound withdrawal underlying side does not match: {round(redeemed, 14)}  {round(tx.amount, 14)}"
+                )
     return False

yearn_treasury/rules/ignore/swaps/cowswap.py

@@ -10,7 +10,7 @@ from yearn_treasury.rules.ignore.swaps import swaps
 from yearn_treasury.rules.ignore.swaps._skip_tokens import SKIP_TOKENS
 
 
-YSWAPS: Final = "0x9008D19f58AAbD9eD0D60971565AA8510560ab41"
+COWSWAP: Final = "0x9008D19f58AAbD9eD0D60971565AA8510560ab41"
 
 
 @swaps("Cowswap", Network.Mainnet)
@@ -34,23 +34,26 @@ def is_cowswap_swap(tx: TreasuryTx) -> bool:
 
     for trade in tx.events["Trade"]:
         if (
-            trade.address == YSWAPS
+            trade.address == COWSWAP
             and TreasuryWallet.check_membership(trade["owner"], block)
             and trade["buyToken"] not in SKIP_TOKENS
         ):
             # buy side
-            if (
-                token_address == trade["buyToken"]
-                and TreasuryWallet.check_membership(tx.to_address.address, block)  # type: ignore [union-attr, arg-type]
-                and amount == token.scale_value(trade["buyAmount"])
+            if token_address == trade["buyToken"] and TreasuryWallet.check_membership(
+                tx.to_address.address, block  # type: ignore [union-attr, arg-type]
             ):
-                return True
+                # TODO get rid of this rounding when we move to postgres
+                buy_amount = round(token.scale_value(trade["buyAmount"]), 8)
+                if round(amount, 8) == buy_amount:
+                    return True
+                print(f"Cowswap buy amount does not match: {round(amount, 8)}   {buy_amount}")
             # sell side
-            elif (
-                token_address == trade["sellToken"]
-                and tx.from_address == trade["owner"]
-                and amount == token.scale_value(trade["sellAmount"])
-            ):
+            elif token_address == trade["sellToken"] and tx.from_address == trade["owner"]:
+                # TODO get rid of this rounding when we move to postgres
+                sell_amount = round(token.scale_value(trade["sellAmount"]), 8)
+                if round(amount, 8) != sell_amount:
+                    print(f"Cowswap sell amount does not match: {round(amount, 8)}   {sell_amount}")
+                    continue
                 # Did Yearn actually receive the other side of the trade?
                 for address in TREASURY_WALLETS:
                     if TreasuryWallet.check_membership(address, block):
@@ -59,7 +62,7 @@ def is_cowswap_swap(tx: TreasuryTx) -> bool:
                             for t in TreasuryTx  # type: ignore [attr-defined]
                             if t.hash == tx.hash
                             and t.token.address.address == trade["buyToken"]
-                            and t.from_address.address == YSWAPS
+                            and t.from_address.address == COWSWAP
                             and t.to_address.address == address
                         )
 

yearn_treasury/rules/ignore/swaps/curve.py

@@ -1,10 +1,10 @@
 from typing import Final
 
-from async_lru import alru_cache
 from brownie.exceptions import EventLookupError
 from brownie.network.event import _EventItem
 from dao_treasury import TreasuryTx, TreasuryWallet
 from eth_typing import ChecksumAddress
+from faster_async_lru import alru_cache
 from y import Contract, Network
 
 from yearn_treasury.constants import CHAINID, ZERO_ADDRESS
@@ -50,11 +50,19 @@ async def is_curve_deposit(tx: TreasuryTx) -> bool:
         # Tokens sent
         elif tx.to_address == event.address:
             try:
+                tx_amount = round(tx.amount, 8)
                 for i, amount in enumerate(event["token_amounts"]):
-                    if tx.amount == tx.token.scale_value(amount):
+                    # TODO: get rid of this rounding when we migrate to postgres
+                    event_amount = round(tx.token.scale_value(amount), 8)
+                    if tx_amount == event_amount:
                         pool = await Contract.coroutine(event.address)  # type: ignore [assignment]
                         if tx.token == await _get_coin_at_index(pool, i):
                             return True
+                        return True
+                else:
+                    print(
+                        f"Curve AddLiquidity sent amount does not match: {tx_amount}  {event_amount}"
+                    )
             except EventLookupError:
                 pass
 
@@ -67,10 +75,16 @@ async def is_curve_deposit(tx: TreasuryTx) -> bool:
             print(f"AddLiquidity-3crv: {event}")
             token = tx.token
             for i, amount in enumerate(event["token_amounts"]):
-                if tx.amount == token.scale_value(amount):
+                event_amount = token.scale_value(amount)
+                # TODO: get rid of this rounding when we migrate to postgres
+                if round(tx.amount, 14) == round(event_amount, 14):
                     pool = await Contract.coroutine(event.address)  # type: ignore [assignment]
                     if token == await _get_coin_at_index(pool, i):
                         return True
+                else:
+                    print(
+                        f"AddLiquidity-3crv amount does not match: {round(tx.amount, 14)}  {round(event_amount)}"
+                    )
 
     # TODO: see if we can remove these with latest hueristics
     return CHAINID == Network.Mainnet and tx.hash in (
@@ -98,17 +112,24 @@ async def is_curve_withdrawal(tx: TreasuryTx) -> bool:
 def _is_curve_withdrawal_one(tx: TreasuryTx) -> bool:
     for event in tx.get_events("RemoveLiquidityOne"):
         # LP Token Side
-        if (
-            tx.to_address == ZERO_ADDRESS
-            and _token_is_curvey(tx)
-            and tx.amount == tx.token.scale_value(event["token_amount"])
-        ):
-            return True
+        if tx.to_address == ZERO_ADDRESS and _token_is_curvey(tx):
+            # TODO: get rid of this rounding when we migrate to postgres
+            event_amount = round(tx.token.scale_value(event["token_amount"]), 9)
+            if round(tx.amount, 9) == event_amount:
+                return True
+            print(
+                f"Curve withdrawal one curvey amount does not match: {round(tx.amount, 9)}  {event_amount}"
+            )
         # Tokens rec'd
-        elif tx.from_address == event.address and tx.amount == tx.token.scale_value(
-            event["coin_amount"]
-        ):
+        if tx.from_address != event.address:
+            continue
+        # TODO: get rid of this rounding when we migrate to postgres
+        event_amount = tx.token.scale_value(event["coin_amount"])
+        if round(tx.amount, 9) == round(event_amount, 9):
             return True
+        print(
+            f"Curve withdrawal one amount does not match: {round(tx.amount, 9)}  {round(event_amount, 9)}"
+        )
     return False
 
 
@@ -120,19 +141,29 @@ async def _is_curve_withdrawal_multi(tx: TreasuryTx) -> bool:
             pool = await Contract.coroutine(event.address)  # type: ignore [assignment]
             if await _is_old_style(tx, pool) or _is_new_style(tx, pool):
                 return True
-            print(f"wtf is this: {tx}")
+            print(
+                f"unhandled curve pool: {tx} symbol={tx.symbol} name={tx.token.name} address={tx.token_address}"
+            )
         # Tokens rec'd
         elif tx.from_address == event.address and TreasuryWallet.check_membership(
             tx.to_address.address, tx.block  # type: ignore [union-attr, arg-type]
         ):
+            tx_amount = round(tx.amount, 7)
             try:
                 for i, amount in enumerate(event["token_amounts"]):
-                    if tx.amount == tx.token.scale_value(amount):
+                    # TODO: get rid of this rounding when we migrate to postgres
+                    event_amount = round(tx.token.scale_value(amount), 7)
+                    if tx_amount == event_amount:
                         pool = await Contract.coroutine(event.address)  # type: ignore [assignment]
                         if hasattr(pool, "underlying_coins"):
-                            return tx.token == await pool.underlying_coins.coroutine(i)
+                            coin: ChecksumAddress = await pool.underlying_coins.coroutine(i)
+                            return tx.token == coin
                         else:
                             return tx.token == await _get_coin_at_index(pool, i)
+                    else:
+                        print(
+                            f"Curve withdrawal multi amount does not match: {tx_amount}  {event_amount}"
+                        )
             except EventLookupError:
                 # some other event has different keys, maybe we need to implement logic to capture these. time will tell.
                 pass

yearn_treasury/rules/ignore/swaps/iearn.py

@@ -1,5 +1,5 @@
 # mypy: disable-error-code=dict-item
-from typing import Dict, Final
+from typing import Dict, Final, cast
 
 from dao_treasury import TreasuryTx
 from eth_typing import ChecksumAddress
@@ -36,8 +36,8 @@ POOL_TO_UNDERLYING: Final[Dict[ChecksumAddress, ChecksumAddress]] = {
 def is_iearn_withdrawal(tx: TreasuryTx) -> bool:
     # Vault side
     if tx.to_address == ZERO_ADDRESS:
-        return tx.token.address.address in POOLS
+        return tx.token_address in POOLS
     # Token side
-    from_address: ChecksumAddress = tx.from_address.address  # type: ignore [union-attr, assignment]
-    token_address = tx.token.address.address
+    from_address = cast(ChecksumAddress, tx.from_address.address)
+    token_address = tx.token_address
     return POOL_TO_UNDERLYING.get(from_address) == token_address