yearn-treasury 0.0.18__cp310-cp310-win32.whl → 0.0.46__cp310-cp310-win32.whl

yearn_treasury/rules/ignore/maker.py

@@ -1,3 +1,11 @@
+"""
+Ignore rules for Maker protocol.
+
+This module defines matching logic for Maker protocol transactions,
+including DAI minting/burning, DSR deposit/withdrawal, and CDP
+deposit/withdrawal for YFI and USDC.
+"""
+
 from decimal import Decimal
 from typing import Final
 
@@ -26,55 +34,59 @@ dsr("Withdrawal").match(from_nickname="Contract: DsrManager")
 
 @cdp("YFI Deposit")
 def is_yfi_cdp_deposit(tx: TreasuryTx) -> bool:
-    if tx.symbol == "YFI" and TreasuryWallet._get_instance(
-        tx.from_address.address  # type: ignore [union-attr, arg-type]
+    if tx.symbol == "YFI" and TreasuryWallet.check_membership(
+        tx.from_address.address, tx.block  # type: ignore [union-attr, arg-type]
     ):
         for event in tx.get_events("slip"):
-            if (
-                all(arg in event for arg in DEPOSIT_EVENT_ARGS)
-                and Decimal(event["wad"]) / 10**18 == tx.amount
-            ):
-                return True
+            if all(arg in event for arg in DEPOSIT_EVENT_ARGS):
+                # TODO: remove this rounding once we move to postgres
+                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 [{scaled}, {rounded}]")
     return False
 
 
 @cdp("YFI Withdrawal")
 def is_yfi_cdp_withdrawal(tx: TreasuryTx) -> bool:
-    if tx.symbol == "YFI" and TreasuryWallet._get_instance(
-        tx.to_address.address  # type: ignore [union-attr, arg-type]
+    if tx.symbol == "YFI" and TreasuryWallet.check_membership(
+        tx.to_address.address, tx.block  # type: ignore [union-attr, arg-type]
     ):
         for event in tx.get_events("flux"):
-            if (
-                all(arg in event for arg in WITHDRAWAL_EVENT_ARGS)
-                and Decimal(event["wad"]) / 10**18 == tx.amount
-            ):
-                return True
+            if all(arg in event for arg in WITHDRAWAL_EVENT_ARGS):
+                # TODO: remove this rounding once we move to postgres
+                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 [{scaled}, {rounded}]")
     return False
 
 
 @cdp("USDC Deposit")
 def is_usdc_cdp_deposit(tx: TreasuryTx) -> bool:
-    if tx.symbol == "USDC" and TreasuryWallet._get_instance(
-        tx.from_address.address  # type: ignore [union-attr, arg-type]
+    if tx.symbol == "USDC" and TreasuryWallet.check_membership(
+        tx.from_address.address, tx.block  # type: ignore [union-attr, arg-type]
     ):
         for event in tx.get_events("slip"):
-            if (
-                all(arg in event for arg in DEPOSIT_EVENT_ARGS)
-                and Decimal(event["wad"]) / 10**18 == tx.amount
-            ):
-                return True
+            if all(arg in event for arg in DEPOSIT_EVENT_ARGS):
+                scaled = Decimal(event["wad"]) / 10**18
+                if scaled == tx.amount:
+                    return True
+                print(f"usdc cdp deposit amount no match [{scaled}, {tx.amount}]")
     return False
 
 
 @cdp("USDC Withdrawal")
 def is_usdc_cdp_withdrawal(tx: TreasuryTx) -> bool:
-    if tx.symbol == "USDC" and TreasuryWallet._get_instance(
-        tx.to_address.address  # type: ignore [union-attr, arg-type]
+    if tx.symbol == "USDC" and TreasuryWallet.check_membership(
+        tx.to_address.address, tx.block  # type: ignore [union-attr, arg-type]
     ):
         for event in tx.get_events("flux"):
-            if (
-                all(arg in event for arg in WITHDRAWAL_EVENT_ARGS)
-                and Decimal(event["wad"]) / 10**18 == tx.amount
-            ):
-                return True
+            if all(arg in event for arg in WITHDRAWAL_EVENT_ARGS):
+                scaled = Decimal(event["wad"]) / 10**18
+                if scaled == tx.amount:
+                    return True
+                print(f"usdc cdp withdrawal amount no match [{scaled}, {tx.amount}]")
     return False

yearn_treasury/rules/ignore/passthru.py

@@ -1,9 +1,12 @@
 from decimal import Decimal
-from typing import Final
+from typing import Final, Tuple
 
-from dao_treasury import TreasuryTx, ignore
+from dao_treasury import TreasuryTx, TreasuryWallet, ignore
+from eth_typing import BlockNumber, ChecksumAddress
 from y import Network
 
+from yearn_treasury.constants import CHAINID, YSWAP_MULTISIG, ZERO_ADDRESS
+
 
 passthru: Final = ignore("Pass-Thru")
 
@@ -20,10 +23,12 @@ 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"
-    if (tx.from_address == yswaps and tx.symbol == "DAI") or (
-        tx.from_address == ymechs and tx.symbol == "3Crv"
+
+    from_address = tx.from_address
+    symbol = tx.symbol
+    if (from_address == YSWAP_MULTISIG and symbol == "DAI") or (
+        from_address == ymechs and symbol == "3Crv"
     ):
         if tx.to_address == cowswap_router:
             for trade in tx.get_events("Trade"):
@@ -36,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
@@ -148,3 +152,159 @@ def is_idle(tx: TreasuryTx) -> bool:
         "0x55d89a5890cfe80da06f6831fdfa3a366c0ed9cf9b7f1b4d53f5007bb9698fa0",
         "0x6c6fc43dca1841af82b517bc5fc53ea8607e3f95512e4dd3009c0dbb425669f7",
     }
+
+
+_factory_strat_to_yield_tokens = {
+    "Contract: StrategyCurveBoostedFactoryClonable": ("CRV", "LDO"),
+    "Contract: StrategyConvexFactoryClonable": ("CRV", "CVX"),
+    "Contract: StrategyConvexFraxFactoryClonable": ("CRV", "CVX", "FXS"),
+}
+
+
+@passthru("Factory Vault Yield", Network.Mainnet)
+def is_factory_vault_yield(tx: TreasuryTx) -> bool:
+    return tx.to_nickname == "yMechs Multisig" and tx.symbol in _factory_strat_to_yield_tokens.get(
+        tx.from_nickname, ()
+    )
+
+
+@passthru("CowSwap Migration", Network.Mainnet)
+def is_cowswap_migration(tx: TreasuryTx) -> bool:
+    """A one-time tx that transferred tokens from an old contract to its replacement."""
+    return tx.hash == "0xb50341d3db2ff4a39b9bfa21753893035554ae44abb7d104ab650753db1c4855"
+
+
+def is_curve_bribe(tx: TreasuryTx) -> bool:
+    """All present and future curve bribes are committed to yveCRV holders."""
+    from_nickname = tx.from_nickname
+    if from_nickname == "Contract: CurveYCRVVoter" and tx.hash not in [
+        # took place before bribes were committed to yveCRV
+        "0x6824345c8a0c1f0b801d8050bb6f587032c4a9fa153faa113d723a2068d844f4",
+        # was a whitehat hack of the v1 bribe contract, necessary to safeguard user funds
+        "0xfcef3911809770fe351b2b526e4ee0274589a3f7d6ef9408a8f5643fa006b771",
+    ]:
+        return True
+
+    # Bribe V3
+    elif from_nickname == "Contract: yBribe" and tx.to_nickname in [
+        "Yearn Treasury",
+        "ySwap Multisig",
+    ]:
+        return True
+
+    # NOTE: I added this one-off to capture tokens sent to BribeSplitter 0x527e80008D212E2891C737Ba8a2768a7337D7Fd2
+    return tx.hash == "0xce45da7e3a7616ed0c0d356d6dfa8a784606c9a8034bae9faa40abf7b52be114"
+
+
+_pass_thru_hashes: Tuple[str, ...] = {
+    Network.Mainnet: ("0xf662c68817c56a64b801181a3175c8a7e7a5add45f8242990c695d418651e50d",),
+    Network.Fantom: (
+        "0x411d0aff42c3862d06a0b04b5ffd91f4593a9a8b2685d554fe1fbe5dc7e4fc04",
+        "0xa347da365286cc912e4590fc71e97a5bcba9e258c98a301f85918826538aa021",
+    ),
+}.get(
+    CHAINID, ()
+)  # type: ignore [call-overload]
+
+
+@passthru("Misc.", Network.Mainnet)
+def is_misc_passthru_mainnet(tx: TreasuryTx) -> bool:
+    # not sure if we still need this, TODO figure it out
+    # NOTE skipped the hashmatcher to do strange things ... there is probably a better way to do this
+    if tx.hash in _pass_thru_hashes and str(tx.log_index).lower() != "nan":
+        return True
+
+    txhash = tx.hash
+    if txhash in {
+        "0xae6797ad466de75731117df46ccea5c263265dd6258d596b9d6d8cf3a7b1e3c2",
+        "0x2a6191ba8426d3ae77e2a6c91de10a6e76d1abdb2d0f831c6c5aad52be3d6246",
+        # https://github.com/yearn/chief-multisig-officer/pull/924
+        "0x25b54e113e58a3a4bbffc011cdfcb8c07a0424f33b0dbda921803d82b88f1429",
+        "0xcb000dd2b623f9924fe0234831800950a3269b2d412ce9eeabb0ec65cd737059",
+    }:
+        return True
+    # do these need hueristics? build real sort logic if these keep reoccurring
+    elif txhash == "0x14faeac8ee0734875611e68ce0614eaf39db94a5ffb5bc6f9739da6daf58282a" and (
+        tx.symbol in ("CRV", "CVX", "yPRISMA") or tx.log_index == 254
+    ):
+        return True
+    return False
+
+
+@passthru("Misc.", Network.Fantom)
+def is_misc_passthru_fantom(tx: TreasuryTx) -> bool:
+    # not sure if we still need this, TODO figure it out
+    # NOTE skipped the hashmatcher to do strange things ... there is probably a better way to do this
+    if tx.hash in _pass_thru_hashes and str(tx.log_index).lower() != "nan":
+        return True
+
+    if tx.hash == "0x14faeac8ee0734875611e68ce0614eaf39db94a5ffb5bc6f9739da6daf58282a":
+        return True
+    # Passing thru to yvWFTM
+    if (
+        tx.symbol == "WFTM"
+        and TreasuryWallet.check_membership(tx.from_address.address, tx.block)  # type: ignore [arg-type, union-attr]
+        and tx.to_address == "0x0DEC85e74A92c52b7F708c4B10207D9560CEFaf0"
+    ):
+        # dont want to accidenally sort a vault deposit here
+        is_deposit = False
+        for event in tx.get_events("Transfer"):
+            sender, receiver, _ = event.values()
+            if (
+                tx.to_address == event.address
+                and sender == ZERO_ADDRESS
+                and tx.from_address == receiver
+            ):
+                is_deposit = True
+        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,5 +7,19 @@ 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 *
+from yearn_treasury.rules.ignore.swaps.curve import *
+from yearn_treasury.rules.ignore.swaps.gearbox import *
+from yearn_treasury.rules.ignore.swaps.iearn import *
+from yearn_treasury.rules.ignore.swaps.otc import *
+from yearn_treasury.rules.ignore.swaps.pooltogether import *
+from yearn_treasury.rules.ignore.swaps.synthetix import *
 from yearn_treasury.rules.ignore.swaps.uniswap import *
+from yearn_treasury.rules.ignore.swaps.unwrapper import *
+from yearn_treasury.rules.ignore.swaps.vaults import *
+from yearn_treasury.rules.ignore.swaps.woofy import *
+from yearn_treasury.rules.ignore.swaps.yfi import *
+from yearn_treasury.rules.ignore.swaps.yla import *

yearn_treasury/rules/ignore/swaps/aave.py

@@ -1,6 +1,16 @@
+"""
+Ignore rules for Aave-related transactions.
+
+This module defines rules for identifying and ignoring Aave-related
+transactions in the Yearn Treasury system. It provides matching logic
+for deposit and withdrawal events, so these transactions can be
+ignored in analytics and reporting.
+"""
+
 from typing import Final
 
 from dao_treasury import TreasuryTx, TreasuryWallet
+from eth_typing import ChecksumAddress
 
 from yearn_treasury.rules.constants import ZERO_ADDRESS
 from yearn_treasury.rules.ignore.swaps import swaps
@@ -20,29 +30,40 @@ def is_aave_deposit(tx: TreasuryTx) -> bool:
 
 @aave("Withdrawal")
 async def is_aave_withdrawal(tx: TreasuryTx) -> bool:
+    from_address: ChecksumAddress = tx.from_address.address  # type: ignore [union-attr, assignment]
+    to_address: ChecksumAddress = tx.to_address.address  # type: ignore [union-attr, assignment]
     # Atoken side
     if (
-        TreasuryWallet._get_instance(tx.from_address.address)  # type: ignore [union-attr, arg-type]
-        and tx.to_address == ZERO_ADDRESS
-        and hasattr(tx.token.contract, "underlyingAssetAddress")
+        TreasuryWallet.check_membership(from_address, tx.block)  # type: ignore [union-attr, arg-type]
+        and to_address == ZERO_ADDRESS
     ):
-        for event in tx.get_events("RedeemUnderlying"):
-            if (
-                tx.from_address == event["_user"]
-                and await tx.token.contract.underlyingAssetAddress == event["_reserve"]
-                and tx.token.scale_value(event["_amount"]) == tx.amount
-            ):
-                return True
+        token = tx.token
+        if hasattr(token.contract, "underlyingAssetAddress"):
+            for event in await tx.get_events("RedeemUnderlying", sync=False):
+                if (
+                    from_address == event["_user"]
+                    and await token.contract.underlyingAssetAddress == event["_reserve"]
+                ):
+                    # 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._get_instance(tx.to_address.address):  # type: ignore [union-attr, arg-type]
-        for event in tx.get_events("RedeemUnderlying"):
-            if (
-                tx.token == event["_reserve"]
-                and tx.to_address == event["_user"]
-                and tx.token.scale_value(event["_amount"]) == tx.amount
-            ):
-                return True
+    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"]:
+                # 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

@@ -9,40 +9,50 @@ compound: Final = swaps("Compound")
 
 
 @compound("Deposit")
-def is_compound_deposit(tx: TreasuryTx) -> bool:
-    for event in tx.get_events("Mint"):
+async def is_compound_deposit(tx: TreasuryTx) -> bool:
+    for event in await tx.get_events("Mint", sync=False):
         if all(arg in event for arg in ("minter", "mintTokens", "mintAmount")):
             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
 
 
 @compound("Withdrawal")
-def is_compound_withdrawal(tx: TreasuryTx) -> bool:
-    for event in tx.get_events("Redeem"):
+async def is_compound_withdrawal(tx: TreasuryTx) -> bool:
+    for event in await tx.get_events("Redeem", sync=False):
         if all(arg in event for arg in ("redeemer", "redeemTokens", "redeemAmount")):
             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/conversion_factory.py

@@ -0,0 +1,21 @@
+from typing import Final
+
+from dao_treasury import TreasuryTx
+
+from yearn_treasury.rules.ignore.swaps import swaps
+
+
+CONVERSION_FACTORY: Final = "0x8E6A115bd8e24d2D86A1AacCC56221e5Bd4577ba"
+ROBOTREASURY: Final = "0xEf77cc176c748d291EfB6CdC982c5744fC7211c8"
+GENERIC_BUCKET: Final = "0x278374fFb10B7D16E7633444c13e6E565EA57c28"
+SOME_RELATED_NON_VERIFIED_CONTRACT: Final = "0x5CECc042b2A320937c04980148Fc2a4b66Da0fbF"
+
+
+@swaps("Conversion Factory")
+def is_conversion_factory(tx: TreasuryTx) -> bool:
+    # TODO: track the balances that are held by the conversion factory but not yet dumped
+    from_address = tx.from_address.address  # type: ignore [union-attr]
+    to_address = tx.to_address.address  # type: ignore [union-attr]
+    return (from_address == GENERIC_BUCKET and to_address == CONVERSION_FACTORY) or (
+        from_address == SOME_RELATED_NON_VERIFIED_CONTRACT and to_address == ROBOTREASURY
+    )

yearn_treasury/rules/ignore/swaps/cowswap.py

@@ -0,0 +1,87 @@
+from typing import Final
+
+from dao_treasury import TreasuryTx, TreasuryWallet
+from eth_typing import BlockNumber
+from pony.orm import select
+from y import Network
+
+from yearn_treasury.constants import TREASURY_WALLETS
+from yearn_treasury.rules.ignore.swaps import swaps
+from yearn_treasury.rules.ignore.swaps._skip_tokens import SKIP_TOKENS
+
+
+COWSWAP: Final = "0x9008D19f58AAbD9eD0D60971565AA8510560ab41"
+
+
+@swaps("Cowswap", Network.Mainnet)
+def is_cowswap_swap(tx: TreasuryTx) -> bool:
+    # One sided, other side goes elsewhere. typically used for output tokens passed-thru to vaults.
+    if tx.from_nickname == "yMechs Multisig" and tx.to_nickname == "Contract: GPv2Settlement":
+        return True
+
+    try:
+        if "Trade" not in tx.events:
+            return False
+    except KeyError as e:
+        if "components" in str(e):
+            return False
+        raise
+
+    token = tx.token
+    block: BlockNumber = tx.block  # type: ignore [assignment]
+    amount = tx.amount
+    token_address = token.address.address
+
+    for trade in tx.events["Trade"]:
+        if (
+            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]
+            ):
+                # 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"]:
+                # 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):
+                        other_side_query = select(
+                            t
+                            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 == COWSWAP
+                            and t.to_address.address == address
+                        )
+
+                        if len(other_side_query) > 0:
+                            return True
+
+    # made with some help from other contracts
+    return tx.hash in {
+        "0xd41e40a0e9b49c4f06e1956066006de901a4ed8c856a43c31ac1cbd344ff0ccf",
+        "0x94e1a85fa25e433976962449588e522ce0f2a81ae3d4b67ae199e458dfce4e39",
+        "0x579056f777c1f05a18e566dd329ea85f5c747fd6e7246411b5e016c8bebe8742",
+        "0xd007d04560fc42df93da0fd25ac3942f89f7f5458eb492872b3d87be91d7a571",
+        "0x2eb9a897ea48c9802f0129674d0203835a236e2f41c6db8edb017a4c315b84f4",
+        "0xce2338b61c8c5875ce4e19f9d5993895a4d5d9eb81b78e1b33279436d2c2c047",
+        "0x6dd14144594e7b19fdc4529682eb1cf554132ae318d8ba5b238cdeb3e694d52a",
+        "0xb0d430e1ec4d6fa7bd4e56f86e6fefd7f71946549710ca0b9f39de14c04d02ed",
+        "0x0b1b00f0a29f787b44421461a3f9444081fe94ca29958c98cd2c23e271f3f69a",
+        "0x69eeeb5d7cb0f23ee98ef23f38d02ff0a695d75a1da1fa010abaa7a5aab947ff",
+        "0xdfbe76c0af4ec68021c1603d4f9a6b5f20734e70af86d32fbd57fa87461064f2",
+        "0x60cfe7c2c19e1fc3010e441ed369fc414bd10dbb7ba88fb4f490d96e15eb2f26",
+        "0x1ddddfff1f02c66ef07817144e9e30d6f734432c2736f7859236d3199d4b23fb",
+    }