yearn-treasury 0.0.26__cp312-cp312-macosx_11_0_arm64.whl → 0.0.45__cp312-cp312-macosx_11_0_arm64.whl

yearn_treasury/__init__.py

@@ -2,9 +2,11 @@ import warnings
 
 from yearn_treasury import budget
 from yearn_treasury._db import prepare_db
+from yearn_treasury._logging import setup_eth_portfolio_logging
 
 
 prepare_db()
+setup_eth_portfolio_logging()
 
 
 warnings.filterwarnings(

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

@@ -0,0 +1,43 @@
+# mypy: disable-error-code="list-item"
+"""
+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
+
+from cchecksum import to_checksum_address
+from eth_portfolio._utils import SUPPRESS_ERROR_LOGS
+from eth_typing import HexAddress
+from y import Network
+
+from yearn_treasury.constants import CHAINID
+
+
+suppress_logs_for: Final[Dict[Network, List[HexAddress]]] = {
+    Network.Mainnet: [
+        "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/budget/__init__.py

@@ -1,6 +1,6 @@
 from yearn_treasury.budget._request import BudgetRequest
-from yearn_treasury.budget._requests import approved_requests, rejected_requests, requests
+from yearn_treasury.budget._requests import approved_requests, budget_requests, rejected_requests
 
 # TODO test
 
-__all__ = ["BudgetRequest", "requests", "approved_requests", "rejected_requests"]
+__all__ = ["BudgetRequest", "budget_requests", "approved_requests", "rejected_requests"]

yearn_treasury/budget/_requests.py

@@ -7,12 +7,16 @@ requests.
 """
 
 import os
-from requests import get
-from typing import Final, List
+import time
+import requests
+from typing import Any, Dict, Final, List
 
 from yearn_treasury.budget._request import BudgetRequest
 
 
+API_URL: Final = "https://api.github.com/repos/yearn/budget/issues"
+"""URL to fetch issues from the repo."""
+
 # Optionally use a GitHub personal access token for higher API rate limits.
 # TODO move this to envs file and document
 _TOKEN: Final = os.environ.get("GITHUB_TOKEN")
@@ -20,20 +24,14 @@ _HEADERS: Final = {"Authorization": f"token {_TOKEN}"} if _TOKEN else {}
 
 
 def fetch_brs() -> List[BudgetRequest]:
-    # URL to fetch issues from the repo
-    api_url = "https://api.github.com/repos/yearn/budget/issues"
     # Use parameters to fetch issues in all states, up to 100 per page.
-    params = {"state": "all", "per_page": 100, "page": 1}
+    current_page = 1
+    params = {"state": "all", "per_page": 100, "page": current_page}
 
     brs = []
     retries = 0
     while True:
-        response = get(api_url, headers=_HEADERS, params=params)  # type: ignore [arg-type]
-        if response.status_code != 200:
-            if retries < 5:
-                retries += 1
-                continue
-            raise ConnectionError(f"Failed to fetch issues: {response.status_code} {response.text}")
+        response = _make_get_request(params=params)
 
         data: List[dict] = response.json()  # type: ignore [type-arg]
         if not data:  # If the current page is empty, we are done.
@@ -67,11 +65,32 @@ def fetch_brs() -> List[BudgetRequest]:
             brs.append(br)
 
         # Move on to the next page.
-        params["page"] += 1  # type: ignore [operator]
+        current_page += 1
+        params["page"] = current_page
 
     return brs
 
 
-requests = fetch_brs()
-approved_requests = [r for r in requests if r.is_approved()]
-rejected_requests = [r for r in requests if r.is_rejected()]
+def _make_get_request(params: Dict[str, Any]) -> Any:
+    retries = 0
+    while True:
+        try:
+            response = requests.get(API_URL, headers=_HEADERS, params=params)
+            response.raise_for_status()
+            return response
+        except requests.HTTPError as e:
+            if "rate limit exceeded" in str(e):
+                print("Github API rate limited...")
+            elif retries < 5:
+                print(e)
+            else:
+                raise ConnectionError(
+                    f"Failed to fetch issues: {response.status_code} {response.text}"
+                ) from e
+            retries += 1
+            time.sleep(5 * (retries + 1))
+
+
+budget_requests: Final = fetch_brs()
+approved_requests: Final = [r for r in budget_requests if r.is_approved()]
+rejected_requests: Final = [r for r in budget_requests if r.is_rejected()]

yearn_treasury/constants.py

@@ -30,6 +30,10 @@ YCHAD_MULTISIGS: Final = {
     Network.Base: "0xbfAABa9F56A39B814281D68d2Ad949e88D06b02E",
 }
 
+YSWAP_MULTISIGS: Final = {
+    Network.Mainnet: "0x7d2aB9CA511EBD6F03971Fb417d3492aA82513f0",
+}
+
 
 if CHAINID not in TREASURY_MULTISIGS or CHAINID not in YCHAD_MULTISIGS:
     raise RuntimeError(f"{Network(CHAINID)} is not supported")
@@ -39,6 +43,8 @@ TREASURY_MULTISIG: Final = convert.to_address(TREASURY_MULTISIGS[CHAINID])  # ty
 
 YCHAD_MULTISIG: Final = convert.to_address(YCHAD_MULTISIGS[CHAINID])  # type: ignore [index]
 
+__yswap_multisig = YSWAP_MULTISIGS.get(CHAINID)  # type: ignore [call-overload]
+YSWAP_MULTISIG: Final = convert.to_address(__yswap_multisig) if __yswap_multisig else None
 
 _TREASURY_WALLETS: Final = {
     Network.Mainnet: {
@@ -46,7 +52,7 @@ _TREASURY_WALLETS: Final = {
         YCHAD_MULTISIG,
         "0xb99a40fcE04cb740EB79fC04976CA15aF69AaaaE",  # Yearn Treasury V1
         "0x5f0845101857d2A91627478e302357860b1598a1",  # Yearn KP3R Wallet
-        "0x7d2aB9CA511EBD6F03971Fb417d3492aA82513f0",  # ySwap Multisig
+        YSWAP_MULTISIG,
         "0x2C01B4AD51a67E2d8F02208F54dF9aC4c0B778B6",  # yMechs Multisig
         "0xE376e8e8E3B0793CD61C6F1283bA18548b726C2e",  # Fee Reimbursement Stash
         "0xC001d00d425Fa92C4F840baA8f1e0c27c4297a0B",  # New token dumping wallet

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")
@@ -39,6 +48,12 @@ run_parser.add_argument(
     help="The time interval between datapoints. Default: 12h",
     default="12h",
 )
+run_parser.add_argument(
+    "--concurrency",
+    type=int,
+    help="The max number of historical blocks to export concurrently. default: 30",
+    default=30,
+)
 run_parser.add_argument(
     "--daemon",
     action="store_true",
@@ -77,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
@@ -109,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
@@ -118,6 +132,9 @@ def main() -> None:
         interval: Final[str] = args.interval
         """Time interval between snapshots."""
 
+        concurrency: Final[int] = args.concurrency
+        """The max number of historical blocks to export concurrently."""
+
         grafana_port: Final[int] = args.grafana_port
         """Grafana port."""
 
@@ -140,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/maker.py

@@ -40,11 +40,11 @@ def is_yfi_cdp_deposit(tx: TreasuryTx) -> bool:
         for event in tx.get_events("slip"):
             if all(arg in event for arg in DEPOSIT_EVENT_ARGS):
                 # TODO: remove this rounding once we move to postgres
-                if Decimal(event["wad"]) / 10**18 == tx.amount:
+                scaled = round(Decimal(event["wad"]) / 10**18, 12)
+                rounded = round(tx.amount, 12)
+                if scaled == rounded:
                     return True
-                print(
-                    f"yfi cdp deposit amount no match [{Decimal(event['wad']) / 10**18}, {tx.amount}"
-                )
+                print(f"yfi cdp deposit amount no match [{scaled}, {rounded}]")
     return False
 
 
@@ -56,11 +56,11 @@ def is_yfi_cdp_withdrawal(tx: TreasuryTx) -> bool:
         for event in tx.get_events("flux"):
             if all(arg in event for arg in WITHDRAWAL_EVENT_ARGS):
                 # TODO: remove this rounding once we move to postgres
-                if Decimal(event["wad"]) / 10**18 == tx.amount:
+                scaled = round(Decimal(event["wad"]) / 10**18, 12)
+                rounded = round(tx.amount, 12)
+                if scaled == rounded:
                     return True
-                print(
-                    f"yfi cdp withdrawal amount no match [{Decimal(event['wad']) / 10**18}, {tx.amount}"
-                )
+                print(f"yfi cdp withdrawal amount no match [{scaled}, {rounded}]")
     return False
 
 
@@ -71,11 +71,10 @@ def is_usdc_cdp_deposit(tx: TreasuryTx) -> bool:
     ):
         for event in tx.get_events("slip"):
             if all(arg in event for arg in DEPOSIT_EVENT_ARGS):
-                if Decimal(event["wad"]) / 10**18 == tx.amount:
+                scaled = Decimal(event["wad"]) / 10**18
+                if scaled == tx.amount:
                     return True
-                print(
-                    f"usdc cdp deposit amount no match [{Decimal(event['wad']) / 10**18}, {tx.amount}"
-                )
+                print(f"usdc cdp deposit amount no match [{scaled}, {tx.amount}]")
     return False
 
 
@@ -86,9 +85,8 @@ def is_usdc_cdp_withdrawal(tx: TreasuryTx) -> bool:
     ):
         for event in tx.get_events("flux"):
             if all(arg in event for arg in WITHDRAWAL_EVENT_ARGS):
-                if Decimal(event["wad"]) / 10**18 == tx.amount:
+                scaled = Decimal(event["wad"]) / 10**18
+                if scaled == tx.amount:
                     return True
-                print(
-                    f"usdc cdp withdrawal amount no match [{Decimal(event['wad']) / 10**18}, {tx.amount}"
-                )
+                print(f"usdc cdp withdrawal amount no match [{scaled}, {tx.amount}]")
     return False

yearn_treasury/rules/ignore/passthru.py

@@ -2,9 +2,10 @@ from decimal import Decimal
 from typing import Final, Tuple
 
 from dao_treasury import TreasuryTx, TreasuryWallet, ignore
+from eth_typing import BlockNumber, ChecksumAddress
 from y import Network
 
-from yearn_treasury.constants import CHAINID, ZERO_ADDRESS
+from yearn_treasury.constants import CHAINID, YSWAP_MULTISIG, ZERO_ADDRESS
 
 
 passthru: Final = ignore("Pass-Thru")
@@ -22,12 +23,11 @@ def is_sent_to_dinoswap(tx: TreasuryTx) -> bool:
 @passthru("Bribes for yCRV", Network.Mainnet)
 def is_ycrv(tx: TreasuryTx) -> bool:
     """These are routed thru cowswap with dai as the purchase token."""
-    yswaps = "0x7d2aB9CA511EBD6F03971Fb417d3492aA82513f0"
     ymechs = "0x2C01B4AD51a67E2d8F02208F54dF9aC4c0B778B6"
 
     from_address = tx.from_address
     symbol = tx.symbol
-    if (from_address == yswaps and symbol == "DAI") or (
+    if (from_address == YSWAP_MULTISIG and symbol == "DAI") or (
         from_address == ymechs and symbol == "3Crv"
     ):
         if tx.to_address == cowswap_router:
@@ -41,13 +41,12 @@ def is_ycrv(tx: TreasuryTx) -> bool:
                     fee_amount,
                     order_uid,
                 ) = trade.values()
-                if (
-                    tx.from_address == owner
-                    and tx.token == sell_token
-                    and buy_token == ycrv
-                    and Decimal(sell_amount) / 10**18 == tx.amount
-                ):
-                    return True
+                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 round(scaled, 11) == round(tx.amount, 11):
+                        return True
+                    print(f"bribes for ycrv amount no match: [{scaled}, {tx.amount}]")
 
     elif tx.hash in {
         # one off exception case to correct accounting mix-up
@@ -260,3 +259,52 @@ def is_misc_passthru_fantom(tx: TreasuryTx) -> bool:
         if not is_deposit:
             return True
     return False
+
+
+@passthru("yvBoost INCOMPLETE", Network.Mainnet)
+def is_buying_yvboost(tx: TreasuryTx) -> bool:
+    """Bought back yvBoost is unwrapped and sent back to vault holders."""
+    symbol = tx.symbol
+    block: BlockNumber = tx.block  # type: ignore [assignment]
+    from_address: ChecksumAddress = tx.from_address.address  # type: ignore [union-attr, assignment]
+    to_address: ChecksumAddress = tx.to_address.address  # type: ignore [union-attr, assignment]
+    if (
+        symbol == "SPELL"
+        and TreasuryWallet.check_membership(from_address, block)
+        and to_address == cowswap_router
+    ):
+        return True
+
+    elif (
+        symbol == "yveCRV-DAO"
+        and TreasuryWallet.check_membership(from_address, block)
+        and to_address
+        in (
+            "0xd7240B32d24B814fE52946cD44d94a2e3532E63d",
+            "0x7fe508eE30316e3261079e2C81f4451E0445103b",
+        )
+    ):
+        return True
+
+    elif (
+        symbol == "3Crv"
+        and from_address == "0xd7240B32d24B814fE52946cD44d94a2e3532E63d"
+        and TreasuryWallet.check_membership(to_address, block)
+    ):
+        return True
+
+    # SPELL bribe handling
+    elif symbol == "SPELL":
+        if tx.to_nickname in ("Abracadabra Treasury", "Contract: BribeSplitter"):
+            return True
+
+    return tx in (
+        "0x9eabdf110efbfb44aab7a50eb4fe187f68deae7c8f28d78753c355029f2658d3",
+        "0x5a80f5ff90fc6f4f4597290b2432adbb62ab4154ead68b515accdf19b01c1086",
+        "0x848b4d629e137ad8d8eefe5db40eab895c9959b9c210d0ae0fef16a04bfaaee1",
+        "0x896663aa9e2633b5d152028bdf84d7f4b1137dd27a8e61daca3863db16bebc4f",
+        "0xd8aa1e5d093a89515530b7267a9fd216b97fddb6478b3027b2f5c1d53070cd5f",
+        "0x169aab84b408fce76e0b776ebf412c796240300c5610f0263d5c09d0d3f1b062",
+        "0xe6fefbf061f4489cd967cdff6aa8aca616f0c709e08c3696f12b0027e9e166c9",
+        "0x10be8a3345660f3c51b695e8716f758b1a91628bd612093784f0516a604f79c1",
+    )

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

@@ -39,24 +39,31 @@ async def is_aave_withdrawal(tx: TreasuryTx) -> bool:
     ):
         token = tx.token
         if hasattr(token.contract, "underlyingAssetAddress"):
-            for event in tx.get_events("RedeemUnderlying"):
+            for event in await tx.get_events("RedeemUnderlying", sync=False):
                 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 tx.get_events("RedeemUnderlying"):
-            if (
-                token == event["_reserve"]
-                and to_address == event["_user"]
-                and token.scale_value(event["_amount"]) == tx.amount
-            ):
-                return True
+        for event in await tx.get_events("RedeemUnderlying", sync=False):
+            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